{"id":2084,"date":"2020-08-16T16:21:35","date_gmt":"2020-08-16T10:51:35","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=2084"},"modified":"2020-08-16T20:24:42","modified_gmt":"2020-08-16T14:54:42","slug":"pattern-matching-comparing-elixir-and-mathematica","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2020\/08\/16\/pattern-matching-comparing-elixir-and-mathematica\/","title":{"rendered":"Pattern Matching: Comparing Elixir and Mathematica"},"content":{"rendered":"

One of the things I like about Elixir<\/strong><\/em><\/a>\u00a0is its support for patterns at the core language level, not through library functions as in most other languages. This contributes to writing cleaner code, in my opinion. \u00a0<\/span><\/p>\n

Another environment that I am familiar with, namely Mathematica<\/strong><\/em><\/a>, boasts of (arguably) the most powerful symbolic programming language called “Wolfram Language”<\/strong><\/em>. Mathematica<\/strong><\/em> is primarily used in mathematical and scientific programming. Patterns and Rules are all-pervasive in this language.<\/p>\n

It is not fair to compare these two languages since each addresses a different kind of problem. Elixir<\/strong><\/em> is meant for highly scalable and fault tolerant general-purpose computing, whereas Mathematica<\/strong><\/em> excels in complex symbolic (and numeric) computations, and over the years has been extended to include Neural Networks, Machine Learning, Natural Language Understanding, and so on.<\/p>\n

In this article, I am going to compare the pattern matching ideas supported by Elixir<\/strong><\/em> and Mathematica<\/strong><\/em>.\u00a0 <\/span>Even this is a vast topic to address, so I will limit the discussion to the most striking aspects of pattern matching.\u00a0<\/span><\/p>\n

In the following sections, when I use the term “Mathematica”<\/strong><\/em>, I actually mean “Wolfram Language”<\/strong><\/em>.\u00a0<\/span><\/p>\n

The \u201c=\u201d Operator<\/span><\/h3>\n

Let us start with a simple idea. In Elixir<\/strong><\/em>, the operator \u201c=\u201d<\/strong><\/em> is called \u201cPattern Matching\u201d<\/strong><\/em> operator, not an \u201cAssignment Operator\u201d<\/strong><\/em>, although the operation can involve assignment. Look at the following example:<\/p>\n

\"Pattern<\/a>
Pattern Matching Operator<\/strong><\/figcaption><\/figure>\n

Here, the two patterns will match only if X, Y, <\/strong><\/em>and Z\u00a0<\/strong><\/em>are bound respectively to 1, 2 and 3. This causes the values to be bound to the variables. The operator, in this case, behaves like the assignment operator.<\/p>\n

Here is a slight variation:<\/p>\n

\"Pattern<\/a>
Pattern Matching (Contd.)<\/strong><\/figcaption><\/figure>\n

In this case, the first value of the LHS tuple is a constant and hence for the pattern to succeed, the RHS must have the same first element. The match succeeds since this is true, and Y<\/strong><\/em> and Z<\/strong><\/em> are bound as before.<\/p>\n

What happens if there is a pattern mismatch? The following example shows this.<\/p>\n

\"Pattern<\/a>
Pattern Mismatch<\/strong><\/figcaption><\/figure>\n

I hope you understand what is going on. There are other interesting variations of the pattern matching operator in Elixir<\/strong><\/em>, but we will not get into those here.<\/p>\n

Coming to Mathematica<\/strong><\/em>, the \u201c=\u201d<\/strong><\/em> operator is the traditional \u201cAssignment\u201d<\/strong><\/em> operator. No pattern matching is occurs here. The following example is similar to what we tried in Elixir<\/strong><\/em>:<\/p>\n

\"Assignment<\/a>
Assignment in Mathematica<\/strong><\/figcaption><\/figure>\n

There is no surprise here since it merely involves assignment to the 3 variables on LHS. Now consider this:<\/p>\n

\"Invalid<\/a>
Invalid Assignment<\/strong><\/figcaption><\/figure>\n

Since we cannot assign to a constant on the LHS, the above fails. There is no attempt to \u201cpattern match\u201d<\/strong><\/em> in this case.<\/p>\n

As the above examples show, the \u201c=\u201d<\/strong><\/em> operator in Elixir<\/strong><\/em> is more general than Mathematica\u2019s<\/strong><\/em> assignment operator.<\/p>\n

Case Statement<\/span><\/h3>\n

Elixir<\/strong><\/em> differs from most other programming languages in that it supports patterns (instead of simple conditions) in the \u201ccase\u201d<\/strong><\/em> statement. Here is an example:<\/p>\n

\"Case<\/a>
Case Statement in Elixir<\/strong><\/figcaption><\/figure>\n

Notice how we use a \u201cguard\u201d<\/strong><\/em> along with the first pattern to check if the second element of the list is greater than 10. The second pattern matches any element in the second position of the list. The third pattern only checks if the expression is a list without considering its internal structure. The last condition will match anything that hasn\u2019t matched the earlier three patterns. In this case, the given list \u201c[1, 11, 3]\u201d<\/strong><\/em> matches the first pattern.<\/p>\n

Here is the same code as above but with the expression \u201c[1, 9, 3]\u201d<\/strong><\/em>. It matches the second pattern.<\/p>\n

\"Case<\/a>
Case Statement (Contd.)<\/strong><\/figcaption><\/figure>\n

What is the result if we pass a 4-element list instead of a 3-element list? The third “qualified”<\/strong><\/em> pattern matches.<\/p>\n

\"Case<\/a>
Case Statement (Contd.)<\/strong><\/figcaption><\/figure>\n

Finally, we pass a \u201cstring\u201d<\/strong> <\/em>instead of a list. In this case, the \u201ccatch all\u201d<\/strong><\/em> pattern matches!<\/p>\n

\"Case<\/a>
Case Statement (Contd.)<\/strong><\/figcaption><\/figure>\n

Mathematica<\/strong><\/em> uses \u201cSwitch\u201d<\/strong><\/em> instead of \u201ccase\u201d<\/strong><\/em>. Otherwise, the structure is quite similar. The following examples correspond to the above Elixir<\/strong><\/em> examples:<\/p>\n

\"Mathematica<\/a>
Mathematica Switch Statement<\/strong><\/figcaption><\/figure>\n

The operator “\/;”<\/strong><\/em> puts constraints on the associated pattern. The following matches the second condition.<\/p>\n

\"Switch<\/a>
Switch Statement (Contd.)<\/strong><\/figcaption><\/figure>\n

The following matches the third condition, a pattern that matches any “List”<\/strong><\/em>.<\/p>\n

\"Switch<\/a>
Switch Statement (Contd.)<\/strong><\/figcaption><\/figure>\n

The last case corresponds to a “non-List”<\/strong><\/em> expression.<\/p>\n

\"Switch<\/a>
Switch Statement (Contd.)<\/strong><\/figcaption><\/figure>\n

As you can observe, the behaviour is quite similar to Elixir<\/strong><\/em>.<\/p>\n

Patterns and Guards in Functions<\/span><\/h3>\n

Both Elixir<\/strong><\/em> and Mathematica<\/strong><\/em> allow \u201cguards\u201d<\/strong><\/em> (or conditions) to be associated with function definitions. This is quite powerful. Let us go through an example to see how this is done.<\/p>\n

Suppose that we want to compute the nth<\/sup><\/strong> \u201cFibonacci\u201d<\/strong><\/em> number. Here is one way to do this in Elixir<\/strong><\/em>:<\/p>\n

\"Computing<\/a>
Computing Fibonacci Number<\/strong><\/figcaption><\/figure>\n

Instead of coding the different trivial cases in a single function, we split the logic across multiple definitions. Notice also, how we are able to associate a \u201cguard\u201d<\/strong><\/em> or condition with the third definition to check if the passed argument is an integer (we take for granted that the argument is positive).\u00a0<\/span><\/p>\n

Here is yet another way. We have merged the first two definitions by introducing a \u201cguard\u201d<\/strong><\/em>.<\/p>\n

\"Fibonacci<\/a>
Fibonacci (Contd.)<\/strong><\/figcaption><\/figure>\n

It is important to keep in mind that Elixir<\/strong><\/em> tries the functions in the order of definition. So, if we change the order as in the following case, it will not work.<\/p>\n

\"Invalid<\/a>
Invalid Definition Order<\/strong><\/figcaption><\/figure>\n

How do we write this function in Mathematica<\/strong><\/em>? The following implementation corresponds to the first version we wrote in Elixir<\/strong><\/em>.<\/p>\n

\"Fibonacci<\/a>
Fibonacci Function in Mathematica<\/strong><\/figcaption><\/figure>\n

Mathematica<\/strong><\/em> too allows us to use \u201cconditions\u201d<\/strong> <\/em>as part of function definition. The code given below matches the second version we wrote in Elixir<\/strong><\/em>.<\/p>\n

\"Fibonacci<\/a>
Fibonacci (Contd.)<\/strong><\/figcaption><\/figure>\n

A nice thing about Mathematica<\/strong><\/em> is that there is no restriction on the order in which the definitions must be provided. So, even the following will work correctly.<\/p>\n

\"Order<\/a>
Order is not Important<\/strong>\u00a0<\/span><\/figcaption><\/figure>\n

Arbitrary Pattern-based Transformations in Mathematica<\/span><\/h4>\n

Unlike Elixir<\/strong><\/em>, Mathematica<\/strong><\/em> allows us to define functions that work with symbolic expressions. Take a look at the following snippet:<\/p>\n

\"Symbolic<\/a>
Working with Symbolic Expressions<\/strong><\/figcaption><\/figure>\n

The first line above defines a function that takes two arguments. The first argument can be anything as denoted by the pattern \u201cx_\u201d<\/strong><\/em>. The second argument must be an expression of the form \u201cx_ raised to the power of anything\u201d<\/strong><\/em>. Given two arguments like this, this function applies another function \u201cp\u201d<\/strong> to 2 times \u201cx\u201d<\/strong><\/em> (remember \u201cx\u201d<\/strong><\/em> refers to the first argument).<\/p>\n

The second and third lines show what happens when this function is called with \u201c(m+n)\u201d<\/strong><\/em> and \u201c(m+n)<\/em> 3<\/sup>\u201d<\/strong>. The fourth and fifth lines show another valid invocation example. In both these cases, the argument structure<\/strong><\/em> is maintained and hence the expected transformation takes place. The last two lines show what happens when the second argument does not satisfy the required structure (it uses \u201cn\u201d<\/strong><\/em> instead of \u201cm\u201d<\/strong><\/em>).<\/p>\n

As the final example of pattern transformations, Mathematica<\/strong><\/em> has a special \u201csubstitution\u201d<\/strong><\/em> operator \u201c\/\/.\u201d<\/strong><\/em>\u00a0that can be applied to an arbitrary expression to transform it into another expression. Here is an example:<\/p>\n

\"Substitution<\/a>
Substitution Operator<\/strong><\/figcaption><\/figure>\n

Here, the expression to the left of \u201c\/\/.\u201d<\/strong><\/em> Is \u201cX2<\/sup> + Y2 <\/sup>+ Z\u201d<\/strong><\/em>. To the right of \u201c\/\/.\u201d<\/strong><\/em> we have a list of substitutions to apply. The substitution operator repeatedly<\/strong><\/em> applies the given values to the LHS expression until it changes no more. Finally, we get the answer \u201c16\u201d<\/strong><\/em>.<\/p>\n

Of course, the substitution can also be symbolic. Look at this:<\/p>\n

\"Symbolic<\/a>
Symbolic Substitution<\/strong><\/figcaption><\/figure>\n

Here we transform one symbolic expression to another. Such transformations are quite common in the domain of Mathematica<\/strong><\/em>.<\/p>\n

In my view, Mathematica\u2019s<\/strong><\/em> pattern matching capabilities are richer and more powerful than Elixir<\/strong><\/em>. What I have covered is just a tiny part of what\u00a0Mathematica<\/strong><\/em>\u00a0allows.\u00a0<\/span><\/p>\n

Hope you enjoyed reading this article. Have a nice weekend and a wonderful week ahead!<\/p>\n","protected":false},"excerpt":{"rendered":"

One of the things I like about Elixir\u00a0is its support for patterns at the core language level, not through library functions as in most other languages. This contributes to writing cleaner code, in my opinion. \u00a0 Another environment that I am familiar with, namely Mathematica, boasts of (arguably) the most powerful symbolic programming language called […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[242,72,17],"tags":[243,43,62],"class_list":["post-2084","post","type-post","status-publish","format-standard","hentry","category-elixir","category-mathematica","category-programming","tag-elixir","tag-mathematica","tag-pattern-matching"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-xC","jetpack-related-posts":[{"id":409,"url":"https:\/\/www.rangakrish.com\/index.php\/2016\/11\/02\/working-with-linguistic-data-in-mathematica\/","url_meta":{"origin":2084,"position":0},"title":"Working with Linguistic Data in Mathematica","author":"admin","date":"November 2, 2016","format":false,"excerpt":"There are many interesting functions in Mathematica for working with language data, not just in English but in many other languages too. The DictionaryLookup[] function is a good starting point. Let us see what languages are supported as part of dictionary lookup: That is a good collection. It is nice\u2026","rel":"","context":"In "Mathematica"","block_context":{"text":"Mathematica","link":"https:\/\/www.rangakrish.com\/index.php\/category\/mathematica\/"},"img":{"alt_text":"Supported Languages","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/11\/dict-1.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/11\/dict-1.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/11\/dict-1.png?resize=525%2C300 1.5x"},"classes":[]},{"id":328,"url":"https:\/\/www.rangakrish.com\/index.php\/2016\/09\/11\/natural-language-processing-in-mathematica\/","url_meta":{"origin":2084,"position":1},"title":"Natural Language Processing in Mathematica","author":"admin","date":"September 11, 2016","format":false,"excerpt":"Welcome back. Today I am going to share with you some of the nice capabilities of Mathematica in the area of Natural Language Processing (NLP). Let us start with words. What if we wish to know\u00a0the various definitions of the word image?\u00a0Here is the answer. Mathematica gives the various senses\u2026","rel":"","context":"In "Mathematica"","block_context":{"text":"Mathematica","link":"https:\/\/www.rangakrish.com\/index.php\/category\/mathematica\/"},"img":{"alt_text":"Word Definition","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/09\/word-data1-1024x238.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/09\/word-data1-1024x238.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/09\/word-data1-1024x238.png?resize=525%2C300 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/09\/word-data1-1024x238.png?resize=700%2C400 2x"},"classes":[]},{"id":1594,"url":"https:\/\/www.rangakrish.com\/index.php\/2019\/06\/08\/using-nodejs-in-mathematica-12\/","url_meta":{"origin":2084,"position":2},"title":"Using NodeJS in Mathematica 12","author":"admin","date":"June 8, 2019","format":false,"excerpt":"In an earlier article, I had described Python integration in Mathematica 12. In addition to Python, NodeJS is also supported as a default \u201cexternal\u201d language. In today\u2019s article, I will focus on NodeJS integration. By the way, NodeJS support was introduced in Mathematica 11.2. Before using NodeJS with Mathematica 12,\u2026","rel":"","context":"In "Mathematica"","block_context":{"text":"Mathematica","link":"https:\/\/www.rangakrish.com\/index.php\/category\/mathematica\/"},"img":{"alt_text":"NodeJS Session Continued","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/06\/Session2.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/06\/Session2.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/06\/Session2.png?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/06\/Session2.png?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":1560,"url":"https:\/\/www.rangakrish.com\/index.php\/2019\/05\/05\/python-integration-in-mathematica-12\/","url_meta":{"origin":2084,"position":3},"title":"Python Integration in Mathematica 12","author":"admin","date":"May 5, 2019","format":false,"excerpt":"Mathematica has had Python support since ver 11.2 through ExternalEvaluate[]. In ver 11.3 it was possible to input Python expression in a cell by beginning with \u201c>\u201d character. The good news is that Mathematica 12 has significantly enhanced this integration. Python Cells Let us start with the simplest way to\u2026","rel":"","context":"In "Mathematica"","block_context":{"text":"Mathematica","link":"https:\/\/www.rangakrish.com\/index.php\/category\/mathematica\/"},"img":{"alt_text":"Function References","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/External-Evaluate-4.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/External-Evaluate-4.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/External-Evaluate-4.png?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":2947,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/11\/24\/using-julia-from-mathematica\/","url_meta":{"origin":2084,"position":4},"title":"Using Julia from Mathematica","author":"admin","date":"November 24, 2022","format":false,"excerpt":"In an earlier article, I had shown how it is possible to interact with Mathematica from Julia. In today\u2019s article, I will share the details of how to interact with Julia from within Mathematica. Why would somebody want to execute Julia code inside Mathematica? Although Mathematica is a great symbolic\u2026","rel":"","context":"In "Julia"","block_context":{"text":"Julia","link":"https:\/\/www.rangakrish.com\/index.php\/category\/julia\/"},"img":{"alt_text":"Installing Julia","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/11\/Julia-Shell.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/11\/Julia-Shell.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/11\/Julia-Shell.png?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":1581,"url":"https:\/\/www.rangakrish.com\/index.php\/2019\/05\/19\/currying-in-mathematica\/","url_meta":{"origin":2084,"position":5},"title":"Currying in Mathematica","author":"admin","date":"May 19, 2019","format":false,"excerpt":"One of the more recent additions to the core Wolfram Language is the \u201cCurry\u201d function. It was introduced in Mathematica ver 11.3 and is still (as of ver 12.0) considered Experimental. In this post, I would like to go over this function briefly. Non-curried functions in Mathematica have to be\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Lisp Currying Examples","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/Lisp-Usage.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2084","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/comments?post=2084"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2084\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=2084"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=2084"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=2084"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}