SigServer:SignatureMath

Back to: SigServer:Documentation

Language Reference

Basic Syntax

Before the XML is parsed the Signature engine looks for opening and closing tags ({{ and }}). Everything between those are interpreted as Signature Math (from now on abbreviated SigMath) and parsed before the XML parser takes action. Every opening tag must be followed by a closing tag.

Example

<text>
  <line>{{ 2 + 3 }}</line>
</text>

The example above will output 5 on the signature.

Types

SigMath supports types.

• Number
• String
• Boolean

Number may be either float or integer.

Example: Numbers

1

The above example is classified as a number.

1.1

This example is also classified as a number.

"1"

This is too a number, because a check is performed on every string to see whether it is a number or not.

"-1"

This is the most efficient way to specify a negative number. Because of the way the parsing algoritm works only writing -1 doesn't work.

Example: Strings

"string"
'string'
" 1"

All three examples are strings. Both " and ' may be used with strings. You cannot escape anything inside a string. This means {{ "}}" }} or {{ "\"" }} gives you an error message.

Example: Boolean

true
false

Boolean values may only be lowercase.

Operators

SigMath supports some basic operators. Arithmetic operators have the highest priority. Comparison operators have the second highest priority. Logic operators have the least priority. Parenthesis may be used to group expressions, such as (1 + 2) * 3 = 9.

Arithmetic Operators

+

Adds two numbers. If one of the arguments are a string the second argument will be appnended to the first. Also used for concatenating strings.

-

Subracts two numbers.

*

Takes the first argument times the second.

/

Divides the first argument with the second.

Comparison Operators

<

Checks if the first argument is smaller than the second. If so true is returned.

>

Checks if the first argument is bigger than the second. If so true is returned.

<=

Checks if the first argument is smaller than or equal to the second. If so true is returned.

>=

Checks if the first argument is bigger than or equal to the second. If so true is returned.

==

Checks if the first argument is equal to the second. If so true is returned.

!=

Checks if the first argument is not equal to the second. If so true is returned.

Logic Operators

||

Checks if the first argument or the second argument are true. If so true is returned.

&&

Checks if the first argument and the second argument are true. If so true is returned.

Variables

SigMath have support for variables. It supports both AniDB variables and user defined variables. AniDB variables are prefixed with $ and user defined variables with @.

Example

{{ $example }}
{{ @example }}

The first block outputs the AniDB variable named example. The second block outputs the user defined variable named example. A user defined variable may have the same name as an AniDB variable. The variables are only lowercase alphanumeric and may contain _ as well.

Functions

SigMath support a range of functions. Arguments are separated by comma, and each argument are evaluated before it is passed on to the function. For a complete list of all functions see the function reference.

Function Reference

Mathematical

abs

number abs(number value);

Returns the absolute value of a number

Example

abs(1);  // Returns 1
abs(-1); // Returns 1

ceil

number ceil(number value);

Returns the ceiling of a number.

Example

ceil(1.4); // Returns 2
ceil(1.9); // Returns 2

floor

number floor(number value);

Returns the floor of a number.

Example

floor(1.1); // Returns 1
floor(1.9); // Returns 1

max

number max(number value1, number value2[, number ...]);

Returns the numerically highest value of the given arguments. At least two arguments are required.

Example

max(3, 5);           // Returns 5
max(3, 1.2, 5, 5.1); // Returns 5.1

min

number min(number value1, number value2[, number ...]);

Returns the numerically lowest value of the given arguments. At least two arguments are required.

Example

min(3, 5);           // Returns 3
min(3, 1.2, 5, 5.1); // Returns 1.2

mod

number mod(number dividend, number divisor);

Returns the reminder when dividing dividend with divider.

Example

mod(10, 3); // Returns 1

pow

number pow(number base, number exp);

Returns base to the power of exp.

Example

pow(3, 2); // Returns 9
pow(2, 3); // Returns 8

round

number round(number value[, number precision]);

Returns a rounded number with the given precision. If precision isn't specified it will return an integer.

Example

round(2.4);     // Returns 2
round(2.5);     // Returns 3
round(2.55, 1); // Returns 2.6

sqrt

number sqrt(number value);

Returns the square root of value.

Example

sqrt(9); // Returns 3

Miscellaneous

if

Alias of notempty();

lc

Alias of lowercase();

lowercase

string lowercase(mixed value[, string options]);

If only first argument is specified it converts all the characters to lowercase. The second argument may be "first" or "words". If it is "first" only the string's first character will be converted. If it is set to "words", every word's first character will be converted.

Example

lowercase("Foo Bar");          // Returns "foo bar"
lowercase("Foo Bar", "first"); // Returns "foo Bar"
lowercase("Foo BAR", "words"); // Returns "foo bAR"

notempty

mixed notempty(mixed value[, mixed true[, mixed false]]);

Check's if the first argument is not empty. Returns TRUE or FALSE if the optional arguments aren't specified. If they are specified it returns the second argument if TRUE and the third argument if FALSE.

Example

notempty("");                       // Returns false
notempty("Foobar");                 // Returns true
notempty(6 > 2);                    // Returns true
notempty("", "Not empty", "Empty"); // Returns "Empty"

padding

string padding(mixed value, number padding[, string align]);

Takes value and adds padding on left side if third argument isn't specified. Third argument is optional and may be "left" or "right" and specifies the padding alignment. Second argument specifies the padding width.

Example

padding("2.40", 6);         // Returns "  2.40"
padding("12.40", 6);        // Returns " 12.40"
padding("2.40", 6, "left"); // Returns "2.40  "
padding("1220.40", 6);      // Returns "1220.40"

date

string date(string format[, string time]);

Returns date and time according to the first argument. The format syntax is the same as PHP's date(). The optional argument may be a timestamp or string with date.

Example

date("Y-m-d");                        // Returns current date e.g. "2007-11-20"
date("H:i:s");                        // Returns current time, e.g. "19:50:37"
date("Y-m-d", "1995-10-03T20:30:37"); // Returns date "1995-10-03"

precision

string precision(number value, number precision);

Returns string containing value with a fixed number of decimals.

Example

precision(5, 2);    // Returns "5.00"
precision(5.25, 1); // Returns "5.2"
precision(5.26, 1); // Returns "5.3"
precision(5.24, 1); // Returns "5.2"

truncate

string truncate(string value, number length[, string appendage]);

Returns the string truncated to specified length. If third argument is specified it will be appended to the returned string if it's truncated.

Example

truncate("Foobar", 3);       // Returns "Foo"
truncate("Foobar", 4, ".."); // Returns "Fo.."
truncate("Foob", 4, "..");   // Returns "Foob"

uc

Alias of uppercase();

uppercase

string uppercase(mixed value[, string options]);

If only first argument is specified it converts all the characters to uppercase. The second argument may be "first" or "words". If it is "first" only the string's first character will be converted. If it is set to "words", every word's first character will be converted.

Example

uppercase("Foo Bar");          // Returns "FOO BAR"
uppercase("foo bar", "first"); // Returns "Foo bar"
uppercase("foo BaR", "words"); // Returns "Foo BaR"