Script syntax reference

TAG Neuron contains a powerful script parser and evaluation engine. The script engine is not ECMA-compliant. Instead, its focus is to provide an efficient and compact script language using mathemathical notation. Following is a brief overview of the syntax different script elements. You can also use the Script Prompt to experiment with script syntax.

Primitive data types

Apart from different ways to create compound data types, the following sections provide a short overview of primitive data types available in script.

Double-valued numbers

Double valued numbers are written using the following syntax (as a regular expression):

[+-]?[0-9]*([.][0-9]+)?([eE][+-]?[0-9]+)?

Examples:

1
3.1415927
1.23e-3

Complex numbers

Complex valued numbers can be written either by enclosing its real and imaginary parts in a list between parenthesis, as follows:

(Re, Im)

If no variable named i is defined, it is also possible to use the imaginary unit constant i, as follows:

Re+Im*i

Both Re and Im above are double-valued numbers.

Boolean values

Boolean values are either written as true or false.

Strings

String values are written between single quotes (') or double quotes ("). The backslash character (\) can be used to escape quote characters, or special control characters in strings, accordig to the following table.

Big Integers

Big Integers can be provided by prefixing them with the # character. You can optionally provide a numeric base for the number, by specifying d for decimal, x for hexadecimal, o for octal and b for binary, between the # sign and the sign or digits. If no base is provided, decimal base is assumed. A + or - sign can be optionally placed after the #.

#[+-]?((d?[0-9]+)|(x[0-9a-fA-F]+)|(o[0-7]+)|(b[0-1]+))

Examples:

#908340580348630802345239423850823402938409234
#x123ac40958023bc9890098ef098a098094
#-o123476253765213476523746512736512735
#d234324238402983409810483057239057091250750
#b0110101001001111010101010111101010101010
#-908340580348630802345239423850823402938409234*#x123ac40958023bc9890098ef098a098094
#o123476253765213476523746512736512735^100

Rational Numbers

Rational numbers can be provided by dividing one big integer with another.

Example:

#908340580348630802345239423850823402938409234/#x123ac40958023bc9890098ef098a098094

Null

The null object reference value is written null.

Variable references, Constants and Namespaces

Constants are pluggable into the script engine, and new constants can be defined in any library, by creating classes that implement the Waher.Script.Model.IConstant interface. Constants and root namespaces are referenced in script by simply writing their names, just as variable references are. The order of presedence among them is as follows:

1. If a variable is found having the referenced name, it is returned, regardless if there exists a constant or a root namespace with the same name.
2. If a constant is found having the referenced name, it is returned if there’s no variable with the same name, regardless if there exists a root namespaces with the same name.
3. If a root namespace is found having the referenced name, it is returned if there is no variable or constant with the same name.

The following table lists constants recognized by Waher.Script. For lists of constants published by other libraries, see the documentation for the corresponding libraries.

There are also a set of predefined variables:

Note: Names are case sensitive. r and R point to different objects.

Canonical extensions

The script engine has a feature that automatically generates canonical extensions to operators and functions if the operands and arguments are vectors, sets or matrices, and the original operator or function is defined for scalar operands and arguments. If an operator or function expects vector arguments, and matrices are used, the canonical extension sees a matrix as a vector of row vectors.

Example:

sin([10,20,30]);
[[1,2],[3,4]]+x

The above is evaluated as:

[sin(10),sin(20),sin(30)];	
[[1+x,2+x],[3+x,4+x]]

Etc.

Operators

The following operators are supported. They are listed in order of presedence.

Encapsulation

Parenthesis

Normal parenthesis ( and ) can be used to encapsulate operations that have lower order of presedence than surrounding operators, and thus control the execution flow. Example:

a * (b + c)

Vectors

Vectors can be explicitly created by listing their elements between square brackets [ and ]. Example:

v:=[1,2,3];

Loop construction of vector

Vectors can also be created using any of the DO-WHILE, WHILE-DO, FOR-TO[-STEP][-DO] or FOR EACH/FOREACH-IN[-DO] statements between braces. Examples:

v:=[DO x++ WHILE X<10];
v:=[WHILE x<10 : x++];
v:=[FOR x:=1 TO 20 STEP 3 : x];
v:=[FOREACH x IN 1..10|0.1 : x^2];
v:=[FOR EACH x IN 1..10|0.1 : x^2];

Note: DO can be exchanged with :, or completely omitted, except in the DO-WHILE case.

Implicit vector notation

Vectors can also be defined implicitly using an implicit vector notation:

[Expression[ in Elements]:Condition1[,Condition2[,...[ConditionN]]]]

This allows you to define vectors based on the contents of other vectors. Example:

X:=1..10;
P:=[x^2:x in X]

Selecting elements

Smaller vectors can be created from larger vectors, by allowing the expression in the implicit vector definition to be a simple variable reference representing an element in the larger vector, and then allowing the conditions in the definition to limit the elements belonging to the shorter vector. Example:

v:=1..100;
[x in v:floor(sqrt(x))^2=x]

Matrices

Matrices can be explicitly created by listing their row vectors between square brackets [ and ]. Example:

M:=[[1,0,0],[0,1,0],[0,0,1]];

Loop construction of matrix

Matrices can also be created using any of the DO-WHILE, WHILE-DO, FOR-TO[-STEP][-DO] or FOR EACH/FOREACH-IN[-DO] statements between braces. Examples:

M:=[DO [x++,x++,x++] WHILE X<10];
M:=[WHILE x<10 : [x++,x++,x++]];
M:=[FOR y:=1 TO 20 : [FOR x:=1 TO 20 : x=y ? 1 : 0]];
M:=[FOREACH x IN 1..10|0.1 : [x^2,x^3,x^4]];
M:=[FOR EACH x IN 1..10|0.1 : [x^2,x^3,x^4]];

Note: DO can be exchanged with :, or completely omitted, except in the DO-WHILE case.

Implicit matrix notation

Matrices can also be defined implicitly using implicit vector notation, where the Expression evaluates to row vectors. Example:

M:=Identity(5);
[Reverse(Row):Row in M]

Sets

Sets are unordered collections of items that can be used in script. There are numerous ways to define sets.

Explicit definition of sets

Sets can be explicitly created by listing their elements between braces { and }. Example:

S:={1,2,3};

Loop construction of set

Sets can also be created using any of the DO-WHILE, WHILE-DO, FOR-TO[-STEP][-DO] or FOR EACH/FOREACH-IN[-DO] statements between braces. Examples:

S:={DO x++ WHILE X<10};
S:={WHILE x<10 : x++};
S:={FOR x:=1 TO 20 STEP 3 : x};
S:={FOREACH x IN 1..10|0.1 : x^2};
S:={FOR EACH x IN 1..10|0.1 : x^2};

Note: DO can be exchanged with :, or completely omitted, except in the DO-WHILE case.

Implicit set notation

Sets can also be defined implicitly using implicit set notation:

{Expression[ in Superset]:Condition1[,Condition2[,...[ConditionN]]]}

This allows you to define infinite sets. Examples:

S:={[a,b]: a>b}
S:={[a,b]: a in Z, b in Z, a>b}
S:={[a,b,c]:a in 1..2, b in 10..13, c in 100..104}
S:={x::x>10}
S:={v[]:count(v)>3}
S:={s{}:count(s)>3}
S:={M[,]:M.Columns>M.Rows}

Note: To differentiate between creating an object ex nihilo, and creating a subset, when no superset is defined, two consequtive colons (:) can be used. {x::x>10} creates a set of all items that are comparable to 10 and are greater. {x:x>10} creates an object ex nihilo with one member x that will have a boolean value corresponding to the greater-than comparison of the variable x with 10.

Subsets

Subsets can be creted by allowing the expression in the implicit set definition to be a simple variable reference belonging to a superset, and then allowing the conditions in the definition to limit the elements belonging to the subset. Examples:

S:={x in Z:x>10}
S2:={x in S:x<20}

Object Ex nihilo

Objects can be created from nothing, by listing the members between braces { and }, separating each one with a comma , and each member name from its corresponding value with a colon :. Example:

{
	Member1: Value1,
	Member2: Value2,
	...
	MemberN: ValueN
}

Member names can be both standard variable references, or constant strings. The following example gives the same result as the example above:

{
	"Member1": Value1,
	"Member2": Value2,
	...
	"MemberN": ValueN
}

You can also choose to create an empty object, and assign properties dynamically. Example:

Obj:={};
Obj.["a","b","c"]:=1

Object methods

You can create objects with methods using object ex-nihilo notation and lambda expression. Example:

Obj:=
{
	"Sum":(x,y)->x+y,
	"Prod":(x,y)->x*y,
	"Pow":(x,y)->x^y
};

[Obj.Sum(3,4), Obj.Prod(3,4), Obj.Pow(3,4)]

Would return:

[7, 12, 81]

Suffix-operators

Suffix-operators are written after the operand to which they are applied. The following table lists available suffix operators:

Some suffix operators can be prefixed by a ? character, to include a null check of the operand. If the operand is null, the operator is not evaluated, and null is returned. The following table lists null-checked suffix operators:

Note: Since script is late-bound, most operators support dynamic and static bindings, where traditional languages only support static bindings. The following is permitted, for example:

s:="A";
Obj.("Property"+s):=10;

The above is the same as writing

Obj.PropertyA:=10;	

Canonical extensions are also possible. Example:

[Obj1,Obj2].Member

Is evaluated as (unless the vector contains a property of that name, such as the Length property):

[Obj1.Member,Obj2.Member]

Canonical extensions are allowed, on both left side, and right side. Example:

Obj.["member1","member2"]

Is evaluated as:

[Obj1.member1,Obj2.member2]

Note 2: You can combine default differentiation operators to create higher order differentiation operators. Example f''''(x) represents the fourth-order differentiation operator, and is the same as f""(x).

Note 3: For more information about physical units, see the section Physical Quantities below.

Unary prefix operators

Unary prefix operators are written before the operand to which they are applied. The following table lists available unary prefix operators:

Powers

There are two power-level operators. Both have the same order of presedence.

There are also a couple of special characters that are understood as power operators:

Factors

There are several factor-level operators, apart from the assignment versions. Both have the same order of presedence.

Note: In some languages % is a residue operator. In this language, the % operator is a percent operator.

Binomial Coefficients

Binomial coefficients can be calculated using the OVER operator, as follows:

n OVER k

Terms

There are four term-level operators, apart from the assignment versions. Both have the same order of presedence.

Intervals

Intervals can be created in the following way:

From .. To

By default, the step size is 1. You can specify the step size in the following way:

From .. To | StepSize

Intersections

The intersection of two sets is accomplished as follows:

Set1 INTERSECT Set2.
Set1 INTERSECTION Set2.

The Intersection character ∩ can also be used:

Set1 ∩ Set2

Unions

The union of two sets is accomplished as follows:

Set1 UNION Set2.

The CUP character ∪ can also be used:

Set1 ∪ Set2

Shift operators

There are two shift operators, apart from the assignment versions. Both have the same order of presedence.

Comparison operators

There are various different comparison operators. All have the same order of presedence.

Note: Element-wise variant of operators only exist for equality or non-equality operators, since these are also defined when comparing encapsulating objects such as sets, vectors, arrays, matrices, etc.

Note 2: If regular expressions contain named groups, variables with the corresponding names will be set to the contents of the corresponding groups if the regular expression matches the string. If the contents is numerical, the corresponding variable will also be numerical. If you want to reference the string literal, use the variable starting with the same name having a suffix of _STR. The position of a group variable match is provided by the variable starting with the same name having a suffix of _POS. Likewise, the variable starting with the same name having a suffix of _LEN provides the length of the match.

Range operators

You can combine two of the < and <=, or > and >= to create range operators. Examples:

10 < x <= 20
100 >= y >= 0
{"name":Str(Required(Name)),"age":Required(0 <= Int(Age) <= 100)),"profession":Optional(Str(Profession))}:=Obj

Membership operators

There are various different membership operators. All have the same order of presedence.

AND operators

There are various different AND operators. All have the same order of presedence.

OR operators

There are various different OR operators. All have the same order of presedence.

Note: The XNOR operator has the same truth table as the equivalence operator <=>, but the order of presedence is different.

Equivalence or implication

Equivalence or implication operators have the same order of presedence.

Equivalence

The equivalence operator is a boolean operator that checks if the both sides are equivalent (or equal, as boolean values). Example:

a <=> b

Truth table:

Implication

The implication operator is a boolean operator that checks if the left side implies the right side (as boolean values). Example:

a => b

Truth table:

Lambda definition

A lambda definition creates an implicit unnamed function. A lambda definition is created by using the -> operator. If multiple parameters are used, they must be enclosed between parenthesis. Examples:

x->x^2;
(x,y)->sin(x)*exp(-1/y^2);

Note: Implicit lambda definitions are created if referring to a function by using only its name. If writing only abs, a lambda definition x->abs(x) will be returned. This makes it possible to create functions taking lambda expressions as parameters, implementing algorithms, and call them using simple references to the existing function library.

Lambda definitions and canonical extensions

When defining lambda functions you can provide information on how arguments are to be treated, and thus also implicitly automatically define canonical extensions for the expression. Each argument x can be defined to belong to one of five categories:

Assignment

A variable assignment is defined using the := operator. Example:

Variable := Value

Assignment, Pattern Matching

If the left side is not a variable reference, a pattern matching algorithm is employed that tries to assign all implicitly available variable references by comparing both sides.

Examples:

[x,y]:=f(a,b,c)
v[]:=f(a,b,c)
[[a11,a12],[a21,a22]]:=Identity(2)
{"name":Str(Required(Name)),"age":Required(0 <= Int(Age) <= 100)),"profession":Optional(Str(Profession))}:=Obj

In the first example, the function f, which takes three parameters, is supposed to return a vector of two elements. If it does, the variables x and y are assigned the elements of this return vector. In the second example, the v is supposed to be a assigned a vector. If the result of the function call is not a vector, it is converted to a vector before being assigned to v. The third example matches the 2x2 matrix result evaluated on the right, with the matrix notation on the left. The fourth example matches an object created ex-nihilo (such as a JSON object), with an object definition, including checks of data types (and possible conversions), tests of valid values, as well as checks for required and optional fields.

The MATCHES operator can also be used. It returns true if there’s a pattern match (and implicit variables are assigned accordingly), or falseif there’s not a pattern match. The above examples become:

f(a,b,c) matches [x,y]
f(a,b,c) matches v[]
Identity(2) matches [[a11,a12],[a21,a22]]
Obj matches {"name":Str(Required(Name)),"age":Required(0 <= Int(Age) <= 100)),"profession":Optional(Str(Profession))}

Special Assignment Operators

There’s also a set of aritmethic operators that act directly on a variable value, an object member or index. These are also categorized as assignment operators, and have the same order of presedence. These operators are:

Note: ^= is not a logical XOR with self operator but a power of self operator.

You can also combine operators to perform partial assignments, as follows:

Function definitions and canonical extensions

When defining functions you can provide information on how arguments are to be treated, and thus also implicitly automatically define canonical extensions for the function. Each argument x can be defined to belong to one of five categories:

Conditional IF

Conditional IF-statements can be written in various ways. Either using the IF and THEN keywords, followed by the optional ELSE keyword, or by using the ? operator, followed by the optional : operator. There is also a quick null-check statement using the ?? operator. There is a ??? operator also, described in the following section.

Examples:

IF Condition THEN IfTrueStatement
IF Condition THEN IfTrueStatement ELSE IfFalseStatement
Condition ? IfTrueStatement
Condition ? IfTrueStatement : IfFalseStatement
Statement ?? IfNullStatement

Note: IF, THEN and ELSE are case insensitive. They are written here using upper case for clarity.

Note 2: If no ELSE or : is present, the statement is evaluated to null.

Conditional Statements (DO/WHILE, WHILE/DO, FOR, FOREACH, TRY CATCH FINALLY)

There are multiple ways to execute conditional loops. These statements have the same order of presedence:

Note: The DO keyword can be replaced by a :.

Note 2: The use of the STEP keyword together with the step size is optional. If omitted, a default step size of 1 or -1 will be used, depending if the loop is ascending or descending.

Note 3: Exceptions caught using the CATCH statement are accessible within the CATCH statement by referencing the variable Exception.

Lists

Lists of statements are created by writing a list of statements or arguments, each separated by a comma , character. Example:

Statement1, Statement2, Statement3, ...

Whitespace is ignored. This includes new-line characters. So Statements can be written on separate rows. Example:

Statement1,
Statement2,
Statement3,
... 

Lists are used in different constructs, such as function definitions and evaluations, lambda definitions, or when working with sets, vectors or matrices, for example.

It is permissible to ignore arguments in a list. Such arguments will implicitly receive the value null. Example:

Arg1, Arg2,, Arg4

Here, there third argument will have value null.

Sequences

Sequences of statements are created by writing a list of statements, each separated by a semicolon ; character. Example:

Statement1; Statement2; Statement3; ...

Whitespace is ignored. This includes new-line characters. So Statements can be written on separate rows. Example:

Statement1;
Statement2;
Statement3;
... 

Functions

Functions are extensible and can be defined in any module in the solution. A complete list of functions available in a solution therefore depends on all libraries included in the project. Functions listed here only include functions defined in this library.

Note: Function names are case insensitive.

Analytic Functions

The following subsections list available analytic or partially analytic functions, partitioned into groups.

Exponential and power functions

The following table lists available exponential and power functions:

Trigonometric functions

The following table lists available trigonometric functions:

Hyperbolic functions

A corresponding set of hyperbolic functions also exists:

Scalar Functions

The following table lists available scalar functions:

Complex Functions

The following table lists available scalar functions:

String Functions

The following table lists available string-related functions:

Date and Time Functions

Note: When specifying a date and time using ticks, the number of ticks can either mean the number of seconds from the UNIX Epoch (at 1970-01-01 00:00:00), if ticks fit as a 32-bit integer, or the number of 100ns ticks since 0001-01-01 00:00:00.

Vector Functions

The following functions operate on vectors:

Matrix Functions

The following functions operate on matrices:

Note: The transpose and conjugate transpose of a matrix is performed using the T and H suffix operators, not by function calls.

Transforms

The following functions generate transformation matrices:

Runtime Functions

The following functions are useful to control the runtime execution of the script:

Logging Functions

The following functions can be used to log information to the event log:

Note: The Message can be a string message, or an object derived from Exception. If such an object any of the following interfaces (from the Waher.Events namespace), the corresponding attributes will be logged with the message automatically: IEventObject, IEventActor, IEventId, IEventLevel, IEventFacility, IEventModule and IEventTags.

Note 2: The Tags argument in the logging functions should be an object-ex-nihilo (or similar object), providing tags as key-value pairs. Any tag name can be used, however, the Event log treats the following tag names specially: Object, Actor, EventId, Level, Facility, Module, StackTrace.

Extensions

The script engine can be extended by modules that are run in the environment. The following subssections list such funcion extensions made available in different modules available by default on the gateway. This list does not include funcion extensions made available by applications that are not part of TAG Neuron.

Color functions (Waher.Script.Graphs)

The following functions are available in the Waher.Script.Graphs library.

Note: In all functions expecting color arguments, you can pass any of the named colors as a string instead. The named colors will be recognized, and converted to the corresponding color.

Graph functions (Waher.Script.Graphs)

The following functions are available in the Waher.Script.Graphs library. In an interactive script environment, clicking on the resulting graphs will return a vector corresponding to the point under the mouse.

The following table lists variables that control graph output:

You can combine graphs using the + operator, as long as graph axes are compatible:

x:=-10..10;
y:=sin(x);
y2:=2*sin(x);
plot2dcurvearea(x,y,rgba(255,0,0,64))+
   plot2dcurvearea(x,y2,rgba(0,0,255,64))+
   plot2dcurve(x,y)+
   plot2dcurve(x,y2,"Blue")+
   scatter2d(x,y,"Red",5)+
   scatter2d(x,y2,"Blue",5)

Graph-types having string labels on one axis, and values on another, can be added using element-wise addition operator .+ as well. When this operator is used, not only are the graphs added, but the internal values are accumulated as well. Example:

Labels:=["A","B","C","D","E","F"];
Colors:=["Red","Green","Blue","Yellow","Magenta","LightGray"];
G:=[foreach x in 0..5 do VerticalBars(Labels,Uniform(0,10,6),Alpha(Colors[x],192))];
G[0].+G[1].+G[2].+G[3].+G[4].+G[5];

Normal addition, using the same values is achieved easilly as follows. The half-transparent bars are painted one on-top of the other, as they occupy the same numerical space.

Sum(G)

Use the GraphWidth and GraphHeight variables to control graph output size. The following example shows how to construct a Sparkline graph:

x:=0..100;
y0:=0;
y:=[foreach i in x do y0:=y0+Uniform(-1,1)];
GraphWidth:=200;
GraphHeight:=25;
Sparkline:=plot2dline(x,y,"Black",1)+scatter2d(100,y[y.Length-1],"Red",2);
Sparkline.ShowXAxis:=false;
Sparkline.ShowYAxis:=false;
Sparkline.ShowGrid:=false;
Sparkline;

If you use layered graphs that are painted ontop of underlying graphs, you can use the alpha channel to add transparency:

x:=-10..10;
y:=sin(x);
y2:=2*sin(x/2);
plot2dlayeredcurvearea(x,y,rgba(255,0,0,64))+
   plot2dlayeredcurvearea(x,y2,rgba(0,0,255,64))+
   plot2dcurve(x,y)+
   plot2dcurve(x,y2,"Blue")+
   scatter2d(x,y,"Red",5)+
   scatter2d(x,y2,"Blue",5)

You can set the properties Title, LabelX and LabelY to descriptive strings, to provide information to the reader:

GraphWidth:=800;
GraphHeight:=400;
f:=x->sin(5*x)*exp(-(x^2/10));
x:=-10..10|0.1;
G:=plot2dcurve(x,f(x),"Blue")+plot2dcurve(x,f'(6)*(x-6)+f(6))+plot2dcurve(x,f'(-6)*(x+6)+f(-6))+scatter2d([-6,6],[f(-6),f(6)],"Red");
G.Title:="Tangent at x=6 and x=-6";
G.LabelX:="x";
G.LabelY:="y=sin(5x)exp(-(x^2/10))";
G

3D Graph functions (Waher.Script.Graphs3D)

The following graph functions are available in the Waher.Script.Graphs3D library.

To use the 3D graph functions, or the 3D graphic drawing primitives, you may also need to use the following helper functions.

Or the following shader-related functions:

While the two-dimensional graph functions take two vectors as input, one for each of the two coordinates (x and y), the three-dimensional graph functions take matrices as input, one for each of the three coordinates (x, y and z). To convert vectors to matrices suitable for three-dimensional graphs, you can use the Columns and Rows functions respectively. Since matrices are square, it is important to use the element-wise operators when using arithmetic operators with the elements of the matrices. Otherwise, the corresponding matrix operations will be used.

Example:

x:=Columns(-10..10|0.1);
z:=Rows(-10..10|0.1);
r:=sqrt(x.^2+z.^2);
y:=10*cos(r*2).*exp(-r/3);
samescale(surface3d(x,y,z))

You can use the Title, LabelX, LabelY, LabelZ, Angle, Inclination and Oversampling properties of the 3D-graph make the graph more informative:

Example:

x:=Columns(-10..10|0.1);
z:=Rows(-10..10|0.1);
r:=sqrt(x.^2+z.^2);
y:=10*cos(r*2).*exp(-r/3);
G:=samescale(surface3d(x,y,z));
G.Title:='Title';
G.LabelX:='X-axis';
G.LabelY:='Y-axis';
G.LabelZ:='Z-axis';
G.Angle:=45;
G.Inclination:=60;
G

You can also use the addition operator, as with two-dimensional graphs, to show multiple graphs simultanerously.

Example:

Thorus(R0,R1,Color,dx,dy,dz):=
(
	theta:=Columns((0..360|5)°);
	phi:=Rows((0..360|5)°);
	x:=(R1+R0*cos(theta)).*cos(phi)+dx;
	y:=R0*sin(theta)+dy;
	z:=(R1+R0*cos(theta)).*sin(phi)+dz;
	samescale(surface3d(x,y,z,Color))
);

Thorus(5,20,'Red',0,0,0)+
	Thorus(3,15,'Blue',0,10,0)+
	Thorus(2,10,'Green',0,17,0)+
	Thorus(1,7,'Yellow',0,20,0)

When drawing 3D surfaces, you can choose to draw a wireframe, use polygon facets or use proper Phong Shading to emulate a curved surface. In the latter example, surface normals are interpolated across all facets, creating a smooth appearance when it interact with light sources.

Example:

theta:=Columns((0..360|5)°);
phi:=Rows((0..360|5)°);
R:=10;
x:=R*cos(theta).*cos(phi);
y:=R*sin(theta);
z:=R*cos(theta).*sin(phi);
samescale(linemesh3d(x+10,y+10,z+10)+polygonmesh3d(x+30,y+10,z+10)+surface3d(x+20,y+30,z+10))

There are also specific 3D charts available that you can use. They may still require you to prepare the input accordingly.

Example:

[LabelsX,LabelsZ,Y]:=Histogram2D([Normal(0,1,100000),Normal(0,1,100000)],-5,5,50,-5,5,50);
VerticalBars3D(Columns(LabelsX),Y,Rows(LabelsZ))

Palette generation functions (Waher.Script.Fractals)

The following functions can be used to randomly create color palettes. The functions are available in the Waher.Script.Fractals library. In an interactive script environment, clicking on the resulting graphs will zoom into the fractal, unless otherwise stated.

Complex Fractal functions (Waher.Script.Fractals)

The following functions can be used to create fractal images based on iterations in the complex plane. The functions are available in the Waher.Script.Fractals library. They can be used as a means to create backgound images for themes, etc.

Iterated Function System (IFS) Fractal functions (Waher.Script.Fractals)

The following functions can be used to create fractal images based on Iterated Function Systems (IFS). The functions are available in the Waher.Script.Fractals library. They can be used as a means to create backgound images for themes, etc.

IfsFractals run on Iterated Function Systems using systems of equations, with optional color coding and weights. These equations, color codings and weights are provided in the vector T. These equations can be given by matrices representing linear transforms, or lambdra expressions. Examples:

IfsFractal(0.5,0.5,1,1e6, [
	Scale2DH(0.5,0.5),
	Translate2DH(0.25,0.5)*Scale2DH(0.5,0.5),
	Translate2DH(0.5,0)*Scale2DH(0.5,0.5)],400,400);

IfsFractal(0,0,3,1e6, [
	 z->sqrt(z-(-0.748814392089844-0.0801434326171877*i)),
	 z->-sqrt(z-(-0.748814392089844-0.0801434326171877*i))],400,400);

IfsFractal(0,5,6,1e6, [
	 [[0,0,0],
	 [0,0.16,0],
	 [0,0,1]],
	 0.01,"Green",
	 [[0.85,0.04,0],
	 [-0.04,0.85,1.6],
	 [0,0,1]],
	 0.85,"Green",
	 [[0.2,-0.26,0],
	 [0.26,0.24,1.6],
	 [0,0,1]],
	 0.07,"Green",
	 [[-0.15,0.28,0],
	 [0.26,0.24,0.44],
	 [0,0,1]],
	 0.07,"Green"],300,600);

Flame fractals can modify the linear transforms using one or more variations. (Variations can be seen as non-linear “distortions”, or modifiers, to the iterated function system, to create more interesting visual results.) There are also two rendering modes: HSL and RGBA.

Example:

FlameFractalRgba(0,0,0,1e7,[
	Rotate2DH(-45°)*Scale2DH(1/sqrt(2),1/sqrt(2)),"Orange",ExponentialVariation(),
	Translate2DH(1,0)*Rotate2DH(-135°)*Scale2DH(1/sqrt(2),1/sqrt(2)),"Red",ExponentialVariation()
	],400,300)

There are many different types of predefined variations¹ that can be used. You can also use the LambdaVariation to create your custom variations.

External Database-related functions (Waher.Script.Data)

Note: To close a connection, destroy the variable containing the connection using the Destroy or Delete function.

Closing a connection

To close a connection, destroy the variable containing the connection using the Destroy or Delete function:

Destroy(db)

Executing custom SQL on an extenral database

To execute custom SQL on an external database, treat the connection as a lambda expression taking one parameter: The script to execute. Any results or result sets will be returned to the script after completing the execution. Example:

Nr:=db("SELECT COUNT(*) from city");

Stored Procedures

Stored Procedures in the database are available directly by reference on the connection object. If you have a stored procedure in the database named proc that takes two arguments P1 and P2, and a connection that you have stored in db, you call the procedure as follows:

db.proc(P1,P2)

You can also create a lambda expression to the stored procedure, and store it in a variable for reference:

f:=db.proc;
f(P1,P2)

This syntax is available for all database conncetions that support stored procedures.

External MySQL Database-related functions (Waher.Script.Data.MySQL)

This module adds external database support for MySQL databases. Connections established to MySQL databases work in script, as all connection types defined in the Waher.Script.Data library, so the corresponding subsections will not be repeated here.

External PostgreSQL Database-related functions (Waher.Script.Data.PostgreSQL)

This module adds external database support for PostgreSQL databases. Connections established to PostgreSQL databases work in script, as all connection types defined in the Waher.Script.Data library, so the corresponding subsections will not be repeated here.

Full-text-search functions (Waher.Script.FullTextSearch)

This module adds full-text-search capabilities to script, using the full-text-search module provided in Waher.Persistence.FullTextSearch library. The following functions are available:

Full-text-search query syntax

Full-text-search is done providing a query string. This query string contains keywords separated by whitespace. Keywords only consist of letters and digits, and are case insensitive. Punctuation characters, accents, etc., are ignored. So are a configurable set of stop words, common words that have little significance in full-text-search. If the keyword is prefixed with a +, it is required to exist. If it is prefixed by -, it is prohibited. No prefix means it is optional. Wildcards are permitted in keywords. You can use any of the characters *, %, ¤ or # as wildcard characters. You can also use regular expressions by encapsulating it between / characters, such as /regex/. You can search for sequences of keywords by encapsulating them between apostrophes ' or quotes ".

The syntax can be nested, so you can combine the different constructs.

Note: The words was and here are used as examples only, to highlight syntax. They are typically considered stop words, and thus ignored in a real search.

Strictness

Strictness in search is controlled by the Strict argument in the Search function. If true, each keyword is interpreted as-is. The keyword will match search, but not searching. If Strict is false, keywords are interpreted as prefixes. The keyword search will therefore also match searching.

Search order

Search order in the Search function is controlled by the optional Order arguments. If not provided, Relevance is used. You can provide string values, or an enumeration value of type Waher.Persistence.FullTextSearch.FullTextSearchOrder. Possible values:

Pagination Strategy

When searching for typed objects, especially in full-text-search collections indexing objects of multiple types, a strategy for how to handle pagination and incompatible types is necessary, for performance reasons. This is controlled by the optional PaginationStrategy argument in the Search function, together with the Type argument, that controls the type of objects to search for. You can provide a string value, or an enumeration value of type Waher.Persistence.FullTextSearch.PaginationStrategy. The default value is PaginateOverObjectsNullIfIncompatible, which is the fastest option. But incompatible objects will be returned as null. The following values are available.

Networking-related functions (Waher.Script.Networking)

The following functions are available in the Waher.Script.Networking library.

Persistence-related functions (Waher.Script.Persistence)

The following functions are available in the Waher.Script.Persistence library.

In addition to this, the following XPATH/SPARQL extension functions are defined

Statistics-related functions (Waher.Script.Statistics)

The following functions are available in the Waher.Script.Statistics library.

System-related functions (Waher.Script.System)

The following functions are available in the Waher.Script.Statistics library.

Threading-related functions (Waher.Script.Threading)

The following functions are available in the Waher.Script.Threading library.

Example of parallel execution:

f(s):=
(
	Start:=Now;
	foreach x in 1..10 do
	(
		Sleep(Uniform(500,1500));
		Semaphore("Output",printline(s+": "+x));
	);
	Now.Subtract(Start).TotalSeconds
);

Parallel(f("A"),f("B"),f("C"))

Content-related functions (Waher.Script.Content)

The following functions are available in the Waher.Script.Content library.

Cryptography-related functions (Waher.Script.Cryptography)

The following functions are available in the Waher.Script.Cryptography library.

XML-related functions (Waher.Script.Xml)

The following functions are available in the Waher.Script.Xml library.

Note: The XML functions are made available so that access to elements and attributes in XML documents can be made accessible in environments where the period (.) operator is not available, for security reasons.

XMLDSIG-related functions (Waher.Script.XmlDSig)

The following functions are available in the Waher.Script.XmlDSig library.

Markdown-related functions (Waher.Content.Markdown)

The following functions are available in the Waher.Content.Markdown library.

The following context-specific constants (read-only variables) are available in inline script:

Semantic-web-related functions (Waher.Content.Semantic)

The following functions are available in the Waher.Content.Semantic library.

XSL-related functions (Waher.Content.Xsl)

The following functions are available in the Waher.Content.Xsl library.

Layout Extensions (Waher.Layout.Layout2D)

The following functions are available in the Waher.Layout.Layout2D library.

In the following subsections, specialized HTTP Error functions are listed.

Web Extensions (Waher.Networking.HTTP[.UWP])

Script can be embeded in transformable web content, such as Markdown documents. The following functions are available in the Waher.Networking.HTTP and Waher.Networking.HTTP.UWP libraries.

In the following subsections, specialized HTTP Error functions are listed.

Redirections

The following functions return HTTP redirection responses back to he client:

Client Errors

The following functions return HTTP client error responses back to he client:

Server Errors

The following functions return HTTP server error responses back to he client:

Special Web Variables

The following predefined variables are available when processing web requests:

JWS Extensions (Waher.Security.JWS)

The following functions are available in the Waher.Security.JWS librariy.

JWT Extensions (Waher.Security.JWT[.UWP])

The following functions are available in the Waher.Security.JWT and Waher.Security.JWT.UWP libraries.

Thing-related Extensions (Waher.Things)

The following functions are available in the Waher.Things library.

Gateway Extensions (Waher.IoTGateway)

The following functions are available in web pages hosted by the IoT Gateway:

The following predefined variables are available in web pages hosted by the IoT Gateway:

Gateway Console Extensions (Waher.IoTGateway.Console)

The following functions are available in the Waher.IoTGateway.Console console application library. Running the IoT Gateway as a console application, adds these functions to the script engine.

Gateway Service Extensions (Waher.IoTGateway.Svc)

The following functions are available in the Waher.IoTGateway.Svc Windows Service host application library. Running the IoT Gateway as a Windows Service, adds these functions to the script engine.

The following predefined constants are also available:

Serialization-related functions (Waher.Service.NeuroLedger)

The following functions are available in the Waher.Service.NeuroLedger library, which is part of the Neuro-Ledger™.

IoT Broker Extensions (available in Waher.Service.IoTBroker)

The following subsections list functions that are available to applications running on the IoT Broker (hosting the Waher.Service.IoTBroker library) or the Neuron™.

Functions related to local services

E-mail related functions

Smart Contracts-related functions

Token-related functions

XMPP-related functions