Vector operations in ARIBAS

ARIBAS provides various support for vector operations. For example, vectors can be added, subtracted and multiplied or divided by scalars.
Example:

    ==> vec1 := (2,3,4,-1).
    -: (2, 3, 4, -1)

    ==> vec2 := (pi,exp(1),0,0.25).
    -: (3.14159265, 2.71828183, 0, 0.250000000)

    ==> vec1 + vec2.
    -: (5.14159265, 5.71828183, 4.00000000, -0.750000000)

    ==> vec1 - vec2.
    -: (-1.14159265, 0.281718172, 4.00000000, -1.25000000)

    ==> 3*vec1.
    -: (6, 9, 12, -3)

    ==> vec1 * 17.
    -: (34, 51, 68, -17)

    ==> vec2 / 3.
    -: (-1.04719755, 0.906093942, 0.000000000, 0.0833333333)

For integer vectors, we have also the operations div and mod, which are applied simultaneously to the components of the vector. Example:

    ==> vec := (100, -200, 300, -400, 500).
    -: (100, -200, 300, -400, 500)

    ==> v1 := vec div 17.
    -: (5, -12, 17, -24, 29)

    ==> v2 := vec mod 17.
    -: (15, 4, 11, 8, 7)

    ==> v1*17 + v2.
    -: (100, -200, 300, -400, 500)

A sometimes useful feature is the simultaneous assignment. Example

    ==> (x,y) := (2**10, 2**100).
    -: (1024, 1_26765_06002_28229_40149_67032_05376)

    ==> x.
    -: 1024

    ==> y.
    -: 1_26765_06002_28229_40149_67032_05376

This can be used to swap variables:

    ==> (x,y) := (y,x).
    -: (1_26765_06002_28229_40149_67032_05376, 1024)

    ==> x.
    -: 1_26765_06002_28229_40149_67032_05376

    ==> y.
    -: 1024

As another example, consider the following compact code to calculate the Fibonacci numbers.

    ==> function fibo(N: integer): integer;
        var
            u,v,k: integer;
        begin
            (u,v) := (1,0);
            for k := 1 to N do
                (u,v) := (v,u+v);
            end;
            return v;
        end.
    -: fibo

    ==> fibo(100).
    -: 3_54224_84817_92619_15075

A new function in ARIBAS is

    stack_arraypush(st: stack; vec: array of Type
                    [; direction: integer]): integer;

Pushes the components of the array vec onto the stack st. If the optional argument direction is positive or omitted, the order is from beginning to the end of vec. If direction is negative, the pushing occurs in reverse order. Return value is the number of elements pushed on st (= the length of vec). Together with the function stack2array this can be used to reverse the order of elements of a vector. Example:

    ==> var st: stack; end.
    -: var

    ==> vec := (1,2,3,4,5).
    -: (1, 2, 3, 4, 5)

    ==> stack_arraypush(st,vec,-1).
    -: 5

    ==> vec1 := stack2array(st).
    -: (5, 4, 3, 2, 1)

Homepage of ARIBAS

Otto Forster 2004-08-16