Numeric Operators

Table 4-1 displays a list of all numeric operators up to digraphs [1], sorted in descending order of their precedence. An equal precedence value (column 1) means the operators are evaluated following the given associativity (column 3).

The table is generated with a Scilab script, i.e. we had the interpreter determine its own precedence rules, which is neat. These scripts are listed in Chapter 9.

One line asks for an additional warning, and that's the unary minus at level 19. It looses against the power operator, ^. Therefore, -1^2 gives -1 and not 1. In other words Scilab sees -1^2 as -(1^2).

The association rules follow those of standard algebra. Thus, nobody should be surprised that a^b^c is interpreted as a^(b^c).

Relational Operators

Scilab implements the usual gang of relational operators with some syntactic sugar of having two "unequality"-operators <>, and ~=. The relational operators' precedences rank in between the numeric and the logical operators like they do in many other modern programming languages. This allows for a minimal use of parentheses in larger expressions like

    if 2.0*n > l+1.0  |  n/3.0 <= k then
        ...
    end

which evaluates exactly the same way as

    if ((2.0 * n) > (l + 1.0)) | ((n / 3.0) <= k) then
        ...
    end

just with much less line-noise.

Logical Operators

There are three logical operators: &, |, and ~, meaning "and", "or", and "not". The twiddle, ~ has the unique syntactic property that any number of consecutive twiddles are allowed and evaluated. But unless you want to enter the obfuscated Scilab contest, sticking with one probably is best as e.g. 15 ~ are as good as none, and therefore

    ~~~~~~~~~~~~~~~%t

returns F.

Table 4-2 shows the complete list of Scilab's logical (also known as boolean) operators sorted according to decreasing precedence.

For the logical operators have boolean expressions as their arguments, it is time now to discuss the implicit promotion of numeric types to boolean type, something very familiar to C, Perl, and Python programmers. You have guessed right, the rule is: "Zero is false, everything else is true." Here are some examples of that rule at work:

    -->%t & 0
     ans  =
      F  

    -->%t & 0.1
     ans  =
      T  

    -->6.34 | %f
     ans  =
      T  

    -->6.34 | -0.3
     ans  =
      T  

Scilab always evaluates boolean expressions completely. No operator is defined with short-circuit evaluation semantics.

    -->deff('b = ret_false()', 'b = %f, disp(''ret_false'')');

    -->ret_false() & ret_false()

     ret_false

     ret_false
     ans  =

      F