## 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