Strings are used across many disciplines to represent filenames, data, and other objects: linguists working with text data study representation, classification, and patterns involved in audio and text usage; biologists dealing with genomic data as strings are interested in sequence structure and assembly and perform extensive statistical analysis of their data; programmers operate on string data for such tasks as text search, file manipulation, and text processing. Strings are so ubiquitous that almost every modern programming language has a string datatype and dozens of functions for operating on and with strings.

Introduction

In Mathematica, strings are represented by any concatenation of characters enclosed in double quotes.

Strings are also used to represent file names that you import and export.

Strings are used as arguments, option values, and as the output to many functions.

In this chapter we will introduce the tools available for working with strings in Mathematica. We will begin with a look at the structure and syntax of strings, then move on to a discussion of the many high-level functions that are optimized for string manipulation. String patterns follow on the discussion of patterns in Chapter 4 and we will introduce an alternative syntax (regular expressions) that provides a very compact mechanism for working with strings. The chapter closes with several applied examples drawn from computer science (checksums) as well as bioinformatics (working with DNA sequences) and also word games (anagrams, blanagrams).

9.1. Structure and Syntax

Strings are expressions consisting of a number of characters enclosed in quotes. The characters can be anything you can type from your keyboard, including uppercase and lowercase letters, numbers, punctuation marks, and spaces. For example, here is the standard set of printable Ascii characters.

Other character sets are available as well. For example, here are the lowercase Greek letters. These are typically entered from one of Mathematica’s many built-in character palettes, or using a keyboard shortcut such as -a- for .

When Mathematica displays a string in output, it appears without the quotes. This is the default behavior of the formatting rules for OutputForm.

Use InputForm or FullForm to display these quotes in output.

Various predicates test whether a string consists entirely of letters, or uppercase and lowercase letters.

Use === (SameQ) to test for equality of strings.

Several functions are available for working with the structure of strings.

StringLength also works with lists of strings. In other words, it has the Listable attribute.

Character Codes

One way to work with strings is to convert them to a list of character codes and then operate on the codes using mathematical functions. Each character in a computer’s character set is assigned a number, called its character code. By general agreement, almost all computers use the same character codes, called the Ascii code. In this code, the uppercase letters A, B, …, Z are assigned the numbers 65, 66, …, 90 while the lowercase letters a, b, …, z have the numbers 97, 98, …, 122 (note that the number of an uppercase letter is 32 less than its lowercase version). The numbers 0, 1, …, 9 are coded as 48, 49, …, 57 while the punctuation marks period, comma, and exclamation point have the codes 46, 44, and 33, respectively. The space character is represented by the code 32. Table 9.1 shows the characters and their codes.

Here are the printable Ascii characters.

converts any string character char to its Ascii code.

You can also get a list of the characters in a range if you know how they are ordered by their character codes.

Characters from other languages can also be used, for example, Greek and Japanese.

Unicode charts for many languages are available online (for example, www.unicode.org/charts). With these charts you can find the hexadecimal code for characters in many different languages. For Gujarati, the first character in its code table has hex value 0A90. Here we convert from base 16 and then display the character.

Using the character code representation of characters, the following series of computations changes a word from lowercase to uppercase.

Or, simply use a built-in function that is designed specifically for this task.

Sorting Lists of Characters

As a practical example of the use of character codes, we will extend the simple sorting function from Chapter 4 to work with lists of string characters. Although written to operate on numbers, this rule can be overloaded to work on characters by making only a few small changes. Here is the original rule from Section 4.3.

The first change is to check that the patterns a and b have head String instead of testing for numbers with the predicate NumericQ. Second, instead of the numerical comparison b < a, we need to compare their character codes.

Here is a list of characters.

Here is the sort.

Section 9.5 explores the use of character codes to create hash tables, or checksums.

Ordered Words

When studying word or language structure, a common task is to find all words within a corpus that meet some criteria you are interested in. In this brief example, we will use character codes to search for words whose letters are “in order” when read from the first letter to the last. We will create a Boolean function OrderedWordQ that returns True or False depending upon whether its argument is in alphabetic order. So would return True but would return False. Then we will use this predicate to find all words in a dictionary that are ordered in this sense.

Start by getting a list of all words in the dictionary using DictionaryLookup.

Alternatively, you can use the data in WordData, which contains phrases in addition to words. You could use any similar resource for your list of words.

First, consider the character code of a string.

Then we only need to know if this list of codes is in order.

Here is a predicate that returns True if its argument is ordered in this alphabetic sense.

Now we will find all the words in the dictionary file that comes with Mathematica that are ordered in this way; we will use Select to return those words that pass the test. Finally, we randomly sample 40 of them.

Almost correct! In the English character code set, capitals appear before lowercase letters. So, although our words are ordered in the sense of character codes, they are not ordered in the commonly-used sense.

One approach to resolving this issue is to only work with words of the same case. We could either convert words of the form uppercase/lowercase to lowercase/lowercase or we could select only words from the dictionary that match a pattern that codes for this. We will wait until the discussion of string patterns in Section 9.3 to correct this issue.

Exercises

1. Convert the first character in a string (which you may assume to be a lowercase letter) to uppercase.
2. Given a string of digits of arbitrary length, convert it to its integer value. (Hint: you may find that the Dot function is helpful.)
3. Create a function that takes a string as its argument and returns a list of the unique characters in that string. For example, should return .

9.2. Operations on Strings

Strings are expressions and, like other expressions (such as numbers and lists), there are built-in functions available to operate on them. Many of these functions are very similar to those for operating on lists. In this section we will first look at some of these basic functions for operating on strings and then use them on some nontrivial examples: analyzing a large piece of text, encoding strings, creating index variables, and finally, a word game for creating anagrams.

Basic String Operations

StringTake, which has a similar syntax to Take, is used to extract parts of a string. The second argument specifies the positions of the characters to extract. So, for example, this takes the first twelve characters in this string.

And this takes the last twelve characters from the string.

A list of the individual characters is returned by Characters.

StringJoin concatenates strings.

The shorthand notation for StringJoin is .

The following functions mirror those for list operations.

Some functions are quite specific to strings and do not have analogs with lists. For example, conversion to uppercase and lowercase.

This trims substrings from a string using alternative patterns (discussed further in Section 9.3). So if either "http://" or "/" is found, they will be trimmed.

Strings vs. Lists

For some computations, you might be tempted to convert a string to a list of characters and then operate on the list using some list manipulation functions. For example, this first constructs a list of the individual characters and then uses Count to get the number of occurrences of the letter B in the list of characters from the text of Charles Darwin’s On the Origin of Species.

Since the string functions in Mathematica are optimized for working on strings directly you will often find that they are much faster than the more general list manipulation functions.

This speedup results from the fact that the string pattern matching algorithms are operating only on a well-defined finite alphabet and string expressions are essentially flat structures, whereas the algorithms for more general expression matching are designed to operate on arbitrary expressions with potentially much more complicated structures.

Converting to lists and using list manipulation functions will often be more cumbersome than working with the string functions directly. For example, counting the occurrences of a word within a chunk of text by first converting to a list of characters would be quite indirect and computationally more taxing than simply using StringCount directly.

In fact, sometimes you will even find it more efficient to convert a numerical problem to one involving strings, do the work with string manipulation functions, and then convert back to numbers as in the subsequence example in Section 9.5.

Encoding Text

In this example, we will develop functions for coding and decoding strings of text. The particular coding that we will use is quite simplistic compared with contemporary commercial-grade ciphers, but it will give us a chance to see how to combine string manipulation, the use of functional programming constructs, and rule-based programming all in a very practical example that should be accessible to anyone.

The problem in encryption is to develop an algorithm that can be used to encode a string of text and then a dual algorithm that can be used to decode the encrypted message. Typically, the input string is referred to as the plaintext and the encoded output as the ciphertext.

To start, we will limit ourselves to the 26 lowercase letters of the alphabet.

One of the simplest encryption schemes is attributed to Julius Caesar who is said to have used this cipher to encode communications with his generals. The scheme is simply to shift each letter of the alphabet some fixed number of places to the left and is commonly referred to as a substitution cipher. Using Thread, we can set up rules that implement this shift, here just shifting one place to the left.

The decoding rules are simply to reverse the encoding rules.

To code a string, we will decompose the string into individual characters, apply the code rules, and then join up the resulting characters in a “word.”

Here is the function to accomplish this.

Similarly, here is the decoding function.

Let us try it out on a phrase.

In this example, we have shifted one position for each letter to encode (and decode). It is thought that Caesar (or his cryptographers) used a shift of length three to encode his military messages. In the exercises, you are asked to implement a different shift length in the encoding and decoding functions.

Even with longer shifts, the Caesar cipher is terribly insecure and highly prone to cracking since there are only 26 possible shifts with this simple cipher. A slightly more secure cipher involves permuting the letters of the alphabet.

Using Thread, we create a rule for each letter paired up with the corresponding letter from the permutation p.

Again, the decoding rules are obtained by simply reversing the above rules.

Although these substitution ciphers are not terribly difficult to crack, they should give you some good practice in working with strings and the various Mathematica programming constructs. Modern commercial-grade ciphers such as public-key ciphers are often based on the difficulty of factoring large integers. For a basic introduction to the history of ciphers, see Sinkov (1966) [2]. A more thorough treatment can be found in Paar and Pelzl (2010) [3].

Indexed Symbols

When developing algorithms that operate on large structures (for example, large systems of equations), it is often helpful to be able to create a set of unique symbols with which to work. As an example of operations on strings, we will use some of the functions discussed in this section to develop a little utility function that creates unique symbols. Although there is a built-in function, Unique, that does this, it has some limitations for this particular task.

One potential limitation of Unique is that it uses the first unused symbol of a particular form. It does this to avoid overwriting existing symbols.

However, if you want to explicitly create a list of indexed symbols with a set of specific indices, it is useful to create a different function. First, note that a string can be converted to a symbol using ToExpression or by wrapping the string in Symbol.

StringJoin is used to concatenate strings. So, let us concatenate the variable with the index, first with one number and then with a range of numbers.

We put all the pieces of code together.

Let us create an additional rule for this function that takes a range specification as its second argument.

Note that we have not been too careful about argument checking.

In the exercises you are asked to correct this.

Anagrams

Anagrams are words that have the same set of letters but in a different order. Good Scrabble players are adept at anagram creation. Anagrams can be created by taking a word, extracting and permuting its characters, and then finding which permutations are real words.

Start by getting the characters in a word.

Permute the characters.

Concatenate the characters in each list.

Now, which of these “words” are really words? One way to check is to select those that are in the dictionary. Those elements in words that are not in the dictionary will return when run against DictionaryLookup, so we omit those using ≠.

Putting all the pieces together, we have the function Anagrams.

Other than extracting the characters of a word and joining the permuted list of characters, the operations here are essentially those on lists (of strings) and pattern matching. Exercise 2 in Section 9.5 discusses a more direct approach to this problem, one that avoids the creation of permutations of the characters in the word.

Exercises

1. Create a function that returns a value of True if its argument str is a palindrome, that is, if the string str is the same forward and backward. For example, refer is a palindrome.
2. Create a function that takes a string str, and returns a string with the characters rotated to the left places. For example:





3. In creating the function MakeVarList in this section, we were not careful about the arguments that might be passed. Correct this problem using pattern matching on the arguments to this function to insure that the indices are positive integers only.
4. Create a function that pads the end of a string with whitespace characters. Then create a second rule that pads the string out to length . If the input string has length greater than , issue a warning message. Finally, mirroring the argument structure for the built-in PadLeft, create a third rule that pads with whitespaces at the front and whitespaces at the end of the string.
5. Modify the Caesar cipher so that it encodes by shifting five places to the right. Include the space character in the alphabet.
6. A mixed-alphabet cipher is created by first writing a keyword followed by the remaining letters of the alphabet and then using this as the substitution (or cipher) text. For example, if the keyword is django, the cipher text alphabet would be:
djangobcefhiklmpqrstuvwxyz
So, a is replaced with d, b is replaced with j, c is replaced with a, and so on. As an example, the piece of text
the sheik of araby
would then be encoded as
tcg scgeh mo drdjy
Implement this cipher and go one step further to output the cipher text in blocks of length five, omitting spaces and punctuation.
7. Modify the alphabet permutation cipher so that instead of being based on single letters, it is instead based on adjacent pairs of letters. The single letter cipher will have permutations; the adjacent pairs cipher will have permutations.

9.3. String Patterns

Most of the string operations we have looked at up until this point have involved literal strings. For example, in string replacement, we have specified both the explicit string that we are operating on as well as the replacement string.

But the real power of programming with strings comes with the use of patterns to represent different classes of strings. A string pattern is a string expression that contains symbolic patterns. Much of the pattern matching discussed in the previous chapters extends to strings in a very powerful manner. For example, this uses patterns to change the first letter in a string to uppercase.

Or, use a conditional pattern to check if a word begins with an uppercase character.

To get started, you might find it helpful to think of strings as a sequence of characters and use the same general principles on these expressions as you do with lists.

For example, the expression matches the pattern because it is a list that starts with a sequence of one or more elements, it contains an element repeated once, and then ends with a sequence of one or more elements.

If we now use a string instead of a list and StringMatchQ instead of MatchQ, we get a similar result using the shorthand notation ~~ for StringExpression.

is shorthand notation for , which, for the purpose of pattern matching, represents a sequence of strings.

StringExpression is quite similar to StringJoin (both can be used to concatenate strings) except that with StringExpression, you can concatenate nonstrings.

The next example also shows the similarity between the general expression pattern matching that we explored earlier in Chapter 4 and string patterns. Using Cases, the following returns all those expressions that match the pattern _Symbol, that is, pick out all symbols from the list.

With strings we use StringCases whose second argument is a pattern that represents a class of characters to match. StringCases returns those substrings that match a given pattern. Many named patterns are available for various purposes. For example, LetterCharacter matches a single letter.

Match single digits with DigitCharacter and one or more digits with NumberString.

To see the generality and power of working with string patterns, suppose we were looking for a nucleotide sequence in a gene consisting of a repetition of A followed by any character, followed by T. Using a gene from the human genome, the following string pattern neatly does the job.

Here are the starting and ending positions of these substrings. StringPosition takes the same syntax as StringCases, analogous to Position and Cases.

And if you wanted to return those characters that follow all occurrences of the string "GTC", you can name the pattern and use a rule to return it.

In this example, the pattern is . This pattern is named pat and it consists of the string GTC which is then followed by any character. That character is named x so that we can refer to it in the replacement expression on the right-hand side of the rule. The replacement expression is the pattern pat concatenated with the character named x.

As another example of the use of string patterns, suppose you were interested in scraping phone numbers off of a web page; you need to construct a pattern that matches the form of the phone numbers you are looking for. In this case we use the form which matches the form of North American phone numbers. NumberString comes in handy as it picks up strings of numbers of any length. Otherwise you would have to use which matches repeating digits.

Finding Subsequences with Strings

In this section we will explore a related problem to the one in Section 4.3, where we searched for subsequences within a sequence of numbers. Here we will transform the problem from working with lists of digits to one where we work with strings.

Using pattern matching it is not too difficult to construct the pattern of interest. For example, suppose we were looking for the substring are within a larger string. Using the special named string pattern WordBoundary which matches the beginning or end of a word, we concatenate (StringJoin) the patterns we need. See Table 9.3 in the next section for a listing of other named patterns.

To start, we will prototype with a short sequence of digits of , converted to a string.

Check that the output is in fact a string.

For our purposes here, we are only interested in the digits following the decimal point. We can extract them by splitting the string of digits on the decimal point and then taking the second part of that expression. This will generalize for numbers with an arbitrary number of digits before the decimal point.

The subsequence 3238 occurs starting 15 positions to the right of the decimal point.

Collecting the code fragments, we turn this into a function.

Let us try it out on a more challenging example: finding occurrences of the sequence 314159 in the decimal expansion of to ten million places.

Comparing with the function that takes lists of digits developed in Section 4.3, our string implementation is about twice as fast.

Alternatives

We have already seen general patterns with alternatives discussed in Chapter 4. Here we will use alternatives with string patterns. The idea is quite similar. For example, a common task in genome analysis is determining the GC content or ratios of the nucleobases guanine (G) and cytosine (C) to all four bases in a given fragment of genetic material.

You could count the occurrences of G and the occurrences of C and add them together.

But it is much easier to use alternatives to indicate that you want to count all occurrences of either G or C. The syntax for using alternative string patterns is identical to that for general expressions that we introduced in Section 4.1.

We will return to the computation of GC content in Section 9.5.

As a slightly more involved example, suppose you are interested in tallying the lengths of words in a corpus. You might start by using StringSplit to split the large string into a list of words.

Looking at the result, you will see that some elements of this list include various types of punctuation. For example, StringSplit, with default delimiters, missed certain hyphenated words and some punctuation.

There are 149863 elements in this split list.

Fortunately, StringSplit takes a second argument that specifies the delimiters to match. The pattern is given as a set of alternatives followed by the repeated operator to catch one or more repetitions of any of these delimiters. Searching through the text will help to come up with this list of alternatives.

Notice that this list contains many more elements than the initial approach given above.

Finally, here is a histogram showing the distribution of word lengths in the text, On the Origin of Species.

Let us compare this with a different text: A Portrait of the Artist as a Young Man, by James Joyce [4] (available online at Project Gutenberg [5]). We are postprocessing here by removing metadata at the beginning and at the end of the file.

An alternative syntax uses a list of delimiters as given by Characters. The repeated pattern, .., helps to catch such constructions as “--“, “::” and double-spaces.

In the next section, on regular expressions, we will see that there are more compact ways of accomplishing some of these tasks.

Exercises

1. At the end of Section 9.1 we created a predicate OrderedWordQ to find all words in a dictionary whose letters are in alphabetic order. This predicate used character codes and returned incorrect results for words that started with a capital letter. Correct this error by only selecting words from the dictionary that start with a lowercase letter. Consider using a conditional string pattern involving the built-in function LowerCaseQ.
2. Given a list of words, some of which start with uppercase characters, convert them all to words in which the first character is lowercase. You can use the words in the dictionary as a good sample set.
3. Create a function that finds all palindromic words of length in the dictionary. For example, kayak is a five-letter palindrome.
4. Find the number of unique words in a body of text such as Alice in Wonderland.

After splitting the text into words, convert all uppercase characters to lowercase so that you count words such as hare and Hare as the same word.

Such computations are important in information retrieval systems, for example, in building term-document incidence matrices used to compare the occurrence of certain terms across a set of documents (Manning, Raghavan, and Schütze 2008 [6]).

9.4. Regular Expressions

In addition to the use of string patterns discussed up to this point, you can also specify string patterns using what are known as regular expressions. Regular expressions in Mathematica follow a syntax very close to that of the Perl programming language. This syntax is quite compact and powerful but it comes at the cost of readability – regular expressions tend to be quite cryptic to humans. As a result, we will only cover a few examples of their use here and refer the interested reader to the Mathematica documentation on string patterns (Working with String Patterns, WMDC [7]).

You should think of regular expressions as an alternative syntax for string pattens. To indicate that you are using a regular expression, wrap the expression in RegularExpression. For example, the regular expression . is a wildcard character. It matches any single character except a newline. To use it as a string pattern, write .

The string "abc" does not match the pattern because it does not consist of a single character.

You can also match a set or range of characters. For example, this matches any of the characters a through z.

Certain constructs give patterns with repeating elements. For example, "c*" is a pattern matched by a string with character c repeated zero or more times; "c+" stands in for the character c repeated one or more times.

You can also match on concatenated characters using the syntax .

Several constructs are available for classes of characters. The named classes in the last two entries of Table 9.2 include alpha, ascii, blank, digit, space, word, and several more.

The regular expression matches any expression beginning with the character a followed by any sequence of characters.

The regular expression represents any digit 0 through 9.

The regular expression matches any expression beginning with an a, followed by any character repeated one or more times, followed by a digit.

Let us try something more ambitious. This finds all words in text that are of length 16 to 18.

The regular expression matches any word boundary (typically whitespace, period, comma, etc.) and matches any word of length 16 to 18.

Various shortcuts exist for some commonly used patterns (Table 9.3).

Conveniently, you can mix regular expressions and other string patterns in various ways. This accomplishes the same thing as the previous computation, but using WordBoundary, instead of the regular expression .

Sometimes you will need to refer to the pattern by name in order to perform some operation on it. This is similar to the situation with regular named patterns. For example, given a list of words, some of which are uppercase/lowercase, this uses string patterns to transform the list to all lowercase words, naming the pattern that is matched by the first character after a word boundary, a.

So how do we name a pattern with regular expressions so that we can refer to it on the right-hand side of a rule? The syntax using regular expressions is to wrap the pattern in parentheses and then refer to it using "$n" , where is the th occurrence of such patterns. For example, is a named pattern that is matched by an expression consisting of a word boundary followed by a word character. The subexpression matching is referenced by "$1" on the right-hand side of the rule.

To change the second character after the word boundary to uppercase, use "$2" to refer to the expression that matches the second .

A particularly useful construct in many situations is the lookahead/lookbehind construct. is used when the following text must match patt and is used when the preceding text must match patt. For example, this finds all those words in some example text that follow "Raven, ".

There are many more constructs available for doing quite sophisticated things with regular expressions. We will explore some of these in the examples and exercises below as well as in the applications in Section 9.5. For a more detailed discussion, see the tutorials Regular Expressions (WMDC [8]) and Working with String Patterns (WMDC [7]).

Word Stemming

Many aspects of linguistic analysis include a study of the words used in a piece of text or in a speech. For example, you might be interested in comparing the complexity of articles written in two different newspapers. The length and frequency of certain words might be a useful measure for such an analysis. Patterns in usage of certain word combinations can be used to identify authenticity or the identity of an author of a work.

There are some basic issues that arise again and again in such analyses. For example, what should be done with contractions such as shouldn’t? What about sets of words such as run, runs, ran, running. Are they considered distinct? One approach in language processing is to strip suffixes and reduce alternate forms to some stem. This process, known as word stemming, is extensively used in many online search systems to try to distill user’s queries to some basic form that can be processed and operated on. It is a bit tricky, as natural languages are notorious for exceptions to almost any rule. For example, although the word entertainment can sensibly be stemmed to entertain, the stem of comment is certainly not com. In other words, a rule that dropped the suffix ment is too broad and returns nonwords in many cases. In most word stemming algorithms, there are numerous rules for the many cases that need to be examined; and there are many special cases. In this section, we will create a set of rules for word stemming to show how these rules are described and how the string pattern constructs in Mathematica provide a good set of tools to implement these concepts. A full-fledged stemming application would include hundreds of rules for each language, so we will only give a small set here to indicate the general process.

Words Ending in …xes

The first set of stemming rules we will create involves a relatively small set of words in the English language – those ending in xes, such as boxes or complexes. The rule is to strip off the es.

To prototype, we collect all the words in the dictionary that end in xes. We will also restrict ourselves to words that are all lowercase. Quiet is used here to suppress the error messages that arise when StringTake operates on words of length less than three. Alternatively, you could put an extra clause () in the conjunction.

Here is the replacement rule. The regular expression "(\\w)(x)es" will be matched by any word character followed by xes. It is replaced by that word character followed only by x. On the right-hand side of the rule, $1 refers to the first pattern on the left, ; and $2 refers to the second pattern on the left, .

This is pretty good; it appears only four stemmed words are not in the dictionary; although max might be considered an abbreviation, postfix is certainly a word! Nonetheless, these sorts of exceptions are common and will need to be dealt with separately.

Plural Nouns Ending …mming

A word such as programming has a stem of program; so the rule for words ending in …mming could be: drop the ming. Start by gathering all the words in the dictionary that end with …mming.

Recall the regular expression represents a word character repeated some number of times; represents a word boundary; the $1 refers to the first expression , that is, the characters up to the mming. These characters will be joined with a single m.

Again, this is quite good although the word lemming has been stemmed to the nonword lem, something that will need to be dealt with as a special case. The way to do that is to order the rules so that the special cases are caught first.

Words Ending in …otes

Numerous rules are needed for turning plural words into their singular stems. To see this, consider a naive rule that simply drops the s for any such words.

This is clearly too general a rule. In fact, several different rules are needed for words that end in s, depending upon the preceding characters. Here, we will only deal with words that end in …otes. First gather the words in the dictionary that match this pattern.

Here is the replacement rule.

Stemming litotes gives the nonword litote. This can again be resolved by adding some specific rules for these not uncommon situations.

Plural to Singular

Let us try to deal with the general problem of stemming plural forms to singular. This is a more difficult scenario to deal with as there are many rules and even more exceptions. We will begin by showing how the order of the replacement rules matters in the stemming process.

You might imagine the rules given in Table 9.4 being used to stem plurals (these are not complete, but they will get us started). In fact, these are step 1a of the commonly-used Porter’s algorithm for word stemming in the English language.

The order in which such rules are used is important. You do not want the last rule being used before any of the others. As we saw with the previous set of rules, Mathematica will apply rules in the order in which they are given, assuming that they have roughly the same level of specificity. Note also that some of these rules are designed to leave certain words unchanged. For example neither pass nor abacus are plural and they should not be stemmed.

Here then is a rough attempt at stemming plural words. First we gather the words from the dictionary that end in s and display a random sample of them.

This process of word stemming requires a lot of trial and error and the creation of many rules for the exceptions. Another approach, called lemmatization, does a more careful and thorough job by working with vocabularies and performing morphological analysis of the words to better understand how to reduce them to a root. For more information, see Manning, Raghavan, and Schütze (2008) [6].

Exercises

1. Rewrite the genomic example in Section 9.3 to use regular expressions instead of string patterns to find all occurrences of the sequence . Here is the example using general string patterns.







2. Rewrite the web page example in Section 9.3 to use regular expressions to find all phone numbers on the page, that is, expressions of the form . Modify accordingly for other web pages and phone numbers formatted for other regions.
3. Create a function that takes its argument word and returns the word with the first letter uppercase and the rest of the letters lowercase.
4. Use a regular expression to find all words given by DictionaryLookup that consist only of the letters a, e, i, o, u, and y in any order with any number of repetitions of the letters.
5. The basic rules for pluralizing words in the English language are roughly, as follows: if a noun ends in ch, s, sh, j, x, or z, it is made plural by adding es to the end. If the noun ends in y and is preceded by a consonant, replace the y with ies. If the word ends in ium, replace with ia (Chicago Manual of Style 2010 [9]). Of course, there are many more rules and even more exceptions, but you can implement a basic set of rules to convert singular words to plural based on these rules and then try them out on the following list of words.



6. A common task in transcribing audio is cleaning up text, removing certain phrases such as um, er, and so on, and other tags that are used to make a note of some sort. For example, the following transcription of a lecture from the University of Warwick, Centre for Applied Linguistics (BASE Corpus [10]), contains quite a few fragments that should be removed, including newline characters, parenthetical remarks, and nonwords. Use StringReplace with the appropriate rules to “clean” this text and then apply your code to a larger corpus.



7. Find the distribution of sentence lengths for any given piece of text. contains several well-known books and documents that you can use. You will need to think about and identify sentence delimiters carefully. Take care to deal properly with words such as Mr., Dr., and so on that might incorrectly trigger a sentence-ending detector.
8. In web searches and certain problems in natural language processing (NLP), it is often useful to filter out certain words prior to performing the search or processing of the text to help with the performance of the algorithms. Words such as the, and, is, and so on are commonly referred to as stop words for this purpose. Lists of stop words are almost always created manually based on the constraints of a particular application. We will assume you can import a list of stop words as they are commonly available across the internet. For our purposes here, we will use one such list that comes with the materials for this book.





Using the above list of stop words, or any other that you are interested in, first filter some sample “search phrases” and then remove all stop words from a larger piece of text.



9. Modify the previous exercise so that the user can supply a list of punctuation in addition to the list of stop words to be used to filter the text.

9.5. Examples and Applications

This section puts together many of the concepts and techniques developed earlier in the chapter to solve several nontrivial applied problems. The first example creates a function to generate random strings, mirroring the syntax of the built-in random number functions. People who work with large strings, such as those in genomic research, often partition their strings into small blocks and then perform some analysis on those substrings. We develop functions for partitioning strings as well as several examples for analyzing sequences of genetic code. An additional example covers checksums, which are used to verify stored and transmitted data. Finally, a word game is included in which we create blanagrams, a variant of anagrams.

Random Strings

A blasphemous sect suggested …that all men should juggle letters and symbols until they constructed, by an improbable gift of chance, these canonical books.
— Jorge L. Borges, The Library of Babel [11]

Those who work with genomic data often need to test their algorithms on strings. While it may be sensible to test against real data – for example, using genes on the human genome – random data might be more appropriate to quickly test and measure the efficiency of an algorithm. Although Mathematica has a variety of functions for creating random numbers, random variates, and so on, it does not have a function to create random sequences of strings. In this section we will create one.

To start, we will choose the characters A, C, T, and G – representing the nucleotide, or DNA, bases – as our alphabet, that is, the letters in the random strings we will create.

The key observation is that we want to choose one character at random from this list. Since we need to repeat this times, we need to randomly choose with replacement. That is the purpose of RandomChoice.

This expression is a list of strings.

Finally, we concatenate the strings.

So a first attempt at putting these pieces together would look like this. Note the use of a default value of 1 for the optional argument n (see Section 6.1 for a discussion of default values for arguments to functions).

The default value of the second argument gives one choice.

We can make the arguments a bit more general using structured patterns. The first argument in this next version must be a list consisting of a sequence of one or more strings.

Here is a ten-character password generator.

It is not hard to extend this function to create random strings of a given length. We essentially pass that argument structure to RandomChoice.

The exercises at the end of this section include a problem that asks you to add an option that provides a mechanism to weight the individual characters in the random string.

Partitioning Strings

Some string analysis requires strings to be broken up into blocks of a certain size and then computations are performed on those blocks. Although there is no built-in function for partitioning strings, we can easily create one, taking advantage of the syntax and speed of the built-in Partition function.

The Partition function requires a list as its first argument. To start, we will give it a list of the characters in a prototype string, a gene on the human genome.

Now, partition this list of characters into lists of length 4 with offset 1.

Because the number of characters in str is not a multiple of 4, this use of Partition has padded the last sublist with the first two characters from the original string; in other words, this has treated the list cyclically; not quite what we want here.

A slightly different syntax for Partition gives an uneven subset at the end. We will need to use this form so as not to lose or introduce any spurious information.

Finally, convert each sublist into a contiguous string.

This puts everything together in a function.

This partitions the string into nonoverlapping blocks of length 12.

This function operates on large strings fairly fast. Here we partition a random string of length ten million into nonoverlapping blocks of length ten.

Adler Checksum

Checksums, or hashes, are commonly used to check the integrity of data when that data are either stored or transmitted. A checksum might be created, for example, when some data are stored on a disk. To check the integrity of that data, the checksum can be recomputed and if it differs from the stored value, there is a very high probability that the data was tampered with. Hash functions are used to create hash tables which are used for record lookup in large arrays of data. As an example of the use of character codes, we will implement a basic checksum algorithm, the Adler checksum.

Mathematica has a built-in function, Hash, that can be used to create hash codes, or checksums.

If the string is changed, its checksum changes accordingly.

We will implement a basic hash code, known as the Adler-32 checksum algorithm. Given a string consisting of concatenated characters , we form two 16-bit sums and as follows:

where is the character code for the character . The number 65521 is chosen as it is the largest prime smaller than . Choosing primes for this task seems to reduce the probability that an interchange of two bytes will not be detected. Finally, the Adler checksum is given by

Let us take Mathematica as our test word. We start by getting the Ascii character codes for each character.

The number above is given by the cumulative sums of the character codes, with 1 prepended to that list. (This step could also be done using FoldList.)

The number is given by the cumulative sums from this last list, omitting the 1 at the beginning as it is already part of the cumulative sums.

We can check our result against the algorithm implemented in the Hash function.

Finally, this puts these steps together in a reusable function. Our prototype worked with small numbers and so the need to work mod 65521 was not necessary. For general inputs, the arithmetic will be done using this modulus.

As an aside, here is its hash code in hexadecimal.

And here is a lengthier example.

Search for Substrings

As we have seen in this chapter, string patterns provide a powerful and compact mechanism for operating on text data. In this example, we will create a function that searches the dictionary for words containing a specified substring.

If our test substring is cite, here is how we would find all words that end in cite. Note the triple blank pattern to match any sequence of zero or more characters.

Here are all words that begin with cite.

And this gives all words that have cite somewhere in them, at the beginning, middle, or end.

Using the double blank gives words that have cite in them but not beginning or ending with cite.

Let us put these pieces together in a reusable function FindWordsContaining. We will include one option, WordPosition that identifies where in the word the substring is expected to occur.

Depending upon the value of the option WordPosition, Which directs which expression will be evaluated.

Using the default value for WordPosition, this finds all words in the dictionary that start with the string cite.

And this finds all words that have cite anywhere in the word.

Finally, here is a dynamic interface that includes a text field in which you can enter an input string; tabs are used to specify in which part of the word you expect the string to occur.

For more on the creation of these sorts of dynamic interfaces, see Chapter 11.

DNA Sequence Analysis

DNA molecules are composed of sequences of the nitrogenous bases guanine, cytosine, thymine, and adenine. Guanine and cytosine bond with three hydrogen bonds and thymine and adenine bond with two. Research has indicated that high GC content (guanine and cytosine) DNA is more stable than that with lower GC. The exact reasons for this are not completely understood and determining the GC content of various DNA materials is an active area of biomolecular research. GC content is often described as a percentage of the guanine and cytosine nucleotides compared to the entire nucleotide content (Cristianini and Hahn 2007 [12]). In this section we will create a function to compute the ratio of GC in any given DNA sequence or fragment.

We will start by importing a FASTA file consisting of human mitochondrial DNA, displaying some information about the contents of this file.

We use StringCount to count the number of occurrences of G or C in this sequence.

And here is the number of occurrences of A or T.

The GC percentage is given by the following ratio.

Here then is an auxiliary function we will use in what follows.

Note that gcRatio expects a string as an argument, but this fails with hsMito, imported from an external source.

It fails because Import returns a list consisting of a string, not a raw string. We can remedy this by writing a rule to deal with this argument structure and then call the first rule.

Typically, researchers are interested in studying the GC ratio on particular fragments of DNA and comparing it with similar fragments on another molecule. One common way of doing this is to compute the GC ratio for blocks of nucleotides of some given length. We will use the function StringPartition, developed earlier to partition the sequence into blocks of a given size. We will work with a small random sequence to prototype.

Here are the GC ratios for each of the blocks given by lis.

Finally, it is helpful to be able to identify each block by its starting position. So we first create a list of the starting positions for each block and then transpose that with the ratios.

Here are all the pieces in one function, GCRatio.

And again, a second rule in case the string is wrapped in a list.

Let us try it out first on our prototype sequence.

And then on the human mitochondrial DNA with block size 1000.

Various types of analysis can then be performed on these blocks. For example, using Select, this quickly finds regions of high GC content.

Here is a quick visualization of the GC content across the blocks.

Numerous comparative studies have been done looking at the GC content for different organisms. One much-studied organism is Thermoplasma volcanium, a bacterium-like organism that exists in very high-acid and high-temperature environments. To accommodate the extreme conditions, organisms in such environments often have high GC content which has a higher thermal stability. The following sequence is in the public domain and was obtained courtesy of the National Center for Biotechnology Information (NCBI Nucleotide Database [13]).

Here is the GC ratio for the entire sequence.

And here are the ratios for block sizes of 100000.

Displaying DNA Sequences

DNA sequences are typically long strings of nucleotides that are difficult to visualize simply by looking at the string of characters. Various visualization tools have been used to work with these sequences and in this section we will look at a common way of viewing them in a formatted table.

As before, we will prototype with a short random string consisting of nucleotide characters G, C, A, and T.

Using StringPartition developed earlier in this chapter, we split the string into blocks of a desired size.

We have 13 blocks here, but for readability purposes, we will put five blocks on each line of output. We use the blank string " " to pad out any string shorter than the blocksize, in this case 10.

The following code gives the starting positions for each line once we have set the block length and row length.

We prepend the starting position of each row at the head of the row. Recall, the second argument to Prepend is the expression you wish to put in front (the indices) of your target expression (the rows).

This is what the formatted output should look like.

Finally, let us put this all together, setting up an option, BlockSize that is combined with the inherited options from Grid.

Let us exercise some of the options.

Blanagrams

A blanagram is an anagram for another word except for the substitution of one letter. Think of Scrabble with a blank square (blank + anagram = blanagram). For example, phyla is a blanagram of glyph: replace the g with an a and find anagrams. In this section we will create a function that finds all blanagrams of a given word.

We will prototype with a simple word, glyph.

Start by replacing the first letter in glyph with an a and then finding all anagrams (using Anagrams from Section 9.2). The third argument to StringReplacePart is a list of beginning and ending positions for the replacement.

Now do the same for each character position in the word.

Running Anagrams on each of these strings, only two appear as words in the dictionary.

Having done this for the letter a, we now repeat for all other single characters.

Because of the extra nesting () we need to flatten the output at a deeper level; and delete duplicates.

Finally, put all the pieces together to create the function Blanagrams.

This turns out to be fairly quick for small words, but it bogs down for larger words.

We will wait until Section 12.3 to optimize this code by profiling (identifying slow computational chunks) and taking advantage of parallel processing built into Mathematica.

Exercises

1. Generalize the RandomString function to allow for a Weights option so that you can provide a weight for each character in the generated string. Include a rule to generate a message if the number of weights does not match the number of characters. For example:













2. Write the function Anagrams developed in Section 9.2 without resorting to the use of Permutations. Consider using the Sort function to sort the characters. Note the difference in speed of the two approaches: one involving string functions and the other list functions that operate on lists of characters. Increase the efficiency of your search by only searching for words of the same length as your source word.
3. Rewrite the function FindWordsContaining using regular expressions instead of the patterns used in this section.
4. Using the text from several different sources, compute and then compare the number of punctuation characters per 1000 characters of text. gives a listing of many different texts that you can use.
5. The function StringPartition was developed specifically to deal with genomic data where one often needs uniformly-sized blocks to work with. Generalize StringPartition to fully accept the same argument structure as the built-in Partition.
6. Rewrite the text encoding example from Section 9.2 using StringReplace and regular expressions. First create an auxiliary function to encode a single character based on a key list of the form where is a plaintext character and is its ciphertext encoding. For example, the pair would indicate the character z in the plaintext will be encoded as an a in the ciphertext. Then create an encoding function using regular expressions to encode any string str using the key consisting of the plaintext/ciphertext character pairs.

References

List of Additional Material

Additional electronic files:

1. www.mathematica-journal.com/data/uploads/2013/04/638154522.tar.gz
2. www.mathematica-journal.com/data/uploads/2013/04/StopWords.dat

About the Author

Paul Wellin worked for Wolfram Research from the early 1990s through 2011, directing the Mathematica training efforts with the Wolfram Education Group. Prior to that, he taught mathematics at both public school and at the university level for over 12 years. He has given talks, workshops, and seminars around the world on the integration of technical computing and education and he has served on numerous government advisory panels on these issues. He is the author or coauthor of several books on Mathematica. In addition to his writing, he is currently involved with several consulting projects, as well as book design and composition projects.

Paul Wellin
Chico, California
paulwellin@gmail.com

Introduction

Robots are ideal vehicles for testing cognitive theories regarding learning, adaptations, and classification of environmental stimuli. Most robots are built around a central processor in charge of dealing with the motor output and the sensory input. To that end, in 2006 LEGO released a new programmable brick, the LEGO MINDSTORMS NXT. This brick, equipped with four sensor inputs and three motor outputs, has 256 kilobytes of flash memory in which files can be stored. It can run programs compiled for the brick (files ending with the .rxe extension and compiled for this system using LEGO LabVIEW or third-party compilers such as NBC or NXC). The versatility and low cost of this brick has made it an ideal vehicle for developing robotic projects.

The NXT is well-suited for developing autonomous robots such as scouting robots. Learning algorithms can also be tested; for example, to find the exit of a maze more aptly than by trial and error. Finally, the NXT can also be used to study social cognition models, in which multiple robots must interact to enhance the group survival rate.

This article shows how to control the brick over a Bluetooth communication link. We also introduce the Math4NXT package, which makes the task easier. Used in conjunction with Mathematica’s built-in Dynamic command, controlling a LEGO robot becomes very simple.

Establishing a Communication Link

The first time you start the NXT brick, use your computer’s Bluetooth tools to look for the brick and establish a communication link. On that very first use, you have to provide a passkey on the brick (default is “1234″) and on the computer. Then you need to choose the “Dev” service available on the brick. At that point, a virtual serial communication port (a COM port) is allocated to serve as a communication link between the computer and the brick. The exact COM port given is variable (e.g. COM11) but remains constant for this NXT-computer pair (detailed instructions to achieve the pairing can be found in [1]). Once you know which COM port to use, you do not need to repeat the process.

The NXT brick has an operating system (firmware) that immediately handles requests received from the COM port. It does so even if the brick is currently running a program. These commands are called direct commands in the LEGO documentation [2]. Direct commands include file manipulation, motor control, sensor configuration and reading, and communication between bricks. Commands are sent over the COM port as telegrams composed of a succession of bytes (numbers between 0 and 255). For some commands, a reply can be returned by the brick, also in the form of a telegram. Each telegram is preceded by the length of the telegram, given as a WORD number, that is, using two bytes. Hence, controlling the NXT brick is simply a matter of sending the correct bytes in the correct order over a serial port.

In order to use a serial COM port, use the Mathematica package called SerialIO [3]. This package has two parts. The first is an executable program, suited for your computer’s processor and operating system. SerialIO provides such programs for Linux and Windows OS (both 32 and 64 bit) as well as for Mac OS X. The second part has the Mathematica functions that can be used in your project. It includes the commands SerialOpen and SerialClose to open and close a communication link on a given COM port, and SerialWrite and SerialRead to send or receive bytes from the COM port. The following figure illustrates the different layers through which information goes during a communication between an NXT brick and a computer.

Figure 1. The software architecture by which an NXT brick and a computer can communicate. The last three boxes on the right represent Mathematica programs, and the last two are given by the package Math4NXT described next.

Get the package SerialIO from Wolfram Library Archive and install it in a folder of your choice (a good place is in the Mathematica AddOns folder, under the ExtraPackages subfolder). For convenience, you can set your working directory to this path so that the MathLink-compatible program is located automatically using the following instruction.

Then load the package with Needs.

The command is successful if you can see a process named SerialIO running in the background of your computer. The following command opens a COM port and therefore establishes a communication link with the brick (it must be turned on).

If you have an NXT brick and wish to evaluate the input cells in this article, select any input cell while holding the Alt key; that selects all input cells. Then from the Mathematica menu, choose Cell ▶ Cell Properties ▶ Evaluatable. Without an NXT brick, running these commands returns error messages or unevaluated input.

To see if the connection is open, look at the brick LCD display in the upper-left corner. If you see <, it means the connection is not established. However, <> means that the connection is established. The variable mybrick contains the stream descriptor of the COM port and is used in all subsequent communications. Closing the COM port is done with the following instruction.

Exiting Mathematica (or ending the kernel) also closes the COM port and purges the process SerialIO running in the background.

Sending a Telegram and Getting the Reply

The SerialIO package was made to send text over the COM port (either individual characters or strings of text). However, for controlling the NXT, it makes more sense to send numbers directly. Hence, we need to convert numbers to the corresponding letters in the ASCII code before sending them. This is a bit awkward and we propose a neater solution later.

A telegram always begins with one byte indicating whether the NXT should return a reply telegram or not. This is your choice, but many commands sent to the brick only return a status byte (0 for success, or an error message). In the case of a status byte, the reply telegram is not useful. To ask for a reply, the first byte must be 0; 128 means that the NXT must not send a reply.

The second byte of a telegram is always the command number. These numbers are given in the LEGO Group documentation [2]. The subsequent bytes depend on the command sent.

For example, asking the NXT to play a sound is achieved by the direct command PlayTone. Its command number is 3. Then two parameters must be provided: the tone frequency (a number between 200 and 14000) and the tone duration (in milliseconds, a number between 0 and 65535). These two parameters are coded as UWORD (unsigned WORD), that is, over two bytes, the least significant byte first. For convenience, we write a conversion function toUWORD.

Hence, a tone frequency of 480 Hz for a duration of two seconds corresponds to the following bytes.

The whole telegram would then correspond to the following.

It must be preceded by the telegram length, obtained with the following instruction.

We concatenate the two parts to get a complete message, and get a list of the characters corresponding to the numbers given (those characters may not be viewable on your computer system) with this line of code.

Let us send those characters to the NXT brick, one by one.

You should hear a tone now. Because we asked for a reply (the first byte was zero), we need to read it.

Again, the reply is composed of text (the characters of which may not be easily viewable). Let us convert them to a list of numbers.

The bytes returned are, in order: the length of the returned telegram, coded over two bytes in UWORD (here 3, 0 means a telegram of length 3); the number 2 indicates that this is a reply telegram; the number 3 indicates the command number that issued a reply (here, 3 is the number for the command PlayTone); and finally, the status of the command (where 0 indicates a success). The command PlayTone does not return other information; some direct commands may return more complex telegrams.

As an example, we send the command GetBatteryLevel. This command has number 11 and requires no parameters (no extra information). If a reply is asked for (but it is pointless to send this command and not ask for a reply), it returns the status of the command (0 for success) followed by two bytes indicating the voltage of the batteries on the NXT in millivolts. To decipher the voltage, let us create another conversion function, fromUWORD.

Let us assemble the telegram, concatenate the telegram length, convert this to a list of characters, and send them.

Now, let us read the reply and convert it to numbers.

The first two bytes are the reply length (5 bytes); 2 and 11 indicate that this is a reply for a GetBatteryLevel command; 0 indicates that the command was successful; and finally, 247 and 27 indicate the battery voltage, which we convert to a number with fromUWORD, defined above.

Hence, the batteries convey 7.16 volts, much below the expected 9 volts for fresh batteries.

Override SerialWrite to Send an Integer or a List of Integers

Because it is more convenient to think in terms of numbers sent to the brick rather than characters, we expand the command SerialWrite contained in the package SerialIO to include the possibility of sending individual integers between 0 and 255 (bytes), and also to send a list of bytes.

With this expansion, a whole message (composed of bytes) can be sent in one call to SerialWrite. For example, the following instructions assemble again the PlayTone command (this time without a reply).

The whole message is sent with one command call.

The Direct Commands Provided in Math4NXT

The above shows how any command can be sent to the NXT brick and its reply read. Afterward, it is simply a question of assembling a telegram in the right order with the right information, and—if asked for—reading the reply and segmenting it into the correct information. To that end, the documentation provided by the LEGO Group ([2], particularly the appendix 2) is quite complete.

To make things simpler, we coded all the direct commands in a package called Math4NXT. First get the package Math4NXT. Since it uses the package SerialIO in the background, also install this package in a path that is searched by Mathematica (e.g. FileNameJoin[{$InstallationDirectory, "AddOns", "ExtraPackages", "SerialIO"}] ). Then load Math4NXT using the following instruction.

Since we did not place the package Math4NXT in a folder searched by Mathematica, we provided its path in the Needs instruction. Then open the serial port (if this was not already done) as before.

All the direct commands begin with the letters NXT. Hence, to read the battery level, the command in the package is called NXTGetBatteryLevel.

By default, the command returns the answer using named strings (e.g. "Status"). You can extract one piece of information as usual.

This format can be changed, for example to raw (i.e. bytes as in the previous two sections), using the option ResultFormat.

Alternatively, the bytes sent and received can be displayed in a separate window using the option .

This option opens the Messages window.

Figure 2. The Messages window opens automatically when the option is used.

All the direct commands are accessible.

Extending the Direct Commands

The direct commands have many limitations. For one, due to the nature of the COM port, messages cannot be longer than 253 bytes. This is a big limitation when dealing with files that can be much longer. Also, the LEGO sensors all work in very different ways; some sensors are passive, not requiring power, while others are active, and still others are programmable, like the I2C sensors. To make use of the commands more uniformly and to avoid the length limitation, we programmed higher-level commands that deal internally with these difficulties.

The names of all of these commands begin with M4N.

One example is the command M4NFileNames that lists all the files present on the brick (optionally with the file size).

This command works by calling the direct commands NXTFindFirst (command number 134), NXTFindNext (135), and NXTClose (132), using the algorithm given in Program 1. To see the multiple calls to NXT commands, use the option in M4NFileNames.

res=NXTFindFirst[mybrick,"*.*"];
While [("Status"/.res)=0,
    res=NXTFindNext[mybrick,"Handle"/.res]
]
NXTClose[mybrick];

Likewise, to facilitate the use of sensors, a command is provided that informs Mathematica of the sensor types connected. Afterward, reading the sensor is done according to the type of sensor connected. To set the sensor type, use M4NSetSensor.

After this, reading the sensor is done with a universal command, M4NReadSensor. To keep in line with the convention of direct commands, the first sensor is on the NXT input port 0.

The result is either 1 for “pressed” or 0 for “unpressed.” This command works the same way whatever type of sensor is connected. Hence, if you connect the ultrasound sensor on the third sensor input, you can issue the following two commands.

The ultrasound sensor is a complex sensor aimed at detecting the distance of obstacles in front of it (in centimeters). It is equipped with a microprocessor that follows the I2C protocol. It must first be powered up and time given to it to boot up before a reading can be made. Using the option , you see that much more exchange of information is needed to initialize an ultrasound sensor than to initialize a touch sensor. Yet, all these transactions are completely invisible with the M4N commands.

Working with Motors

Another limitation of the direct commands provided by the NXT’s firmware concerns the motor control. The new LEGO motors contain tacho counters that keep track of the number of degrees of rotation executed. However, the direct command can only stop a motor once a target number of degrees is reached, so that in effect, the motor overturns.

PID control of a motor is a more effective way of controlling rotation. It sets a target number of degrees and adjusts the power of the motor so that it slows down when the target is almost reached (using integral and derivative; see [4, 5]).

The authors of [5] developed a PID controller for the NXT. This controller is located on the NXT brick; the computer sends a target movement, and the controller takes control of the motor, adjusting the power until the target number of degrees is reached. The controller program is called MotorControl22.rxe, for Version 2.2.

Get the program MotorControl22.rxe and transfer it to the brick. To do so, import the contents of the file into Mathematica and download this to the NXT. Once set (this step may take a few minutes over Bluetooth as the controller is 37 kilobytes long), start the controller. Here are the instructions to do so; the first part checks that the file is not already on the brick.

Finally, inform your program of what type of motors you have and to which port they are connected using M4NSetMotor.

Incidentally, M4NSetMotor uploads MotorControl22.rxe if it is not present on the brick, and starts this program if it is not currently running. Therefore, you do not have to worry about these technicalities and can rely on M4NSetMotor alone.

Now that the controller is up and running, you can send orders to it using commands related to motors.

M4NRunMotor, M4NStopMotor, and M4NBrakeMotor can be used on regular motors as well as on tacho motors. However, M4NRunMotorFor can only be used with tacho motors and involves the PID controller. Once a motor is controlled by the PID controller, you should not send other instructions to it. Therefore, the predicate M4NRunMotorFreeQ can be used to check if the controller is done.

The following instruction starts the two motors.

Stop the motors using two different modes (M4NBrakeMotor locks the motor, whereas M4NStopMotor ceases to power the motor).

The following instructions check that motor MOTORA is free before a movement, during the movement (10 complete turns), and six seconds after the movement began.

Configuring a Robot

At the level of the program, a robot has a certain configuration, defined by what sensors are connected to the input and what motors are connected to the output. We showed two commands earlier that can be used to define the sensors and the motors.

We created a general command, M4NInitialize, whose purpose is to set all these items in one command. In addition, it can also be used to set the volume level and give a name to the brick (if you have many bricks, a good habit is to rename them by the COM port to which they are connected).

In addition, M4NInitialize checks that the firmware version on the NXT is compatible with this package and checks that the battery has enough charge (it returns a warning if not). It is also possible to give the path of the folder containing the controller MotorControl22.rxe with the option MotorControlPath in case it is not already on the NXT.

Dynamic Control of the Robot

The M4N and NXT commands can be used dynamically. For example, to get the current state of the touch sensors, you can follow these steps.

First, initialize the sensors using M4NInitialize or M4NSetSensor.

The ShowSensor function creates a panel with a title containing On or Off, based on the sensor value. This function uses some options for aesthetic purposes only.

Then, we can use ShowSensor four times in a row to get a row of indicators.

The option UpdateInterval determines at what interval the sensors are consulted.

As a last example, we create a joystick that controls two motors. The speed of rotation of the motor (adjusted by the MotorPower option) depends on the up/down position of the joystick. In addition, the motors move synchronously if the left/right position of the joystick is centered.

We first define an extended ClickPane that responds to more events than the regular ClickPane function.

We must not forget to initialize the motors (so that the PID controller is turned on).

That is it. The following shows a panel with a red dot (the top of the joystick). It constantly sets the motor power to be proportional to the position of the joystick. In addition, if the joystick is released, it returns to the center with an exponential function implemented by the variable mult. Finally, if you click the pane anywhere, the joystick instantly returns to the center with a beep.

A Line-Follower Project

To illustrate a simple example of an autonomous robot, we program the line-follower robot. This robot’s purpose is to follow the edge of a line. The line should be dark on a light background (or vice versa; the contrast along the edge is the important factor). To achieve this, you need a robot equipped in the front with a light detector (see, for example, the assembly instructions given on p. 33 of the MINDSTORMS education booklet [2]).

For this project, the configuration requires a light sensor and two motors, which we initialize.

In a first phase, we need to calibrate the sensor so that the readings on light and dark surfaces are known. Use the following to average 100 readings while you move the robot over a white surface.

Then use this while moving the robot over a dark surface.

The mean of the above two values is the critical value. For a robot that follows the left edge of a dark line, for readings lighter than the mean, we want the robot to steer to the right (and for readings darker than the mean, we want the robot to steer to the left).

The following short program moves the robot at a moderate speed (the variable basespeed is set to 20) and adjusts the base speed according to the difference between the current reading and the mean.

The constant mult is used to control the magnitude of the steering. Larger values result in a robot’s making abrupt changes in direction. This quantity should be small for smooth movement. Yet, if there are abrupt curves in the trajectory, a small multiplier gives a robot that cannot turn enough to find the edge again. See the conclusion for more discussion.

Technical Limitations

There are a few direct commands that we chose not to implement in this package. These are concerned with rebooting the NXT brick, changing its firmware, erasing the flash memory, or executing a reset. In essence, these commands destroy the robot.

With the M4N commands and the NXT commands, the robot can be controlled very efficiently and very easily. However, the COM port is not very fast. Crucially, each switch in the direction of communication of the port requires 6 ms. This is the reason why replies should be avoided unless they are absolutely necessary. In some applications, these delays may be so important that the program must be moved to the brick in whole or in part. The PID controller MotorControl22.rxe is an example where the program is distributed over the two machines: the computer sends target moves and the brick executes the decisions millisecond by millisecond to achieve the requested move.

Conclusion

One recent theory in cognitive science is the embodiment theory. It states that a cognitive system must be in an interactive relation with the world to develop a meaningful representation of the world. This view contradicts the classical artificial intelligence (AI) view in which cognitive agents manipulate tokens or symbols that may not necessarily be related to aspects of the outside world. Hence, according to the AI view, the sensors and actuators are independent of the cognitive functions and may be built separately. This view is tenable as long as we are devising cognitive systems in a virtual world (e.g. using computer-based simulations). However, as soon as physical robots are actually constructed, we see how difficult it is to hold this position.

The simple line-follower program shows this. In a virtual environment, the line-follower simulator can be run at full speed and steering can be made as abrupt as desired, because there is no inertia and no risk that the robot falls over. When the physical robot is built, these become very serious concerns. Of course, the programmer adapts the program to take these risks into account (reducing the speed and lowering the multiplier factor). Likewise, the white and black readings are calibrated by the programmer in a very simple way. Yet, if the ambient lighting changes, the calibration must be done again. Further, as said earlier, if the multiplier mult is too small, the robot may not be able to steer quickly enough around a sharp curve. Finally, the line-follower robot uses wheels. If it used legs instead, flexibility and possible muscle tear would come into play.

All the above concerns can be seen at worst as annoyances, at best as challenges for the programmer. Yet, the simplest animals are immune to all of these concerns. The embodiment theory holds that organisms developed adequate representations by interacting with the world, and that those representations became robust with regard to all the possible sources of fault. Representations and algorithms given by a programmer, on the other hand, may not respond to real-life tests, however simple or elegant they are.

The NXT is a simple yet complete platform to test robots in real life. Combined with Mathematica’s computational power, it is easy to develop adaptive algorithms such as neural networks and see what kind of representations are self-constructed by the robot. It remains to be seen what the simplest adaptive line-follower program looks like.

Acknowledgments

The author would like to thank Vincent Brault, Dominic Langlois, and Sylvain Chartier from the CONEC laboratory, University of Ottawa, for their help during the development of the Math4NXT package.

References

About the Author

Denis Cousineau is a professor at the University of Ottawa in cognitive psychology. He runs research in artificial intelligence as well as on human categorization processes.

Denis Cousineau
École de psychologie
Université d’Ottawa
136, rue Jean-Jacques Lussier
Ottawa (ON), K1N 6N5, CANADA
Denis.Cousineau@UOttawa.ca

Mathematica organizes text, computable mathematical typesetting, and graphics as a notebook document. 3D computer graphics simulation, animation, and rendering systems organize graphics primitives so as to give the user a handle on the complexity required to model reality—a formidable task. An animation system, such as Autodesk Maya [2], presents complexity in a hierarchical way such that it can be selectively hidden, but subparts of it can be easily navigated to in order to manipulate the graphics primitives that make up the simulated 3D graphic scene.

Figure 1. Pt. Reyes [3, 4].

In Mathematica and in an advanced 3D graphics animation or simulation system, the task of representing 3D graphics primitives for manipulation and then passing them off to graphics hardware or to an external system for high-quality rendering is the same, but a high-performance animation system approaches the task differently from Mathematica. In the early 1990s, Silicon Graphics, Inc. (SGI) devised the scene graph as a hierarchical mechanism for organizing complex 3D graphics simulations. The scene graph model has been adopted by most powerful animation systems. But, expressions in Autodesk Maya—the language it provides to extend its capabilities to model real-world processes—are very limited. The high-performance animation system is optimized to manipulate complexity, but not to generate it.

The Mathematica language’s ability to computationally model reality is absolutely unlimited. Circa 1993, the Symbolics S-Graphics package was widely thought to contain the best geometrical modeling system available for animation [5]. Symbolics spawned the Open Genera Lisp system and the Macsyma computer algebra system. The bottom-level string-rewriting system of Mathematica is like Lisp. Mathematica’s programming paradigm promotes use of (lambda) functions. I think that these parallels between Mathematica and a very advanced, albeit historically early, computer animation system should not be dismissed.

Advanced 3D graphics animation and simulation systems can benefit from Mathematica’s programming language and Mathematica graphics can benefit from the hierarchical organization of the animation scene graph. It is easy to get started using a scene graph in Mathematica. I used this technique in the animated hand model of the “Fingerspelling Sign Language” Wolfram Demonstration [1].

The scene graph is a basic structure of the SGI Open Inventor system [6]. (See Figure 2 and also the Coin3D project) [7]. These systems render graphic primitives interactively by traversing the scene graph (it is a tree structure) and emitting OpenGL code (a language understood by graphics hardware) [8] for the graph Shape node entities as they are traversed [9]. Graphics Shape primitives are animated by placing 3D coordinate Transform nodes ahead of them in the scene graph [10]. A transformation stack is accumulated as the traversal descends tree branches, and the stack of transforms is applied to the graphics shape primitives and emitted as OpenGL (or other RenderAction) directives as they are encountered [11].

Figure 2. “Example of a Scene Graph” (Chapter 1, Figure 1-2 , [6]).

Open Inventor 2.0 became the basis for the first version of the Virtual Reality Modeling Language (VRML 1.0) [12]; X3D [13] is the latest successor to VRML Version 2.0 [14] (1997) and it is implemented in XML. In Open Inventor, Separator [15] nodes are objects that inherit from the Group class (e.g., a Separator node is a kind of Group object) [16]. In VRML 2.0, Transform nodes also act implicitly as a Group mechanism in the hierarchy as well. Property nodes include Materials, which specify object surface illumination and appearance properties to be applied to subsequent Shape nodes in the scene graph tree.

If the Computable Document Format (CDF) is Mathematica’s answer to the Portable Document Format (PDF), then CDF organizes Graphics3D objects in it as a two-dimensional document. The X3D Document Object Model (DOM) [17] could be Mathematica’s answer to organizing Graphics3D objects in the animation scene graph to represent a virtual world.

The key to this observation was the work I did on the Wolfram|Alpha Pro XML file upload scanner [18]. As of the time of this writing, Wolfram|Alpha and the Wolfram Demonstrations Project are compatible with Mathematica 8. In this version, Mathematica does not yet have an X3D importer, but I have discovered that it is actually much more powerful to import an animation scene graph implemented in X3D using Mathematica’s quite excellent XML importer. All you have to do to use it is to rename the X3D file to use the .xml extension instead. The XML importer preserves the tree hierarchy of the XML Document Object Model (DOM) and allows you to traverse the X3D animation scene graph in Mathematica after the style of an advanced animation system such as Autodesk Maya.

Figure 3 shows the Maya outliner user interface view of an animation rig to articulate a “sausage” hand model constructed of Non-Uniform Rational B-Spline (NURBS) sphere primitives. The tree structure represents the parent-child hierarchy of sphere geometry nodes and their 3D coordinate transforms. The nodes in the graph are selectable and, when selected, provide access to the Maya animation channel editor for the transform values (translation, rotation, scale) for each node.

Figure 3. Outliner user interface in Autodesk Maya 2013.

Figure 4 shows the ExpressionTreePlot seen when you upload to Wolfram|Alpha Pro the X3D scene graph for the hand model of the “Fingerspelling Sign Language” Demonstration as an XML file. This file is supplied in the additional electronic files accompanying this article.

The Wolfram|Alpha XML Pro upload response shows an ExpressionTreePlot, restyled for Wolfram|Alpha, of a simplification of the XML DOM tree.

Figure 4. The response to uploading an X3D hand animation rig as XML to Wolfram|Alpha Pro.

The XML file itself is of the following form.

<?xml version=”1.0″ encoding=”UTF-8″?>
…
<!DOCTYPE X3D PUBLIC “ISO//Web3D//DTD X3D 3.0//EN” …
…
<head>
…
</head>
<Scene>
<Group>
…
<Transform DEF=’Relbow’ translation=’0.0 0.0 0.0′
rotation=’0.0 0.0 1.0 0.0′>
…
<Shape DEF=’Rhand_thumbMcarpalGeom’>
<Sphere DEF=’Rhand_thumbMcarpalSphere’/>
</Shape>
…
</Transform>
…
</Group>
</Scene>
</X3D>

The XML should be imported into the Mathematica “Fingerspelling Sign Language” Demonstration notebook source as follows.

The handXML expression is paraphrased for readability. Please see the “Fingerspelling Sign Language” Demonstration notebook source for the complete expression. Where hierarchy in the XML file is denoted by <tag>…</tag>, hierarchy in the Mathematica structure is denoted by bracketed lists. The complete structure of the handXML expression is depicted in the ExpressionTreePlot in the Wolfram|Alpha XML file upload result.

In order to generate Graphics from the XML object hierarchy, functions must be written to translate X3D Transform and Shape nodes into the Mathematica Graphics3D equivalents. I provide some of these functions in the downloadable source code for the “Fingerspelling” Demonstration. In the X3D file, the Transform and Shape nodes are all named using the “DEF” rule. In an advanced animation system like Maya, names carry a huge amount of information and are absolutely essential.

A node selection user interface for the Animated Hand Model of the “Fingerspelling” Demonstration using a hierarchy of OpenerView instead of a static Grid of Checkbox can be constructed automatically in Mathematica by recursively traversing the X3D DOM tree (scene graph) using XMLObject. The structural hierarchy required to articulate the hand bones through a kinematic transform stack is reflected in the structure of the node selection user interface. Compare these graphics to the Outliner node selection user interface from Autodesk Maya, which was built precisely for the task of managing kinematic animation on a complex rig.

Figure 5. A node selection user interface for the Animated Hand Model of the “Fingerspelling” Demonstration using a hierarchy of OpenerView.

See also the Demonstrations “3D Skeletal Anatomy of the Arm” and “3D Skeletal Anatomy of the Torso” [19, 20], which use a similar Graphics3D node selection user interface.

In the “Fingerspelling” Demonstration, I stored animation channels for keyframes as lists of node name and channel value rules.

Similarly, the node selection state is keyed by the Shape node name. The staticSelection list contains twenty rules in the “Fingerspelling” Demonstration source, paraphrased here for readability.

I apply the animated transform values to the X3D scene graph as imported into Mathematica using , a recursive function. Then I use collectTransforms to collect a stack of geometric coordinate transforms from the XML transform elements descending a branch. Then I apply Sow to a function that applies Mathematica geometric transforms to every XML Shape node encountered. To show the Graphics3D, I apply Reap to the results of ApplyXFormStack as follows.

Again, ApplyXFormStack calls collectTransforms descending the branches of the scene graph tree—analogous to glPushMatrix of OpenGL—and applies that transform stack to each Shape node it traverses. In the “Fingerspelling” Demonstration, we do ease-in/ease-out interpolation between anim lists containing keyframe poses corresponding to letters of the alphabet, then apply the interpolated rotation angle value to the joint transform of the same name.

Reading X3D as XML fully exposes all of the security vulnerabilities inherent in importing XML files into Mathematica. The Mathematica XML importer initially reads all of the Graphics Coordinate, Coordinate Index, and Transform fields as strings, which then must be converted to lists of numerical values using either ToExpression or Read. It is easy to encode expressions into an XML file that can do damage to a computer execution environment or file system when Mathematica runs Read or ToExpression on them. For similar reasons, Read and ToExpression are prohibited from Wolfram Demonstration notebooks.

Figure 6. An animated clip from the “Fingerspelling” Demonstration.

In “Fingerspelling Sign Language Using an Animated Hand Model,” keyframed animation curves are simple, sinusoidal ease-in/ease-out moves, whereas Maya uses cubic spline curves to interpolate animation channels. But the key point here is what is required to organize and animate multiple GraphicsComplex subparts of a complex Graphics3D object in Mathematica. In my opinion, the X3D incarnation of VRML represented in the XML DOM tree is an excellent model for doing this.

Acknowledgments

Thanks to George Fann, who first suggested that I look at X3D.

References

[1]	S. Dickson and S. Martell. “Fingerspelling Sign Language Using an Animated Hand Model” from the Wolfram Demonstrations Project—A Wolfram Web Resource. www.demonstrations.wolfram.com/FingerspellingSignLanguageUsingAHandModel.
[2]	Autodesk. “Maya.” (Feb 1, 2013) usa.autodesk.com/maya.
[3]	Wikipedia. “Reyes Rendering.” (Feb 1, 2013) en.wikipedia.org/wiki/Reyes_rendering.
[4]	R. Cook, L. Carpenter, T. Porter, B. Reeves, D. Salesin, and A. R. Smith. “Pt. Reyes.” (Feb 14, 2013) alvyray.com/Art/PtReyes.htm.
[5]	Wikipedia. “Symbolics.” (Feb 1, 2013 ) en.wikipedia.org/wiki/Symbolics.
[6]	J. Wernecke, “The Inventor Mentor: Programming Object-Oriented 3D Graphics with Open Inventor, Release 2,” Redwood City, CA: Addison-Wesley, 1994. techpubs.sgi.com/library/dynaweb_docs/0630/SGI_Developer/books/Inv_Mentor/sgi_html/index.html.
[7]	Kongsberg Oil & Gas Technologies. “Coin3D.” (Feb 1, 2013) bitbucket.org/Coin3D/coin/wiki/Home.
[8]	Silicon Graphics, Inc. “OpenGL: The Industry’s Foundation for High Performance Graphics.” (Feb 1, 2013) www.opengl.org.
[9]	Kongsberg Oil & Gas Technologies. “SoShape Class Reference [Node Classes].” (Feb 1, 2013) doc.coin3d.org/Coin/classSoShape.html.
[10]	Kongsberg Oil & Gas Technologies. “SoTransform Class Reference [Node Classes].” (Feb 1, 2013) doc.coin3d.org/Coin/classSoTransform.html.
[11]	Kongsberg Oil & Gas Technologies. “SoGLRenderAction Class Reference [Action Classes].” (Feb 1, 2013) doc.coin3d.org/Coin/classSoGLRenderAction.html.
[12]	VRML.org. “Virtual Reality Modeling Language.” (Feb 18, 2013) web.archive.org/web/20121017095254/http://www.vrml.org.
[13]	Web3D Consortium. “X3D Developers.” (Feb 4, 2013) www.web3d.org/x3d.
[14]	A. Ames, D. Nadeau, and J. Moreland, VRML 2.0 Sourcebook, New York: John Wiley & Sons, 1996. www.web3d.org/x3d/content/examples/Vrml2.0Sourcebook/index.html.
[15]	Kongsberg Oil & Gas Technologies. “SoSeparator Class Reference [Node Classes].” (Feb 4, 2013) doc.coin3d.org/Coin/classSoSeparator.html.
[16]	Kongsberg Oil & Gas Technologies. “SoGroup Class Reference [Node Classes].” (Feb 4, 2013) doc.coin3d.org/Coin/classSoGroup.html.
[17]	w3schools.com. “XML DOM Tutorial.” (Feb 5, 2013) www.w3schools.com/dom/default.asp.
[18]	Wolfram Research. “Wolfram|Alpha Pro XML File Upload Example.” (Feb 4, 2013) www.wolframalpha.com/input/?i=+&examplefile=1&lk=3&fileinput=FileUpload%2FAnimatedMethane.xml.
[19]	S. Dickson. “3D Skeletal Anatomy of the Arm” from the Wolfram Demonstrations Project—A Wolfram Web Resource. demonstrations.wolfram.com/3DSkeletalAnatomyOfTheArm.
[20]	S. Dickson. “3D Skeletal Anatomy of the Torso” from the Wolfram Demonstrations Project—A Wolfram Web Resource. demonstrations.wolfram.com/3DSkeletalAnatomyOfTheTorso.
S. Dickson, “Advanced Animation in Mathematica,” The Mathematica Journal, 2013. dx.doi.org/doi:10.3888/tmj.15-2.

List of Additional Material

Additional electronic files:

1. www.mathematica-journal.com/data/uploads/2013/02/RHandTootsie2scale.xml

About the Author

Stewart Dickson was a programmer of 3D computer graphics and animation for broadcast video, theatrical film, digital cinema, and location-based entertainment from 1984 to 2002. He was a pioneer in digital sculpture from 1989. He has worked at Walt Disney Feature Animation, Oak Ridge National Laboratory, and the NOAA National Climatic Data Center. He has worked at Wolfram Research since 2011.

Stewart Dickson
Wolfram Research, Inc.
100 Trade Center Drive
Champaign, IL 61820-7237
sdickson@wolfram.com

This article carries out the evaluation of kinetic energy integrals using Gaussian-type functions with arbitrary Cartesian angular values. As an example, we calculate the kinetic matrix for the water molecule in the STO-3G basis set.

Introduction

In this article, the second of a series describing algorithms for evaluating molecular integrals, we detail the evaluation of the kinetic energy integrals. Detailed accounts of molecular integrals can be found in the references of [1]. The electronic kinetic energy in atomic units () involves integrals of the type

(1)

in which is an unnormalized Cartesian Gaussian primitive centered at the nucleus :

(2)

Here is the orbital exponent and the polynomial represents the angular part, in that the sum of the Cartesian angular momenta corresponds to functions of type , , , , …. One notable property of the Gaussian function, which will be used here, is that the derivative of a Gaussian function can be expressed as a sum containing Gaussians of lower and higher Cartesian angular values. In particular,

(3)

Similarly, . This property is useful in integrals involving differential operators, such as the kinetic energy; in calculations involving the gradient of the energy or Hamiltonian; and in deriving one of the most important algorithms of Gaussian function computation, the recurrence relation.

The kinetic operator, expressed in Cartesian coordinates as , enables separation of the kinetic integrals into three components . For example,

(4)

Furthermore, if we also separate into its Cartesian components, becomes a product of three integrals

(5)

Derivative of Gaussian Functions

The last two integrals in are simply overlap integrals and can be evaluated as outlined in [1]. Integrating by parts, the first integral is

(6)

where, according to the property mentioned above, the first term can be expanded into two Gaussian products, which vanish at the integral limits.

Next, we consider the first term of the integrand. Expressing equation (3) in terms of (1) and rearranging, we get

(7)

Substituting the result into equation (6), we have

(8)

and expanding the polynomial part yields

(9)

We can now express the first integral of equation (5) in terms of one-dimensional Gaussian primitives:

(10)

Kinetic-Energy Integral

We have now shown that the kinetic-energy integral can be written as a product of overlap integrals. The component, for example, is given by

(11)

Recurrence Relations

Using the notation of [1], where the overlap integral of two Gaussians is expressed in terms of its orthogonal components,

(12)

the component of the kinetic-energy integral, equation (11), can be written as

(13)

where the factor has been absorbed into the definition of the kinetic integral . We will derive the recurrence relation for this term . For , the first three terms of equation (13) are zero, and we are left with . Analogously, for or , we have

(14)

and the recurrence relation for the kinetic integral function with any two Cartesian angular momenta generalizes to

(15)

Implementation

The function Kin evaluates the kinetic integral of two Gaussian primitives; here alpha, beta, RA, RB, LA, and LB are , , , , , and as defined earlier. The first step is the evaluation of the overlap integral as described in [1].

We describe in detail the evaluation of the kinetic-energy matrix for the water molecule (, , the geometry optimized at the HF/STO-3G level). The molecule lies in the - plane with Cartesian coordinates in atomic units.

In the STO-3G basis set, each atomic orbital is approximated by a sum of three Gaussians; their unnormalized primitive contraction coefficients and orbital exponents (taken from [2]) are as follows.

Here are basis function origins and Cartesian angular values of the orbitals, listed in the order , , , , , , and .

Specifically, for the kinetic-energy integral of the first primitive of the orbital of hydrogen atom 1, , and the first primitive of the orbital of the oxygen atom, ,

(16)

where the indices indicate primitive of basis function . The kinetic integral in terms of the kinetic and overlap function is then

(17)

We start with and , and from the first four equations of the module, we use the recurrence scheme to build up the overlap values needed for . We will need values up to ,

(18)

leading to .

Similarly, for , we will need which, in turn, comes from and . We have

,

,

,

leading to .

For the component,

,

,

,

leading to .

With , the kinetic integral of equation (16) is , which we can also obtain from the module Kin.

Three Gaussian primitives for each atomic orbital result in nine integrals of the type that we have just evaluated. For example, the element of the kinetic-energy matrix,

(19)

is , derived via a contraction scheme that requires the following normalization factor.

This calculates .

For larger basis sets, one needs only to replace the summation upper limit 3 in equation (19) with the appropriate number of primitives belonging to a particular basis function and an additional summation for the basis functions.

Finally, here is the resulting kinetic energy matrix.

Since the kinetic-energy matrix is symmetrical, we need only to calculate the upper elements. The value of the elements hartree is the electronic kinetic energy of the hydrogen atom described by the STO-3G basis set (compared to the exact value of 0.5 hartree). Analogously, the element is the corresponding kinetic energy of an electron in the orbital of the oxygen atom, and so forth.

Conclusion

We have provided an introduction to the evaluation of kinetic-energy integrals involving Gaussian-type basis functions both analytically and by use of recurrence relations. The results are sufficiently general so that no modification of the algorithm is needed when larger basis sets with more Gaussian primitives or primitives with larger angular momenta are employed.

References

M. Hô and J. M. Hernández-Pérez, “Evaluation of Gaussian Molecular Integrals II,” The Mathematica Journal, 2013. dx.doi.org/doi:10.3888/tmj.15-1.

About the Authors

Minhhuy Hô received his Ph.D. in theoretical chemistry at Queen’s University, Kingston, Ontario, Canada in 1998. He is currently a professor at the Centro de Investigaciones Químicas at the Universidad Autónoma del Estado de Morelos in Cuernavaca, Morelos, México.

Julio-Manuel Hernández-Pérez obtained his Ph.D. at the Universidad Autónoma del Estado de Morelos in 2008. He has been a professor of chemistry at the Facultad de Ciencias Químicas at the Benemérita Universidad Autónoma de Puebla since 2010.

Minhhuy Hô
Universidad Autónoma del Estado de Morelos
Centro de Investigaciones Químicas
Ave. Universidad, No. 1001, Col. Chamilpa
Cuernavaca, Morelos, Mexico CP 92010
homh@uaem.mx

Julio-Manuel Hernández-Pérez
Benemérita Universidad Autónoma de Puebla
Facultad de Ciencias Químicas
Ciudad Universitaria, Col. San Manuel
Puebla, Puebla, Mexico CP 72570
julio.hernandez@correo.buap.mx

Fourier-space representation of the partial differential equations describing nonlinear dynamics of continuous media in cylindrical geometry can be achieved using Chandrasekhar-Kendall (C-K) functions defined over infinite domain as an orthogonal basis for solenoidal vector fields and their generating function and its gradient as orthogonal bases for scalar and irrotational vector fields, respectively. All differential and integral operations involved in translating the partial differential equations into transform space are then carried out on the basis functions, leaving a set of time evolution equations, which describe the rate of change of the spectral coefficient of an evolving mode in terms of an aggregate effect of pairs of interacting modes computed as an integral over a product of spectral coefficients of two physical quantities along with a kernel, which involves the following integral:

involving the product of three Bessel functions of the first kind of integer order. This article looks at this integral’s properties using a semi-empirical approach supported by numerical experiments. It is shown that this integral has well-characterized singular behavior. Significant reduction in computational complexity is possible using the proposed empirical approximation to this integral.

Introduction

Fourier-space representation of the nonlinear dynamics of continuous media is useful in studies on turbulent or self-organizing behavior that looks at the transport of energy across a wide range of scale lengths. Many problems in physics possess a native cylindrical geometry, and for such cases Chandrasekhar-Kendall (C-K) functions [1] (curl eigenfunctions) provide a complete orthogonal basis [2] for solenoidal fields, under appropriate boundary conditions. C-K functions defined over a finite cylinder have been used as an orthogonal basis for spatial-spectral expansion methods in plasma physics, usually in the incompressible regime [3, 4, 5], which neglects the role of irrotational fields in plasma dynamics. However, there are important physical effects [6] that involve a nonlinear interaction between solenoidal and irrotational fields, which can be studied only if both irrotational and solenoidal fields are taken into account on an equal footing.

The limitation to incompressible flows (or solenoidal fields in general) in spatial-spectral methods referred to above arises from the fact that the radial component of C-K functions and the radial derivative of their generating function (scalar potential solution of the Helmholtz equation) cannot both be zero on the same finite cylinder, so that the gradient of the generating function does not provide an orthogonal basis for irrotational flow. In contrast, when defined over an infinite domain, the generating function and its gradient do serve as orthogonal bases for scalar and irrotational vector fields, respectively. This is equivalent to Fourier-space representation in cylindrical geometry.

Although the mathematics of Fourier-space representation deals with spatial dimensions of the system and Fourier-space coordinates ranging from zero to infinity, no physical system has infinite size, and physical models of continuous media often stipulate a lower bound on scale lengths as a condition for their applicability. An infinite domain thus has a utilitarian meaning within the context of a physical theory: the upper and lower limits of integral transforms used in a physical theory are physically meaningful large and small numbers; mathematical zero and infinity are used to obtain the limit of a sequence of calculations with increasingly smaller and larger limits of integration in the interest of obtaining a tractable model and experimentally verifiable predictions [7].

The C-K functions, eigenfunctions of the curl operator in cylindrical geometry (defined by unit vectors , , and with coordinates ) are defined as , . The set of eigenfunctions, labeled by the four parameters , , , , is

(1)

The parameter labels circular polarizations and is the azimuthal mode number; the radial mode number and axial mode number are related to the magnitude of the eigenvalue by the relation . The orthogonality relations over an infinite cylinder are:

(2)

For the infinite domain, the generating function of C-K functions

(3)

satisfies the relation

(4)

and its gradient satisfies the following relations

(5)

The orthogonality between the gradient of the generating function and the C-K functions is an exact consequence of their structure and does not depend on their asymptotic behavior. Partial differential equations of the nonlinear dynamics of continuous media can be translated into cylindrical Fourier space by performing all differential and integral operations with respect to spatial variables on the basis functions, leaving a set of time evolution equations. As an example, the equation of continuity,

(6)

can be written in transform space as

(7)

with the following shorthand notation: . The spectral coefficient of density is , that of solenoidal velocity is , and that of irrotational velocity is . The functions of mode numbers used in equation (7) are defined as

(8)

(9)

(10)

Time-evolution equations like (7) describe the rate of change of the spectral coefficient of an evolving mode on the left-hand side (LHS) in terms of an aggregate effect of pairs of interacting modes on the right-hand side (RHS) computed as an integral over a product of spectral coefficients of two physical quantities along with a kernel. The physics contained in the vector and differential operators of the partial differential equations is transferred to the functions of mode numbers similar to , which involve the following integral over an infinite domain consisting of products of three Bessel functions of the first kind of integer order,

(11)

This integral, referred to in the next section as the triple-Bessel (or 3B) integral, belongs to a class of integrals discussed by Watson [9, 10], whose analytical theory is not known and is the subject of this article. From (7), its properties as a distribution are seen to be relevant, but not its numerical value as a conventional Riemann integral, which may not exist for some values of its arguments. The comment made above concerning the utilitarian meaning of infinity in physical theory applies in this context, where properties of a sequence of integrals similar to (11) with increasingly larger but finite upper limit can be investigated usefully. The upper limit of integration is therefore mentioned as an argument in (11). Whenever the argument is not mentioned, it is implied to be infinity.

Transformation of the equations of continuity and momentum conservation in the two-fluid model of plasma into cylindrical Fourier space involves 115 instances of the 3B integral in 19 expressions similar to those described in equations (8)-(10) [8]. Investigations of plasma phenomena involving nonlinear interaction between solenoidal and irrotational fields, such as self-organization or turbulence in the two-fluid plasma model, would benefit considerably if an adequate approximation of the 3B integral becomes available. This is the motivation of the present work.

Properties of the Triple-Bessel Integral

The 3B integral is trivially invariant under permutation of pairs of arguments , , . If the arguments , , are scaled as , , , then the integral scales as

Since azimuthal mode numbers can be positive or negative integers or zero,

reflecting the property of Bessel functions of integer orders: .

Using the known relations for Bessel functions

(12)

(13)

the following properties of the triple-Bessel integral can be derived as

(14)

The 3B integral is thus the Hankel transform of of order , and its inverse Hankel transform is also seen to exist.

Relations (12) and (13) yield

(15)

For , . If in addition ,

(16)

For , , the following result is known [10, p. 412] in terms of Legendre functions :

(17)

The following simpler case is also known, corresponding to the case , equation 3 in Watson’s treatise [10, p. 411]:

(18)

where

Relations (15)-(18) point to the existence of singular behavior of the 3B integral at specific values of its arguments. While (17) and (18) are formulas for the 3B integrals in the sense of Riemann integrals, (15) and (16) refer to them in the sense of distributions.

Approximation to the Triple-Bessel Integral

This integral occurs as part of a kernel in an integral over the mode numbers , over the interval , which itself is a term in a summation over azimuthal mode numbers , (integers) from to . Although the exact evaluation of this integral in the sense of a Riemann integral is probably not possible [9], the existence of the singular behavior noted above suggests that its behavior in the neighborhood of singularities provides the dominant contribution. In view of known difficulties in the analytical approach [10] and the availability of the sophisticated numerical integrator in Mathematica 8.0.4, a semi-empirical approach [11] is chosen. The upper limit of integration is taken as a large but finite number , so that the required integral can be treated as the limit of a sequence for increasing .

For large values of argument, the Bessel function can be approximated as [10]:

(19)

The scaling property of the 3B integral discussed above suggests that the radial mode numbers can always be scaled so that approximation (19) becomes a good approximation in most of the infinite domain of integration (except perhaps in a small region around ). This yields

(20)

Each integral on the right-hand side of (21) is of the form

(21)

For ,

(22)

For ,

(23)

The functions and are the Fresnel cosine and sine integrals. Applying (24) to (21),

(24)

This can be simplified as follows: When is an odd integer, the cosine term in the ratio

is zero, so that the ratio is . Similarly, if this number is an even integer or zero, the sine term is zero, so that the ratio must be . Hence this ratio can be represented as . Applying this logic to (25),

(25)

Equation (25) has the advantage that both its sides can be independently computed, and their numerical equivalence and computational time can be compared, particularly at the singular points. Each term in (25) has a factor of the form

(26)

The functions , which are mirror images of each other, are plotted in Figure 1 and some numerical values are shown in Table 1.

Figure 1. Plot of functions .

Table 1. Numerical values of functions .

For a large but finite number , only one term out of four in (25) dominates when , and then the integral has the value

(27)

(28)

The full width at half maximum (FWHM) of the peaks of as a function of any one of the radial mode number arguments is seen to be , irrespective of other arguments. The semi-empirical relations (27) and (28), based on a large but finite upper limit of integration, are numerically validated in the next section, showing that (20) is a reasonably good approximation near the upper and lower singularities at and .

When and are equal, the last two terms in (25) become comparable, and (28) breaks down. However, the question of how close and can be before (28) breaks down can form the basis of a numerical experiment. Set , where is a sufficiently large positive number. Then (28) takes the form

(29)

The ratio of the numerically evaluated LHS and RHS for randomly selected parameters can be plotted against by varying over many decades. This is considered in the next section. The value of above which the formula breaks down is seen to be of the order of , irrespective of the upper limit of integration, which is varied over five decades. The numerical experiments show that (28) remains valid for increasingly close values of and as the limit of integration is increased.

The limit requires some care. It is seen from (27) and (28) that the maximum of at shifts to and tends to infinity. At the same time, the FWHM of the peak tends to zero. The weighted area of the peak at for a smooth weight function is defined in terms of an arbitrarily small positive number and a function where as

(30)

For smooth weight functions, in the limit as , and the integral on the RHS of (29) can be written as

(31)

Observing that the integral does not converge, choose , in order to ensure convergence in the infinite limit of . The integral on the RHS of (30) is then evaluated with infinite limits

(32)

The weighted area under the peak is therefore given by the limit of (31)

(33)

Similar logic can be applied to (28) when is treated as a fixed nonzero number

(34)

The region away from singularities does not need a finite upper limit of integration. For this case, a better approximation for the 3B integral can be constructed by applying (19) to only two out of three Bessel functions:

(35)

This can be computed by recognizing that (for positive )

(36)

(37)

The Heaviside -function in (36) and (37) excludes the singular points. Some general features of this approximate expression require attention. For all pairs of primed azimuthal mode numbers whose sum is even (or odd), the expression is unchanged. For , the third term in (35) varies as , and the fourth term is zero. For , the expression oscillates rapidly as and at the same time falls off in magnitude as . For , the last terms of (36) and (37) provide a sharp fall. Significant magnitude of the expression is thus expected only in the region satisfying the triangle inequality: as in the analytical results (17) and (18).

A computational survey of the behavior of the above approximation to the 3B integral can be graphically presented in terms of scaled parameters , , making use of the scaling relation mentioned above:

This may be conveniently displayed in terms of the scaled :

This parameter is negative below the lower singularity and greater than 1 above the upper singularity.

This is considered in the next section.

Numerical Exploration of the Triple-Bessel Integral

Numerical exploration of the triple-Bessel integral, treated as a function of for given values of , , uses Mathematica 8.0.4, which implements sophisticated algorithms for numerical integration of highly oscillating functions with user-defined precision. Since the integral is expected to diverge at , the upper limit of numerical integration is kept at a high but finite number, which is also a parameter varied in the study.

Although the NIntegrate function in Mathematica is well tested, it is nevertheless prudent to benchmark it against the known result (18) in order to confirm that its options and parameters are correctly chosen for the intended application. The result of benchmark calculations is displayed in Figure 2, which summarizes the results of thousands of calculations with randomly generated arguments satisfying the triangle inequality and located near the lower singularity, upper singularity, or between the singularities. It is seen that there is quite good, but not perfect, agreement between the numerically calculated result and the formula for the following options: , , , and , which were chosen after a few trials.

Outside the triangle inequality region, NIntegrate gives very small values, consistent with the zero value from the analytical formula.

The upper limit of integration used in these calculations is symbolic Infinity, which is interpreted by NIntegrate as a large number that delivers the requested performance. The upper limit thus may not be the same in all calculations of the triple-Bessel integral. Using arbitrary fixed large numbers for the upper limit, however, gives absurd results.

Figure 2. Result of 3600 calculations of with randomly chosen and in various decade ranges and randomly chosen to lie in the region between and .

Figures 3 and 4 show the detail of the variation (magnified times) of the triple-Bessel integral, treated as a function of for , , , , in the neighborhood of and , with integration limit . The relevant Mathematica code is shown in Appendix 2. Figure 3 took over six hours to generate on a Core-2 Duo, 2 GHz, 4 GB ram machine. The resemblance of the shape of the plot to the functions is evident. Note the glitches at values of away from the singularity, showing that the numerical integrator does not work well for some values of the parameters. Since , the sign of the singularity in Figure 4 (time of computation: nearly nine hours) is negative for the given values of azimuthal mode numbers, as predicted by (29).

Figure 3. magnification detail in the neighborhood of : , , , , . Time required: about 22000 seconds.

Figure 4. magnification detail in the neighborhood of : , , , , . Time required: about 31000 seconds.

A randomized parameter space survey of (27) was carried out using the following protocol: 200 values of and were chosen randomly in each of four decades from to , was chosen randomly in the range to , and integers , , were chosen randomly in the range 0 to 100. For each set of parameters, the result of numerical integration over the limit , in the range of 9-12, divided by the value calculated using (27), was plotted against the latter. The result is summarized in Figure 5. A similar exercise for equation (28) is summarized in Figure 6. The code used is described in Appendix 3. It is seen that a higher integration limit gives less deviation from the formula.

Figure 5. Randomized parameter space survey of formula (27).

Figure 6. Randomized parameter space survey of formula (28).

As discussed in the previous section, (28) is expected to break down when and are sufficiently close, since the assumption concerning domination of only one term of (25) fails. This phenomenon is explored in the following test. (See Appendix 4).

The closeness of and is quantified in terms of a multiple of the parameter , which scans the width of the peak by setting . For a set of randomly selected parameters , , , , and , the ratio of values obtained from numerical integration and (28) is plotted against , which varies over 11 decades from to . This plot is generated for five values of upper integration limit , , , , and for the same set of randomly selected parameters, This is repeated for many randomly selected sets of , , in the range 0 to 100, 50 random values of in each of four decades from to , and in the range to The result is shown in Figure 7. The formula is seen to hold good when is above , irrespective of the limit of integration.

Figure 7. Randomized parameter space survey of formula (28) with .

The same dataset is displayed as a function of in Figure 8 for different values of the upper limit of integration.

Figure 8. Randomized parameter space survey of formula (28) with . The agreement between numerical integration and formula becomes better at closer values of as the limit of integration is increased.

Formula (28) is seen to be valid for increasingly smaller values of difference in and as the limit of integration is increased: less than a few parts per million when the integration limit is . For infinite limit of integration, the formula should therefore hold for arbitrarily close and .

The significance of numerical validation of (27) and (28) demonstrated above is that the dependence of the polarity of the peak on the three azimuthal mode numbers is correctly reproduced without a single error in several thousand calculations (where and differ more than a few parts per million), in addition to a reasonable agreement with peak amplitude and shape, for a large number of randomly selected parameters.

A similar exercise for the better approximation for regions away from singularities, formula (35), gives a very different picture: the formula overestimates the numerically calculated integral by several orders of magnitude. In order to understand this, a randomized survey of the approximation (35) and the numerical integration with upper limits , , was carried out and is summarized below. The program used in this survey is given in Appendix 5. The parameters used in the survey were: , , , . NIntegrate did not report any errors. Consistency of the trend in the survey suggests that the 3B integral tends to zero for the infinite upper limit of integration when : a (tentative) conclusion, which is predicated on the assumption that NIntegrate works correctly in these kinds of calculations. That can, in principle, be further examined by repeating this test for a much larger number of calculations and many different sets of options.

Using symbolic Infinity for the upper limit in these calculations is found to give absurd results. There is thus a distinct possibility that NIntegrate sometimes behaves in an anomalous manner while calculating the triple-Bessel integral.

Figure 9. Randomized survey of as functions of scaled , which are for various upper limits compared with (35).

The reasonable degree of agreement between the results of three theoretical formulas ((18), (27), and (28)) and numerical integration (with symbolic Infinity as the upper limit for (18) and a large number as the upper limit in (27) and (28)), with randomly selected parameters, tends to establish the credibility of numerical integration. At the same time, the fact that absurd results are produced by using a large number as the upper limit in the test for (18) and symbolic Infinity as the upper limit in the above test suggests that there is scope for improvement in the implementation of NIntegrate.

Proposed Approximate Formula for the Triple-Bessel Integral

The above discussion and numerical experimentation lead to the following observations, subject to the caveat concerning the correct behavior of NIntegrate:

1. tends to infinity as .
2. The FWHM of the peak of at tends to zero as .
3. The weighted integrals (32) and (33) over this peak converge to finite values for smooth weight functions.
4. Both outside and within the triangle inequality region , is negligibly small.

These observations suggest the following approximate semi-empirical representation of the 3B integral in the sense of distribution with respect to for smooth weight functions:

(38)

Here, for , and for . Note the inclusion of the case : this is proposed as the generalization of the results displayed in Figure 8 to the infinite integration limit. Putting , , in (38) recovers the usual orthogonality formula (12) for Bessel functions, supporting the discussion concerning equation (33) and also the inclusion of the case.

Its only claim to merit is that it is a less restrictive approximation than the total neglect of irrotational and scalar fields in spatial-spectral treatments of nonlinear dynamics of continuous media. Adoption of (38) as a kind of tentative semi-empirical model for the triple-Bessel integral, at least until a better replacement becomes available, would enable construction of a theoretical framework for studying effects arising out of the nonlinear interaction of solenoidal and irrotational electron modes in the two-fluid plasma model in cylindrical geometry [6], which is currently an intractable problem. This framework can be improved if and when further research, hopefully motivated by this discussion, leads to a better representation of (38).

Discussion

The insight gained above about the properties and numerical behavior of the 3B integral has significant implications concerning the usefulness of the Fourier space representation of nonlinear dynamics of continuous media in cylindrical geometry. The question, how far is infinity?, in the context of a physical theory, is seen to have an answer in terms of the error with which a physical quantity, such as radial mode number, might be defined using an experimental procedure. Two radial mode numbers may then be considered equivalent if their difference lies within the error band. The reciprocal of this error band would then represent the order of magnitude of the limit of integration in coordinate space, which reproduces, within experimental errors, the result that nonlinear interaction of these modes generates a near-zero radial-mode-number mode.

The origin of the singularities in this integral, treated as a function of three radial and three azimuthal mode numbers, can be seen from (20) to lie in resonant interaction between three waves of radial mode numbers , , , having phases governed by the azimuthal mode numbers , , , when any radial mode number equals the sum or difference of the other two radial mode numbers.

The triple-Bessel integral occurs in expressions that describe how the rate of change of the spectrum of a given quantity (the evolving mode), labeled by mode numbers without primes, depends on the interaction between the spectra of two other quantities, labeled by primed mode numbers (the interacting modes) and is accompanied by the factor . The semi-empirical model (38) then takes on a much simpler form, expressed below as a distribution with respect to using the invariance with respect to a permutation of pairs of arguments , , :

(39)

According to the model formula (40), the contribution of the 3B integral to the evolution of the spectrum is governed by two singularities. One evolves the spectrum toward higher radial mode numbers than the radial mode numbers of interacting quantities, generating smaller radial scale lengths and steeper gradients as in shock formation or turbulence. The other evolves the spectrum toward radial scale lengths larger than the radial scale lengths of the interacting modes, indicating the formation of a larger structure, as in self-organization. The tendencies toward turbulence/shock formation or self-organization are influenced by azimuthal mode numbers.

The computational advantage of the semi-empirical model of the 3B integral presented above can be judged by comparison with the approach of Chen, Shan, and Montgomery (CSM) [4, 5]. The first advantage over the method of CSM is that the spatial-spectral representation of irrotational vector fields as well as scalar fields becomes possible in addition to solenoidal fields: while the CSM method is limited to solenoidal fields only, over the infinite domain, an orthogonal basis becomes simultaneously available for scalar, irrotational, and solenoidal fields, facilitating the investigation of effects due to their nonlinear interaction [6]. The second advantage is that rather than computing a table of numerical values of coupling coefficients for an infinity (or a suitably large number) of azimuthal mode numbers, the dependence on azimuthal mode numbers is reduced to a simple computation of sign of a term. The semi-empirical formula (40) takes on the role of the table of coupling coefficients in the Galerkin approach of CSM [4, 5].

The spatial-spectral representation of the equation of continuity then becomes

(40)

The third advantage is the significant reduction in the computational complexity of equation (7) noticed in its reduced form (40): reduction in the number of integrations, simpler dependence on azimuthal mode numbers, and simpler form of the coupling factors. This opens up the possibility of doing computations similar to those of CSM without the restriction to incompressible flow and with a much larger number of modes.

Summary and Conclusion

This article concerns the integral of the product of three Bessel functions of the first kind of integer orders over the semi-infinite domain , which is encountered when transforming a system of nonlinear partial differential equations containing solenoidal vector fields, scalar fields, and irrotational vector fields, using Chandrasekhar-Kendall functions, their generating function, and its gradient as orthogonal bases over the semi-infinite domain. Known properties of this integral, which show singular behavior, are summarized. Using the approximation of Bessel functions for large arguments, it is shown that the triple-Bessel integral represents resonant three-wave interaction that leads to singularities when one argument equals the sum or difference of the other two arguments. Numerical investigations using Mathematica have been used to validate a scaling formula for the polarity, absolute magnitude, and shape of the singular peak with a large finite upper limit of integration. A semi-empirical approximate formula of the integral has been suggested in terms of the Dirac delta function for regions near the singularities for smooth weight functions. It is shown that the computational complexity of a cylindrical Fourier-space representation of the equation of continuity is reduced considerably using this formulation. This opens up the possibility of computational efforts similar to those of CSM without restriction to incompressible dynamics for a much larger number of modes.

Appendix 1

This generates Figure 2.

Appendix 2

This generates Figures 3 and 4.

Appendix 3

This generates Figure 5.

This generates Figure 6.

Appendix 4

This generates Figures 7 and 8.

Appendix 5

This generates Figure 9.

Appendix 6

The following outlines an argument in support of the assumption that the 3B integral is zero outside the triangle inequality region. Using the integral representation of the Bessel function

the 3B integral can be written as

The integral would be zero if has no zeros. This would correspond to the region outside the triangle inequality.

Acknowledgments

This article owes its origin to the following insightful question from an anonymous referee of Physics of Plasmas: “How far is infinity?” The help given by William Rummler of Wolfram Technical Support is gratefully acknowledged.

References

About the Author

The author holds the designation Outstanding Scientist in the Physics Group at Bhabha Atomic Research Centre, Mumbai, India and is a professor at the Homi Bhabha National Institute, Mumbai, a deemed university. He is the representative of India on the International Scientific Committee for Dense Magnetised Plasmas (ISC-DMP), which oversees the scientific programs of the International Center for Dense Magnetised Plasmas established at Warsaw under an agreement between UNESCO and the Polish National Atomic Energy Agency in 1999.

S. K. H. Auluck
Physics Group
Bhabha Atomic Research Centre
Mumbai 400085, India
skhauluck@gmail.com
skauluck@barc.gov.in

Rhombic Triacontahedra (RT) and Rhombic Hexecontahedron (RH)

Here are the RT and RH.

To find the possible candidate polyhedra, let us summarize the angles of face centers relative to the center of a single face of RT, as seen from the origin.

The dimensions applicable in the clusters can be determined on the basis of the relationship of the cube and RT. For instance, the cube edge is equal to the longer diagonal of the face of the RT (a golden rhombus), . The diagonal of the cube equals the distance between opposite threefold vertices of the RT.

Additional information for finding possible candidate polyhedra comes from a chart of truncations prepared by Szaniszló Bérczi. Figure 1 shows regular (Platonic) solids projected on a sphere. Archimedean solids are deduced from the regular solids by the truncation operation. A Platonic or Archimedean solid can be identified by its vertex configuration, because it is uniform; this is given by the Steiner symbol, which lists the faces that meet at a vertex. For example, is the Steiner symbol for the cube, because three squares (4-sided faces) meet at each vertex. The RT-related structures should be arranged according to the third row of the table: , , , , , .

Figure 1. The periodic table of Platonic and Archimedean solids and tessellations supplemented by the sequence of one of the infinite numbers of two-dimensional hyperbolic tessellations. In order to emerge, the regular solids are given in their projected-onto-sphere form.

For more help, we can consider the relationship of RT to cube and to RH, on the basis of which all necessary dimensions can be calculated.

This is the length of the cube edge.

This is the length of the cube diagonal, which is equal to the length of the threefold axis diagonal of the RT.

This is the face distance of the RT.

This is the length of the fivefold axis diagonal of the RT.

The relationship of the RT, cube, and a golden rectangle can be used to determine dimensions.

The relationship of the RT, RH, and a plane perpendicular to the threefold axis that cuts the RT and RH in half can be used to determine the angles between the RT faces.

Here are the definitions used in the constructions.

Icosahedron (ICO)

The icosahedron (ICO) is one of the five Platonic solids.

Twelve RTs placed at the vertices of the icosahedron enclose an RH. Such RT clusters appear in photos of certain quasicrystals.

Here is a cluster of 12 RHs without transparency.

When dodecahedra are used instead of RTs, they are attached to each other along their edges.

Truncated Icosahedron (TICO) (5, 6, 6)

The truncated icosahedron (TICO) is the shape most widely used for a soccer ball. It is also the overall structure of the C60 molecule, Buckminsterfullerene.

Here ICOs replace RTs; the ICOs meet along their edges.

Icosidodecahedron (ID) (3, 5, 3, 5)

The icosidodecahedron (ID) can be constructed as a truncation of either an icosahedron or a dodecahedron.

Here is the corresponding cluster.

Let us add 12 RTs at the vertices of the ICO.

Now add 12 RHs at the vertices of the DOD.

Add some more RTs at the vertices of an ID. This construction can be continued by adding more RTs and RHs.

Truncated Dodecahedron (TD) (3, 10, 10)

This is a special case of dodecahedron truncation, when the edge length is uniform.

This cluster of 60 RTs can be interpreted as being assembled from 20 sets of three RTs.

Dodecahedron (DOD) (5, 5, 5)

The usual pentagonal dodecahedron is one of the five Platonic solids.

Here is its associated cluster.

This investigates how the basic polyhedron relates to its associated cluster.

The cluster of 20 RTs can be fitted with 12 RHs placed at the vertices of an ICO.

Great Rhombicosidodecahedron (GRID) (4, 6, 10)

This is a beautiful shape. Somewhat similar shapes can be seen in some photographs of quasicrystals.

Here is its associated cluster.

Small Rhombicosidodecahedron (SRID) (3, 4, 5, 4)

An SRID has 60 vertices. In the related cluster, each RT is connected to four adjacent RTs, as opposed to the TICO-based cluster, where each RT is connected to only three adjacent RTs.

Here is its associated cluster.

This cluster can also be extended by adding RHs, for example at the vertices of an ICO.

Summary of Truncations and Their Clusters

Here is a summary of the clusters that correspond to the various truncations.

Cube (4, 4, 4)

The cube is one of the five Platonic solids.

Here is its associated cluster.

Two Johnson Solids

A number of Johnson solids can be considered as parts of the above polyhedra. The two shown here could be used as structures.

Here are their clusters.

Connections with Vertices

Interesting clusters can also be produced when the RTs meet at their vertices. For instance, RTs at RT vertices meet with their fivefold tips.

RTs at the vertices of a rhombic dodecahedron (RD) meet with their threefold tips. Adjacent pairs of RTs overlap in a flat golden rhombohedron, creating another closed structure.

References

S. Kabai, Sz. Bérczi, and L. Szilassi, “Some Clusters Produced by Placing Rhombic Triacontahedra at the Vertices of Polyhedra,” The Mathematica Journal, 2012. dx.doi.org/doi:10.3888/tmj.14-14.

Image Reference:

About the Authors

Sándor Kabai is a retired engineer who received his B.Sc. in manufacturing technology from Bánki College in Hungary in 1970. He has written many Demonstrations for the Wolfram Demonstrations Project; see demonstrations. He consults in space research-related education in Hungary.

Szaniszló Bérczi received his M.Sc. in physics and astronomy at Eötvös Loránd University in 1974 and his Ph.D. in geology (planetary science) at the Hungarian Academy of Science in 1994. He has achievements in several fields of science. He made a new synthesis of the evolution of matter according to the material hierarchy versus great structure building periods. This model is a part of his Lecture Note Series at Eötvös Loránd University. He also organized a research group on the evolution of matter within the Geonomy Scientific Committee of the Hungarian Academy of Science (with Béla Lukács). He wrote the first book in Hungary about planetary science, From Crystals to Planetary Bodies (in Hungarian). At Eötvös Loránd University, he initiated and built (with colleagues) the Hungarian University Surveyor (Hunveyor) experimental space probe model and the Husar rover (Hungarian University Surface Analysis Rover) for training teachers, and developed new technologies for measurement. He wrote the first lecture note book in Hungarian on symmetry and structure building, which uses symmetry principles in forming cellular automata models. He organized the loan of NASA lunar samples from Houston JSC and NIPR Antarctic meteorites from the Tokyo Antarctic Meteorite Center to Eötvös Loránd University, and initiated planetary materials studies and comparisons on industrial materials and technologies. His booklet series on ancient Eurasian art surveys both figurative and ornamental arts of great Eurasian regions. His studies on ethnomathematics cover ancient Eurasian cultures.

Lajos Szilassi received an M.Sc. in constructive geometry from the University of Szeged, Hungary in 1966, and a Ph.D. in 2006. He is now an emeritus professor at the University of Szeged. His main teaching areas include geometry, elementary mathematics, and computer applications. His research fields are in computer-aided solutions of mathematical and geometrical problems, with visualization of the solutions. In 1977 he found a way to construct a toroidal heptahedron, which is known now as the Szilassi polyhedron.

Sándor Kabai
1203 Budapest
Határ 9
Hungary
www.kabai.hu
unico@t-online.hu

Szaniszló Bérczi
Eötvös Loránd University, Faculty of Science
Institute of Physics, Dept. Materials Physics
Pázmány Péter sétány 1/a. H-1117
Budapest, Hungary
bercziszani@ludens.elte.hu

Lajos Szilassi
szilassi@jgytf.u-szeged.hu

Because the spacecraft is near the Moon, we assume that the lunar acceleration of gravity has the constant value , that the relative velocity of the exhaust gases with respect to the spacecraft is constant, and that the mass rate is constrained by , where is constant and gives the maximum rate of change of the mass due to burning the fuel.

Mathematical Approach to a Soft Landing

The problem is to make a soft landing on the surface of the Moon with the minimum amount of fuel.

Here is a sketch of the system immediately preceding the landing.

Following [1, pp. 247-248] and [2], we introduce the following notation and assumptions:

• is time
• is the mass of the spacecraft, which varies as fuel is burned
• is the rate of change of mass, constrained by
• , the gravitational constant near the Moon
• is a constant, the relative velocity of the exhaust gases with respect to the spacecraft
• , the thrust
• is the the height, with
• , the velocity
• , the control function

Recalling our assumptions, aerodynamic forces and gravitational forces of bodies other than the Moon are negligible and lateral motion is ignored. Thus the descent trajectory is vertical and the thrust vector is perpendicular to the ground.

We also suppose that , where is the mass of the spacecraft without fuel and is the initial mass of fuel; , since as we expect that the spacecraft will return to Earth, it needs some fuel for takeoff.

Equations of Motion

By Newton’s second law ([3, p. 128] and [2]),

(1)

which can be written as a system of equations

(2)

(3)

(4)

where is a constant. The third equation states that the loss of mass per second (the fuel burned by the jet per second) is proportional to the thrust of the jet.

The Optimal Control Problem

Our goal is to minimize the fuel consumption, so the cost functional is

(5)

where is the first time for which

Thus the horizon is , where remains to be determined.

In vector form, if , then

and the problem can be written

(6)

and finally,

(7)

From (3) we have that

and by integration over the interval , we get that

It follows that if and only if

Solving for ,

Now we substitute this into (5) to get

This result was published in [2].

Theorem 1

Consider equation (5) with conditions (6) and (7). Then for some given , , , and , the amount of fuel required to stop the spacecraft, that is, to force , is a strictly increasing monotonic function of the terminal time .

Corollary 1

Minimizing the terminal time for equation (5) with (6) and (7) is equivalent to minimizing the fuel consumption.

From here it follows that instead of (7) we can consider the following cost functional

(8)

and thus equation (6) with (7) becomes (6) with (8). This is a Mayer optimal control problem (see Chapter 4 of [4]).

Necessary Conditions for the Mayer Problem

To avoid a lengthy discussion, we state a short version of theorem 4.2.i in [4]. Let the Mayer problem be expressed as

(9)

(10)

A pair , , is said to be admissible or feasible provided is absolutely continuous [5], is measurable, and and satisfy (10). Let be the class of admissible pairs . The goal is to find the minimum of the cost functional over , that is, to find an element such that for all . We introduce the variables , called multipliers, and an auxiliary function , called the Hamiltonian, defined on by

We define

More assumptions are necessary:

1. There exists an element such that for all .
2. is closed in .
3. The set , is closed in .
4. .
5. Notation:
, , , , .
6. The graph of the optimal trajectory belongs to the interior of .
7. does not depend on time and is a closed set.
8. The end point of the optimal trajectory is a point of , where possesses a tangent variety (of some dimension , ), whose vectors are denoted by

or by

Theorem 2

Assume these eight hypotheses and let be an optimal pair of the Mayer problem (9) and (10). Then the optimal pair necessarily has the following properties:

(a) There is an absolutely continuous function such that

If is not identically zero at , then is never zero in .

(b) For almost any fixed (a.e.), the Hamiltonian (as a function depending only on ) takes its minimum value in at the optimal strategy , that is, (a.e.).

(c) The function coincides a.e. in with an absolutely continuous function and

The Hamiltonian and the equations for the multipliers to (6) and (7) are

so that , , , where and are constants.

For , the minimum of is attained with , and then

This corresponds to free fall for the spacecraft.

For , the minimum of is attained with , and then

Thus we find that the control function takes only extreme values and .

If on an interval we have that , and hence

then for , we have

In this case, describes an arc of a parabola of equation

with

If on an interval we have , and hence

then for , we find

Theorem 3

If all the assumptions in the section Mathematical Approach to a Soft Landing are satisfied, is the time of ignition of the engine, is the time of landing, that is , and if the system of equations

for and is solvable, then there exists an optimal pair that solves the optimal control problem given by (6) and (8).

Program for Soft Landing on the Moon

MoonLanding is a Mathematica program for a soft landing on the Moon. Here h0 is the initial height, v0 is the initial velocity, mass is the mass of the lander without fuel, fuel is the initial fuel, g is acceleration due to gravity, k is the relative velocity of the exhaust gases, and is the rate of change of the mass by burning.

The correctness of the results drastically depends on the initial values of the variables z and g that we use in solving the nonlinear system of equations in the program.

This Manipulate lets you vary the parameters in real time.

Acknowledgments

The author expresses his gratitude to Horia F. Pop from Babes-Bolyai University, Faculty of Mathematics and Computer Science in Cluj-Napoca, Romania, for valuable discussions.

References

[1]	D. E. Kirk, Optimal Control Theory, Englewood Cliffs, NJ: Prentice-Hall, Inc., 1970.
[2]	J. Meditch, “On the Problem of Optimal Thrust Programming for a Lunar Soft Landing,” IEEE Transactions on Automatic Control, 9(4), 1964 pp. 477-484. doi:10.1109/TAC.1964.1105758.
[3]	G. Leitmann (ed.), Optimization Techniques: With Applications to Aerospace Systems, Mathematics in Science and Engineering, Vol. 5, New York: Academic Press, 1962.
[4]	L. Cesari, Optimization—Theory and Applications, Problems with Ordinary Differential Equations, Applications of Mathematics, Vol. 17, New York: Springer, 1983.
[5]	M. Mureşan, A Concrete Approach to Classical Analysis, New York: Springer, 2009.
Marian Mureşan, “Soft Landing on the Moon with Mathematica,” The Mathematica Journal, 2012. dx.doi.org/doi:10.3888/tmj.14-13.

About the Author

Marian Mureşan is affiliated with Babes-Bolyai University, Faculty of Mathematics and Computer Science, in Cluj-Napoca, Romania. He is interested in analysis, nonsmooth analysis, calculus of variations, and optimal control.

Marian Mureşan
Babes-Bolyai University
Faculty of Mathematics and Computer Science
1, M. Kogalniceanu str., 400084, Cluj-Napoca
Romania
mmarianus24@yahoo.com
mmarian@math.ubbcluj.ro

Introduction

The quantitative description of turbulent flows is known to be severely hampered by the extremely rapid variations in the mean and higher-order statistics in the near-wall region. Some very early studies [1, 2, 3] showed that the basic structure of an attached turbulent boundary layer consists of a viscous wall layer, in which the turbulent and laminar stresses are of comparable magnitude, and a defect layer, in which the velocity profile may be expressed in terms of a small perturbation to the external flow solution [4]. Also, [1, 2, 3] showed that this structure naturally leads to a universal velocity solution that has logarithmic behavior and depends on the velocity and length scales based on the friction velocity.

For separated flows, this picture changes dramatically; the friction velocity reduces to zero, so that a new scaling procedure based on the local pressure gradient at the wall needs to be introduced. The logarithmic solution is then reduced to a square-root velocity profile. Aspects of the complex flow structure due to separation are thoroughly discussed in [4].

To incorporate the structure of organized motion into a near-wall analytical model, Walker et al. [5] proposed a time-dependent formulation based on the dynamical features of the wall layer. Following the general description commonly found in the literature, the flow dynamics are considered to be dominated by two features: wall layer streaks and the bursting phenomenon. The streaks are elongated in the flow direction, with length of the order of (where , is the kinematic viscosity, and is the friction velocity), and can be observed over a large characteristic time, the quiescent period [6].

Analytical near-wall solutions for turbulent flows are of central significance, since the extreme thinness of the viscous sublayer naturally demands the use of exceptionally fine meshes in the numerical computation of problems of practical relevance. This difficulty can be naturally overcome, provided the local analytical solutions are used to bridge the viscous-dominated region.

In [5], the duration of the quiescent period is assumed to be much larger than the duration of the bursting process, so that solutions for the unsteady Navier-Stokes equations can be given in terms of the flow development between pairs of streaks. The analysis resorts to standard methods for orthogonal functions to arrive at a set of three nonlinear governing equations that have to be solved numerically. In addition, a semi-similarity procedure is proposed, resulting in a solution that includes . This function is a similarity solution of the linear diffusion equation that behaves logarithmically for large and vanishes at . Mean velocity profiles are obtained by evaluating a time-average of the solution over the period between bursts, .

In mathematics is generally used to denote a variant of the Riemann zeta function. Here, no confusion should arise: the function , as defined in [5], is given by the equation e1 below.

Instantaneous and averaged velocity profiles are presented for four combinations of (the dimensionless pressure gradient parameter) and in accordance with typically measured values. For constant pressure flow (, ), the canonical boundary layer structure is well reproduced. Under a favorable pressure gradient (, ), the instantaneous profiles are accelerated as expected. For adverse pressure gradients (, ; , ), decreases and, for the latter case, reverse instantaneous flow is observed over the latter part of the cycle.

Here, we develop a new version of the near-wall turbulent velocity profile shown in [5], in particular, of the function. This article introduces the required features of function and its derivatives. In addition, we present some original identities for the hypergeometric functions and .

Identity Involving and

The function is of particular relevance, being the only known similarity solution of the linear diffusion equation that behaves logarithmically for large and vanishes at [5].

The function can be defined either in terms of an expansion or an integral, as shown in [5] (equations (44) and (42)). In the latter form, the triple integral can be rearranged to a single integral.

The coefficients are defined by a recurrence relation.

The sum in e1 is uniformly convergent for all . This is particularly useful in the evaluation of for small to moderate values of [5].

This solves the recurrence equation.

FullSimplify shows that the coefficients are the harmonic numbers.

After substituting equation e4 into equation e1, the sum turns out to be a hypergeometric function.

This is the second term of e5.

This is difficult to calculate for large numerical values of , because is extremely small, while the hypergeometric function is extremely large. To remove from , we use the following identity.

Take the derivative of e6 with respect to for and .

Use e7 to substitute into e5.

To verify that e8 is an identity, we evaluate its right-hand side for with 100 digits of precision.

For and , Mathematica 8 gives the following.

Mathematica 8 can evaluate e9 and e10 for numerical values of . The following rule generates derivatives of order n that earlier versions of Mathematica can evaluate.

For and , the function WalkerDerivative gives the following.

To verify that the right-hand sides of e9 and e11 are equal and that the right-hand sides of e10 and e12 are equal, we evaluate them for with 100 digits of precision.

Initial Value Problem

To derive the initial value problem for , we use e8 and its derivatives.

To obtain the desired initial value problem, we eliminate from e14 and e15 the hypergeometric function and replace by 0 in e13 and e14.

The resulting ordinary differential equation is equivalent to equations (40) and (41) in [5]. The condition is also given in [5]. However, the condition is missing in [5], where no attempt is made to obtain a numerical solution.

We plot the function (blue) and its derivative (purple).

Conclusion

Exact expressions for the Walker function and its derivatives are obtained. From a computational point of view, an important result is the specification of the initial value problem, for it allows extremely fast interpolating functions to be generated. From a mathematical point of view, some new identities between the two hypergeometric functions and are presented. These identities were revealed by the built-in Mathematica functions RSolve, Sum, and FullSimplify. Of possible interest is the application of the techniques to discover new identities and to the problems described in the book by Petkovšek et al. [7].

Acknowledgments

The first author is thankful to the Brazilian National Research Council (CNPq) and the Brazilian National Institute of Standards (INMETRO) for their financial support of this research through a CNPq Research Fellowship-Edital MCT/CNPq/Inmetro nº 059/2010-PROMETRO Processo Nº 563061/2010-3.

The second author is grateful to the Brazilian National Research Council (CNPq) for the award of a Research Fellowship (Grant No. 303982/2009-8). The work was financially supported by the Rio de Janeiro Research Foundation (FAPERJ) through Grant E-26/170.005/2008.

References

About the Authors

M. D. Mikhailov
INMETRO—Divisão de Metrologia em Dinâmica de Fluidos
Dimci/Dinam, Prédio 3, Av. Nossa Senhora das Graças 50
Duque de Caxias, 25250-020
Rio de Janeiro, Brasil
m.d.mikhailov@gmail.com

Atila P. Silva Freire
Mechanical Engineering Program (PEM/COPPE/UFRJ)
C.P. 68503, 21941-972
Rio de Janeiro, Brazil
atila@mecanica.coppe.ufrj.br

Pauli Algebra

An element of Pauli algebra consists of a complex scalar, say , and a three-dimensional complex vector , denoted , which thus has eight real dimensions. In effect, this is a generalization of quaternion algebra, but with complex instead of real components. In this article, we call these elements “spinors.”

A product of two spinors is a spinor defined by

(1)

where and are the dot and cross products, respectively. Note that this multiplication is associative, implying that we do not need parentheses when multiplying three or more spinors. But multiplication is not commutative (the result depends on the order of factors).

There are two important unary (single-argument) operations on spinors: the first is called a reflection (denoted ), which changes the sign of the vector part, that is, ; the second takes the complex conjugate of and of each component of ; it is denoted . Finally, just for convenience, we let denote the combination of both of these, that is, Note that

(2)

which are quite easy to verify.

The corresponding Mathematica routines look and work like this.

From now on we consider a three-dimensional vector to be a special case of a spinor, meaning that is shorthand for . We can easily compute various functions of spinors (and of three-dimensional vectors, as a special case). Thus, for example, assuming that is a three-dimensional vector with real components, we find

(3)

where is the length of and is a unit vector in the same direction.

Similarly, for a three-dimensional vector with pure imaginary components (which we express in the form to keep the elements of real), the same kind of expansion yields

(4)

again where is the length of and is a unit vector in the same direction.

This can be easily extended to a complex-vector argument, as follows.

Special Relativity

The basic idea of Einstein’s theory is to unite space and time into a single entity of spacetime, whose “points” (or events) can then be represented by real spinors of type . The separation between any two such events constitutes a so-called 4-vector that, when multiplied (in the spinor sense) by its own reflection, yields a pure scalar . It is now postulated that this quantity must be invariant (having the same value) in all inertial coordinate systems (i.e. those that differ from each other by a fixed rotation and/or a boost—a motion at constant velocity). For simplicity, our choice of units sets the speed of light (which must be the same in all inertial systems) equal to 1.

The question is: how do we transform 4-vectors from one inertial frame to another, while maintaining this invariance? The answer is provided by

(5)

where and represent a 4-vector in the old and new frame of reference, respectively, and is a spinor such that . It is obvious that remains real whenever is real, and that

(6)

where (the scalar invariant of ). This shows that has the same value in all inertial frames of reference. Requiring reflection to be a frame-independent operation (meaning that for every 4-vector) leads to

(7)

From this, we can see that transforms differently from , being an example of a four-dimensional covector (a -vector, in our notation). Another important example of a -vector is the operator, where stands for the usual three-dimensional (spatial) gradient (the collection of , , and partial derivatives).

One can show that if and only if , where is a “pure” vector (i.e. three dimensional, but potentially complex valued). This is a fully general but rather inconvenient form of ; fortunately, one can prove that any such can be expressed as a product of an ordinary three-dimensional rotation and a boost , where and are real-valued vectors. To see that results in an ordinary rotation of the vector part of (where the magnitude of specifies the angle and the direction of defines the axis of rotation), consider

(8)

where is the decomposition of into components parallel and perpendicular to , respectively. Note that commutes with (and any function thereof); consequently, it remains unchanged by this transformation. On the other hand, and anticommute (i.e. ), implying

(9)

and, consequently, the rest of (8). One can thus see that this transformation leaves the scalar part of a 4-vector intact, and rotates the vector part using and as the axis and angle of rotation (of the old frame, with respect to the new one), respectively.

Similarly, using , we get

(10)

Here, can be replaced by , where and represent the unit direction and the magnitude of a three-dimensional vector (a velocity of the old frame with respect to the new one), respectively. This leads to the following simplified (and physically more meaningful) result of such a boost, applied to :

(11)

Electromagnetic Fields

A 4-vector field of central significance is the electromagnetic potential , where and each component of are real-valued functions of a spacetime location (i.e. of , , , and ). Now comes an important point: within the current framework, it is physically meaningless to multiply two 4-vectors (we would not know how to transform such a product from one inertial frame to another), but it is possible to multiply a -vector by a 4-vector, creating what we call a mixed vector. It is thus quite legitimate to do

(12)

creating a mixed vector, which has its own new way of transforming (shown shortly).

To physically interpret the right-hand side of (12), we first impose the so-called Lorenz condition (often misattributed to the more famous Lorentz) of (we prove shortly that this condition is frame invariant), and identify with , where and are the resulting (real-valued) electric and magnetic fields, respectively.

One can now show rather easily that will simply rotate the two fields. On the other hand, a boost results in

(13)

since transforming a mixed vector is done by . In both cases (rotation and boost), the scalar part remains equal to zero, thus proving invariance of the Lorenz condition.

Unlike 4-vectors, mixed vectors can be multiplied, yielding a new mixed vector (in terms of its transformation properties). Thus, for example,

(14)

tells us that both and are invariant scalar fields.

Similarly, multiplying a 4-vector by a mixed vector returns a 4-vector; for example,

(15)

This time, the result must equal the charge/current density (yet another basic 4-vector of the theory); this results in a compact, Dirac-algebra formulation of the usual Maxwell equations. As an example, the following program computes the electromagnetic field of a point-like massive particle of a unit charge, moving at a uniform speed along the axis; it also verifies that the result satisfies Maxwell’s equations.

Dynamics of a Point-Like Charged Particle

We choose units in which both the rest mass and the charge of the particle equal 1. Its instantaneous location is denoted , where the three components of are functions of . To make the subsequent equations frame independent (having the same form in all inertial frames), we now need to introduce the particle’s so-called proper time by

(16)

We already know that transforms as a 4-vector; , thus and, consequently, are relativistically invariant (the dot over implies differentiation with respect to ). Proper time is then computed by the corresponding integral, namely

(17)

which, being a “sum” of invariant quantities, is an invariant scalar as well. This implies that

(18)

transforms as a 4-vector (we call it the 4-momentum of the moving particle).

The motion of the charged particle in a given electromagnetic field can now be established by solving

(19)

where the right-hand side is the so-called Lorentz force, and “” takes the real part of its argument (also a 4-vector). Note that “” applied to a 4-vector remains a 4-vector (since the complex conjugate of a 4-vector transforms as a 4-vector, as one can readily verify).

Based on (18), the right-hand side of (19) equals

(20)

For a particle with a negative unit charge, the sign of this 4-vector would be reversed.

One way of solving the resulting 4-vector equation is to expand the left-hand side of (19):

(21)

which has to equal (20). Canceling the scalar factor of , we get

(22)

Finally, the first (scalar part) of these four equations can be obtained by taking the dot product of the remaining three equations (the vector part) and , and is therefore redundant. All we need to solve in the end is

(23)

or, equivalently (by solving for ),

(24)

the correctness of which can be easily verified by substituting this into the left-hand side of (23) and obtaining the right-hand side. These equations can, in general, be solved only numerically. The resulting will be a three-component function of a frame-dependent time (proper time was used only as an intermediate tool to assure agreement between inertial frames of reference; our solution remains correct in any other such frame, after the corresponding transformation). The following program finds the motion of a negatively charged particle (chosen because an attractive force makes the resulting path somehow more interesting, compared to the same-charge repulsion) in the field of the previous section.

The originally stationary unit-mass particle has been “captured” by the moving massive particle (which is assumed to be so heavy that its own motion remains unaffected), and will continue orbiting it (while following its uniform motion). It is important to realize that this formulation of the problem has ignored the fact that a moving particle generates (and radiates) an electromagnetic field of its own, which would further modify its motion. More importantly, we also know that, at an atomic level, the world is governed by quantum mechanics, ultimately resulting in a totally different description of an orbiting particle. This is the reason why the last solution is only of mathematical interest. Under a wide range of initial conditions, the light particle would be drawn to collide with the heavy one.

Motion in a Constant Electromagnetic Field

Things become easier when and are both constant fields (in space and time). One can then express as , where is the initial value of the particle’s 4-momentum, and is a spinor analogous to that (instead of transforming 4-vectors between inertial frames) advances to its current location. This time we find it more convenient to make both and functions of proper time . Also, one must not forget to meet the condition, which is then automatically maintained by at all future times.

Expanding the right-hand side of (19) yields

(25)

This should equal the left-hand side of (19), namely

(26)

which implies that

(27)

having the obvious solution

(28)

a function of a mixed vector transforms as a mixed vector. After computing and, consequently, , all we need to do is to integrate this last expression in terms of to get a solution for . A simple example follows.

In this example, we have been able to obtain an explicit analytic solution.

In most textbooks (e.g., [1], [2]), the treatment we have described is done using conventional tensor analysis, with covariant and contravariant vectors. It is always illuminating, however, to obtain the same results using a completely different approach, such as the one favored by Hestenes [3]. We have shown that Mathematica is capable of handling computations in any of several formalisms.

References

About the Author

Jan Vrbik
Department of Mathematics, Brock University
500 Glenridge Ave., St. Catharines
Ontario, Canada, L2S 3A1
jvrbik@brocku.ca

Details of the Integral Evaluations

The integrals discussed here are related to averages over the spherical matrix elements [1, 2] defined by

(1)

which are symmetric-top eigenfunctions with eigenvalues and a degeneracy . The function is defined [1, 2] as

(2)

where the sum is over all integer values of from 0 to the first negative factorial that occurs in the denominator. In the impulse approximation for quasi-elastic electron scattering [3], averages over the rotational motion of a spherical top molecule such as methane are integrals of the following form:

(3)

where

(4)

is the Hamiltonian operator whose eigenfunctions are the Legendre polynomials with eigenvalues . Equation (4) is also a part of the Hamiltonian for which the are solutions, but the are not eigenfunctions of (). The occurrence of arises in the treatment of the scattering problem in the impulse approximation [3]. By use of Mathematica it was possible to prove that

(5)

where the normalization factor is given by

(6)

for all values of and . For integer the results are

(7)

where

(8)

The use of the word “prove” is based on the results from a Mathematica program. All of these expressions occur as ratios of positive integers and were found to be in exact agreement with the results on the right-hand sides in equation (7) for values of from 0 through 18.

Note that the same result can be obtained for the case where is replaced by if is replaced by

(9)

Except for the factor of for and for in the definitions of the , the remaining parts are equivalent to the integrals

(10)

and

(11)

Further investigation using found the same result with

(12)

where it is noted that

(13)

Define the double sum over the integral

(14)

and

(15)

These results suggest the conjecture that , where is a constant. For and , the constant factor was found to be for , as shown in the next section.

Implementation

The function d is .

The functions d1 and d2 are the first and second derivatives of with respect to .

The function h is the result of the Hamiltonian operating on d.

Define the integral a.

The function int1 is the integral in equation (14).

The function int2 is the normalization integral of the square of .

The function s is the sum of the ratios of the integrals int1 and int2 over and .

For various choices of , , and , the table compares the exact evaluation of (equation (14)) with the proposed result (equation (15)) and shows that the ratio of the two is a constant, which in this case is . The evaluation of takes some time.

References

[1]	D. M. Brink and G. R. Satchler, Angular Momentum, Oxford: Clarendon Press, 1979 pp. 21-25.
[2]	R. A. Bonham, G. Cooper, and A. P. Hitchcock, “Electron Compton-like Quasielastic Scattering from , , and ,” Journal of Chemical Physics, 130 144303, 2009. dx.doi.org/10.1063/1.3108490.
[3]	G. I. Watson, “Neutron Compton Scattering,” Journal of Physics: Condensed Matter, 8(33) 5955, 1996. iopscience.iop.org/0953-8984/8/33/005.
R. A. Bonham, “Some Integrals Involving Symmetric-Top Eigenfunctions,” The Mathematica Journal, 2012. dx.doi.org/doi:10.3888/tmj.14-12.

About the Author

Russell A. Bonham received his Ph.D. in physical chemistry from Iowa State University in 1957. He is the author of more than 200 articles on all aspects of electron scattering from free atoms and molecules. He is currently a professor emeritus at Indiana University and an adjunct professor at the Illinois Institute of Technology.

R. A. Bonham
Department of Biological, Chemical, and Physical Sciences
Illinois Institute of Technology
3101 South Dearborn Street
Chicago, IL 60616
bonham@iit.edu