Numerical vs Symbolic -- What to do when plots are blank (and other strange errors)

The plotting functions require numerical inputs. This sounds obvious but most people have trouble debugging plots that come out empty. When something does not plot, the first thing to do is to evaluate the expression and look for undefined variables or typos.

Consider the following:

A = 12;
b = 3;
expr = a* b sin[theta];
Plot[expr, {theta, 0, 10}]

which yields a less than informative plot:

The best approach is to take the plot argument and evaluate it at a point somewhere in the plot range and see that it is numerical. It is often a good idea to evaluate it at the two extremes and the middle to make sure it is numerical everywhere.

expr /. theta -> 0
expr /. theta -> 5
expr /. theta -> 10

to get

 (* 3 a sin[0] 
3 a sin[5] 
3 a sin[10] *)

It becomes clear that the a is undefined and that sin does not evaluate (because of the lower case 's')

Consider Reap/Sow Instead of AppendTo

When using the output of a program to build large lists, a combination of Reap and Sow is often cited as the most efficient (computationally speaking) approach. Put simply, AppendTo trades speed in favour of flexibility by creating a copy of the original list when called. Indeed, Reap/Sow is also point 7 of 10 Tips For Writing Fast Mathematica Code.

I remember first seeing Reap/Sow as a beginner and feeling like it was an 'advanced' feature for other users. Instead I fell into the pattern of defining an empty list and using AppendTo which in hindsight was a beginner's mistake I frequently made by the justification given above.

The example from the link above says it best:

In[7]:= data = {}; 
 Do[AppendTo[data, RandomReal[x]], {x, 0, 40000}]; // AbsoluteTiming

Out[7]= {11.6127, Null}

In[8]:= data = 
   Reap[Do[Sow[RandomReal[x]], {x, 0, 40000}]][[2]]; // AbsoluteTiming

Out[8]= {0.164533, Null}

This is one small change which will Reap large benefits for any beginner.

What does @#(%=<[!} et cetera mean?

Mathematica has a very extensive set of characters used as its syntax. I will try to list most (all?) of them here.

Non-standard characters

If the symbol appears to be a non-standard character one can wrap the symbol in quotes and perform FullForm on it to get the name of the symbol. Example:

gives:

"\[Function]"

Brackets

These syntax elements all appear in pairs:

• (...) Circumfix. Used to group expressions such that it has higher precedence, not used to enclose arguments of a function
• {...} List doc. Circumfix. Used to describe lists of any depth, e.g.: {a,b,...}. Known as arrays, vectors, matrices, tensors, in other languages
• [...] Circumfix. Used to enclose arguments of a function, e.g.: f[a]
• [[...]] Part doc. Post/circumfix. a[[b]] = Part[a,b]. Used to extract parts of an expression. Can also be typeset as a single character: \[LeftDoubleBracket] and \[RightDoubleBracket], and can also be typeset as a subscript
• <|...|> Association doc. Circumfix. Used to describe a list of key-value pairs. Known as associative arrays, dictionaries, hashmaps. Can also be typeset as a single character: \[LeftAssociation] and \[RightAssociation].
• (*...*) Circumfix. Used for making comments in code, can be anywhere in the code except inside strings, then it will be taken literal.
• <*...*> TemplateExpression doc. Circumfix. Expression inside a string template.
• \[LeftFloor]...\[RightFloor] Floor doc. Circumfix. Mathematical Floor function. \[LeftFloor]a\[RightFloor] = Floor[a]. Can be typeset using \[LeftFloor] and \[RightFloor].
• \[LeftCeiling]...\[RightCeiling] Ceiling doc. Circumfix. Mathematical Ceiling function. \[LeftCeiling]a\[RightCeiling] = Ceiling[a]. Can be typeset using \[LeftCeiling] and \[RightCeiling].
• =[...] FreeformEvaluate doc =[query] performs FreeformEvaluate[query]

Applying functions

• @ doc. Infix. Used to apply a function to a single argument: f@x = f[x] (related to Prefix doc)
• // doc. Infix. Used to apply a function to a single argument: x // f = f[x] (related to Postfix doc)
• ~ Infix. Works on two arguments: a ~ f ~ b = f[a,b] (related to Infix doc)
• @* Composition doc. Infix. f@*g = Composition[f,g] Used to compose two or more functions. @* is the infix operator form of Composition
• /* RightComposition doc. Infix. f/*g = RightComposition[f,g] Used to compose two or more functions. /* in the infix operator form of RightComposition
• /@ Map doc. Infix. f/@ a = Map[f,a] Used to apply a function to all elements of a
• //@ MapAll doc. Infix. f//@ a = MapAll[f,a] Used to apply a function to every subexpression of a
• @@ Apply doc. Infix. f @@ a = Apply[f,a] Used to replace the head of a by f
• @@@ Apply doc. Infix. f @@@ a = Apply[f,a,{1}] Used to replace the heads at level 1 of a by f.

Pure function, slots, and slot sequences

• & Function doc. Used to define a pure function where the arguments are given by #1 (short: #), #2, #3, et cetera. Also known as lambda function, anonymous functions, function literal, lambda abstraction...
• # Slot doc. represents the first argument supplied to a pure function
• #1, #2, #n Slot doc. represents the nth argument supplied to a pure function
• #0 Slot doc. represents the pure function itself.
• #name Slot doc. represents the value associated with the key name in an association in the first argument
• ## SlotSequence doc. represents a sequence of all the arguments
• ##n SlotSequence doc. represents a sequence of arguments starting from the nth
• \[Function] Function doc. Infix operator of Function. x \[Function] body = Function[x,body]
• |-> Function doc. Infix operator of Function with names variable. x |-> body = Function[x,body]

Assignments

• = Set doc. Infix. a=b = Set[a,b]
• := SetDelayed doc. Infix. a:=b = SetDelayed[a,b]
• =. Unset doc. Postfix. a=. = Unset[a]
• ^= UpSet doc. Infix. a[b]^=c = Upset[a[b],c]
• ^:= UpsetDelayed doc. Infix. a[b]^:=c = UpSetDelayed[a[b], c]
• /: = TagSet doc. Compound infix. a /: b[a] = c = TagSet[a, b[a], c]
• /: := TagSetDelayed doc. Compound infix. a /: b[a] := c = TagSetDelayed[a, b[a], c]
• /: =. TagUnset doc. Compound infix. a /: b[a] =. = TagUnset[a, b[a]]
• += AddTo doc. Infix. a+=b = AddTo[a, b] Adds b to a and stores the value in a.
• -= SubtractFrom doc. Infix. a-=b = SubtractFrom[a, b] Subtracts b from a and stores the value in a.
• *= TimesBy doc. Infix. a*=b = TimesBy[a, b] Multiplies a by b and stores the value in a.
• /= DivideBy doc. Infix. a/=b = DivideBy[a,b] Divides a by b and stores the value in a.
• //= ApplyTo doc. Infix. a//=f = ApplyTo[a,f]. Applies function f to a and stores the value in a.
• ++ used as a prefix operator is PreIncrement doc. ++a = PreIncrement[a] Adds 1 to a and stores the value in a, returns the new a
• ++ used as a postfix operator is Increment doc. a++ = Increment[a] Adds 1 to a and stores the value in a, returns the old a
• -- used as a prefix operator is PreDecrement doc. --a = PreDecrement[a] Subtracts 1 from a and stores the value in a, returns the new a
• -- used as a postfix operator is Decrement doc. a-- = Decrement[a] Subtracts 1 from a and stores the value in a, returns the old a

Number related

• *^ Infix. Equivalent to *10^ sometimes 'e' in other languages. 3*^4 = 30000
• ` related to Precision doc. Postfix. Define number to be a machine precision number. It denotes context when it is written between symbols. Also appears in pairs inside strings for TemplateSlot doc where they denote an argument
• `n related to Precision doc. Infix. Defines number to have precision n. It denotes context when it is written between symbols
• ``n related to Accuracy doc. Infix. Supposed to be written between 2 numbers. Defines number to have accuracy n
• ^^ related to BaseForm doc. Infix. 3^^1212 represents 1212 written in base 3. Up to base 36 can be specified in this notation (using letters a through z, in either lower of upper case, to denote 10 through 35). Use FromDigits doc for higher bases. Base conversion is done using IntegerDigits doc or RealDigits doc
• \[ImplicitPlus] ImplicitPlus doc. Infix. An invisible character used for e.g. fractions: 5\[ImplicitPlus](3/4) = Plus[5,3/4] = 23/4 where 3/4 is then typed as a fraction

Relational operators

• == Equal doc. Infix. a==b = Equal[a,b]. Used to test if a and b are equal. Also used to define an equation
• \[Equal] Equal doc. Infix. a==b = Equal[a,b]. Used to test if a and b are equal
• != UnEqual doc. Infix a!=b = UnEqual[a,b]. Used to test if a and b are not equal
• ? UnEqual doc. Infix a!=b = UnEqual[a,b]. Used to test if a and b are not equal
• > Greater doc. Infix. a>b = Greater[a,b]. Used to test if a is greater than b
• < Less doc. Infix. a<b = Less[a,b]. Used to test if a is less than b
• >= GreaterEqual doc. Infix. a>=b = GreaterEqual[a,b]. Used to test if a is great than or equal to b
• <= LessEqual doc. Infix. a<=b = LessEqual[a,b]. Used to test if a is less than or equal to b
• === SameQ doc. Infix. a===b = SameQ[a,b]. Used to test if a and b are identical
• =!= UnsameQ doc. Infix. a=!=b = UnsameQ[a,b]. Used to test if a and b are not identical

Note: All the above operator can remain unevaluated, except for SameQ and UnsameQ, these always evaluate to either True or False. Even when a or b is symbolic. All operator can be used multiple times in a row e.g.: a == b == c (all have to be equal) or a > b > c (strictly decreasing numbers) or a != b != c (all unequal). The functions have arbitrary arity, e.g. Equal[] = True.

• \[Element] Element doc. Infix. a \[Element] b = Element[a,b]. Asserts that a is an element of b

Logical operators

• &&, \[And] And doc. Infix. Logical And operator. a && b = a \[And] b = And[a,b] Executes in order and has lazy evaluation
• ||, \[Or] Or doc. Infix. Logical Or operator. a || b = a \[Or] b = Or[a,b] Executes in order and has lazy evaluation
• \[Nand] Nand doc. Infix. Logical Nand operator a \[Nand] b = Nand[a,b] Executes in order and has lazy evaluation
• \[Nor] Nor doc. Infix. Logical Nor operator a \[Nor] b = Nor[a,b] Executes in order and has lazy evaluation
• ! Not doc. Prefix. Logical negation !a = Not[a]. Not to be confused with Factorial doc (postfix operator)
• ¬ Not doc. Prefix. Logical negation ¬a = Not[a].
• \[Xor] Xor doc. Infix. Logical Xor operator a \[Xor] b = Xor[a,b]
• \[Implies] Implies doc. Infix. Logical implication. a \[Implies] b = Implied[a,b]
• \[Equivalent] Equivalent doc. Infix. Logical equivalence testing. a \[Equivalent] b = Equivalent[a,b]

Note: And, Or, Nand, Nor, and Xor have arbitrary arity.

Patterns and rules

• _ Blank doc. Prefix. _ = Blank[]
• _a Blank doc. Prefix. _a = Blank[a]
• __ BlankSequence doc. Prefix. __ = BlankSequence[]
• __a BlankSequence doc. Prefix. __a = BlankSequence[a]
• ___ BlankNullSequence doc. Prefix. ___ = BlankNullSequence[]
• ___a BlankNullSequence doc. Prefix. ___a = BlankNullSequence[a]
• a_ Pattern doc. Postfix/infix. a_ = Pattern[a, Blank[]]
• a:_ Pattern doc. Postfix/infix. a:_ = Pattern[a, Blank[]]
• a__ Pattern doc. Postfix/infix. a__ = Pattern[a, BlankSequence[]]
• a:__ Pattern doc. Postfix/infix. a:__ = Pattern[a, BlankSequence[]]
• a___ Pattern doc. Postfix/infix. a__ = Pattern[a, BlankNullSequence[]]
• a:___ Pattern doc. Postfix/infix. a:__ = Pattern[a, BlankNullSequence[]]
• _. Optional doc. Postfix. _. = Optional[Blank[]] also related to Default doc
• _:a Optional doc. Postfix. _:a = Optional[Blank[],a] also related to Default doc
• __. Optional doc. Postfix. __. = Optional[BlankSequence[]] also related to Default doc
• __:a Optional doc. Postfix. __:a = Optional[BlankSequence[],a] also related to Default doc
• ___. Optional doc. Postfix. ___. = Optional[BlankNullSequence[]] also related to Default doc
• ___:a Optional doc. Postfix. ___:a = Optional[BlankNullSequence[],a] also related to Default doc
• /; Condition doc. Infix. a /; b = Condition[a, b]
• ? PatternTest doc. Infix. a ? b = PatternTest[a,b]
• -> Rule doc. Infix. a -> b = Rule[a,b]
• \[Rule] Rule doc. Infix. a \[Rule] b = Rule[a,b]
• :> RuleDelayed doc. Infix. a :> b = RuleDelayed[a,b]
• \[RuleDelayed] RuleDelayed doc. Infix. a \[RuleDelayed] b = RuleDelayed[a,b]
• /. ReplaceAll doc. Infix. a /. b = ReplaceAll[a, b]
• //. ReplaceRepeated doc. Infix. a //. b = ReplaceRepeated[a,b]
• .. Repeated doc. Postfix. a.. = Repeated[a]
• ... RepeatedNull doc. Postfix. a... = RepeatedNull[a]
• | Alternatives doc. Infix. a | b = Alternatives[a, b]. Not to be confused with || Or doc

String related

• <> StringJoin doc. Infix. a<>b = StringJoin[a,b]
• ~~ StringExpression doc. Infix. a~~b = StringExpression[a,b]

Note: both have arbitrary arity.

Graph related

• <-> UndirectedEdge doc. Infix. a<->b = UndirectedEdge[a,b]
• \[UndirectedEdge] UndirectedEdge doc. Infix. a\[UndirectedEdge]b = UndirectedEdge[a,b]
• \[DirectedEdge] DirectedEdge doc. Infix. a\[DirectedEdge]b = DirectedEdge[a,b]

Other

• \[Application] Application doc a\[Application]b Performs Application[a,b].
• . Dot doc a.b Performs the dot product of a and b
• , Used to separate arguments in a function call, e.g.: f[a,b]
• % Out doc. % = Out[$Line - 1] = Out[]. Gives the last result generated
• %% Out doc. %% = Out[-2]. Gives the penultimate result
• %..% (k repetitions of %) Out doc. %...% = Out[-k]. Gives the k-th last result
• %n Out doc. Gives the result of line n
• \[PartialD] D doc. Postfix. Use in combination with a subscript to denote a partial derivate
• \[DifferentialD] Integrate doc. Compound match fix. \[Integral]a\[DifferentialD]b = Integrate[f,b]
• ! as a postfix operator means Factorial doc a! = Factorial[a]. Mathematical factorial function
• !! as a postfix operator means Factorial2 doc a!! = Factorial2[a]. Mathematical double factorial function
• ; CompoundExpression doc. Infix. a=1;a=2 = CompoundExpression[a=1,b=2] Though it might look like a postfix operator, it is not: a=1;a=2; = CompoundExpression[a=1,b=2,Null]
• ;; Span doc. Infix. a ;; b = Span[a,b] and a ;; b ;; c= Span[a,b,c] Note that more than 2 infix operator in a row will give (most likely) unexpected results
• :: MessageName doc. Infix. a::b = MessageName[a,b]
• ? Information doc. Prefix. ?a = Information[f, LongForm -> False]. Print some information about symbol a
• ?? Information doc. Prefix. ??a = Information[f]. Print information about symbol a
• << Get doc. Prefix. << a = Get["a"]. Reads in file a, evaluating each expression in it and returning the last one. Not to be confused with left bit shift operators in other languages (BitShiftLeft doc)
• >> Putt doc. Infix. a >> b = Put[a,b]. Write a to file b. Not to be confused with right bit shift operators in other languages (BitShiftRight doc)
• >>> PutAppend doc. Infix. a >>> b = PutAppend[a,b]. Appends a to file b.

In case some symbol(s) is(are) missing, let me know!

Thanks, had added a previous version of ApplyTo, now fixed, and also added [Application]. (https://reference.wolfram.com/language/ref/Application.html)

Also added this explicitly. thanks!

Not sure how you are entering the left and right floor brackets but that is the problem,

\[LeftFloor]5.5\[RightFloor]
(* 5 *)

To enter from the keyboard esclfesc and escrfesc where esc is escape.

Sorting numerical data and the behavior of Sort

Mathematica has various ways of sorting data. Most commonly one wants to sort numbers. The command Sort can be used to do so:

Sort[{4, 2, 8, 1}]

returns:

{1, 2, 4, 8}

all very well. However, if one has symbolic answers, Sort might not do what you expect:

data3 = Sin[Range[10]]
data3 // N
Sort[data3]

gives:

{Sin[1],Sin[2],Sin[3],Sin[4],Sin[5]}
{0.841471,0.909297,0.14112,-0.756802,-0.958924}
{Sin[1],Sin[2],Sin[3],Sin[4],Sin[5]}

It looks like if Sort did not do anything! What is happening here? Well, Sort puts things in canonical order and decides whether they are ordered correctly using the default function Order (which works basically the same as OrderedQ):

OrderedQ[1,2]  (* True, they are ordered *)
OrderedQ[2,1]  (* False; they are not ordered *)
OrderedQ[Sin[2], Sin[3]]    (* True, they are ordered! *)

That might be a bit unexpected. Sort will only look at the structure, and then 2 comes before 3. If we want to explicitly sort by numerical value (rather than canonical order) one needs to specify this:

data3 = Sin[Range[5]]
data3 // N
Sort[data3, Less]  (* prior to V11.1 *)
N[%]
Sort[data3, NumericalOrder]   (* V11.1 and up *)
N[%]

One can do this in the above two ways (using NumericalOrder rather than Order) or using the function Less which will evaluate the number numerically and then compare them. Since Version 11.1 there is also a new function called NumericalSort which just does that:

data3 = Sin[Range[5]]
data3 // N
NumericalSort[data3]
N[%]

Now that we know why Sort sometimes gives unexpected results, and that we have found alternate ordering functions, we find that this is generally not fast.

data = RandomReal[1, 10^6];
AbsoluteTiming[Sort[data, Less];]

It takes several seconds (5.3 seconds on my laptop) to sort a million numbers! Ok, what's going on here? The problem is that Sort with a second argument does pair-wise comparisons, such that the algorithm scales very poorly. If the problem can be re-stated such that each element in a list gets a numerical value which can be sorted using the default ordering function (Order), then this is much faster. We can then improve the performance considerably by using SortBy and a second argument:

AbsoluteTiming[SortBy[data, N];]

or equivalently in this case (we already have approximate numbers so N is not necessary):

AbsoluteTiming[SortBy[data, Identity];]

which only takes 0.17 seconds on my laptop. Since we have approximate numbers, Sort itself works correctly and is fast as well:

AbsoluteTiming[Sort[data];]

Takes 0.16 seconds on my laptop.

Summary

• If one only has pure numbers (1337, 1.337 et cetera) use Sort (or from version 11.1 on use NumericalSort).

• If one has numbers but in some kind of symbolic form (Sin[3], Sqrt[5], Pi, E, Exp[2], 10 Degree, Quantity[Sqrt[..],...] or ...) use NumericalSort (or SortBy[... , N] for versions prior to 11.1).

• If your problem is not one of those, then check if the problem can be recast in one where a single function gives a 'value' to each element that then can be sorted efficiently, if that is possible use SortBy with the correct second argument

Compare the following two examples:

SortBy[{"abc","ab","e","cd","efg"},StringLength]
Sort[{"abc","ab","e","cd","efg"},StringLength[#1]<=StringLength[#2]&]

Give the same result but the first one is generally much faster.

• If such a rephrasing of the problem is not possible use the general Sort with appropriate ordering function.

Final words

Much more can be said about Sort (like the ordering of Sort for a mix of strings, symbols, and numbers). Feel free to comment on this post for additional things to consider when sorting...

Basic syntax of built-in functions

• All built-in functions start from capital letters and are in CamelCase for compound names. Users of many other programming languages might miss this as they are used to different conventions. Examples: Plot, ListPlot, FindSpanningTree, etc.

• Arguments of a function are inclosed in square brackets. Round parenthesis are used only for ordering of operations. Again, other languages use different conventions. Examples:

  • Cos[Pi] --- is a function with a single argument Pi.
  • BesselJ[1/2, 5] --- is a function with 2 arguments
  • (2-Cos[Pi])Sin[Pi/3] --- round parenthesis are used to order operations