## L1VM - array functions

I did add new functions to my `math-lib-vect` module:

``````vmath_min_int, vmath_max_int, vmath_average_int, vmath_sort_int_inc, vmath_sort_int_dec
vmath_min_double, vmath_max_double, vmath_average_double, vmath_sort_double_inc, vmath_sort_double_dec
vmath_array_copy, vmath_array_clear
``````

The `vmath_min` and `vmath_max` functions return the smallest and biggest number of an array.

The `vmath_average` function returns the average number of an array.

The `vmath_sort` functions sort an array in increasing or decreasing order.

The `vmath_array_copy` function copies an array to a new array of the same variable type.

The `vmath_array_clear` function sets an array entries to zero.

Here is a full example:

``````// array-min-max.l1com
// array with values demo
// shows how to set up an array
// and how to access the elements
//
#include <intr.l1h>
#include <vars.l1h>
(main func)
(set const-int64 1 zero 0)
(set const-int64 1 one 1)
(set int64 1 ind 0)
(set int64 1 f 0)
(set int64 1 num 0)
(set int64 1 realind 0)
// set array data using spaces as elements separator
(set int64 10 array 10 5 8 4 3 2 7 23 45 30)
(set int64 10 array_new)
(set int64 1 maxarray 10)
(set int64 1 maxind 9)
(set const-int64 1 Parray 0)
(set const-int64 1 Parray_new 0)
(set int64 1 min 0)
(set int64 1 max 0)
(set double 1 averaged 0.0)
(set string s minstr "min: ")
(set string s maxstr "max: ")
(set string s sortincstr "sorted increasing:")
(set string s sortdecstr "sorted decreasing:")
(set string s averagestr "average: ")
(set string s array_copystr "array_new copy of array:")
(set string s array_clearstr "array_new cleared:")
(zero :math_vect_init !)
(array Parray pointer)
(array_new Parray_new pointer)
// print array
(for-loop)
(((ind maxarray <) f =) f for)
((ind int64_size *) realind =)
(array [ realind ] num =)
print_i (num)
print_n
((ind one +) ind =)
(next)

// get min number
(Parray zero maxind :vmath_min_int !)
(min stpop)
print_n
print_s (minstr)
print_i (min)
print_n

// get max number
(Parray zero maxind :vmath_max_int !)
(max stpop)
print_s (maxstr)
print_i (max)
print_n

// get average
(Parray zero maxind :vmath_average_int !)
(averaged stpop)
print_s (averagestr)
print_d (averaged)
print_n
print_n

// sort array increasing numbers
(Parray maxind :vmath_sort_int_inc !)
(zero ind =)

print_s (sortincstr)
print_n
// print array
(for-loop)
(((ind maxarray <) f =) f for)
((ind int64_size *) realind =)
(array [ realind ] num =)
print_i (num)
print_n
((ind one +) ind =)
(next)
print_n

// sort array decreasing numbers
(Parray maxind :vmath_sort_int_dec !)
(zero ind =)

print_s (sortdecstr)
print_n
// print array
(for-loop)
(((ind maxarray <) f =) f for)
((ind int64_size *) realind =)
(array [ realind ] num =)
print_i (num)
print_n
((ind one +) ind =)
(next)

// copy array
(Parray Parray_new zero maxind int64_size :vmath_array_copy !)
(zero ind =)

print_n
print_s (array_copystr)
print_n
// print array
(for-loop)
(((ind maxarray <) f =) f for)
((ind int64_size *) realind =)
(array_new [ realind ] num =)
print_i (num)
print_n
((ind one +) ind =)
(next)

// clear array
(Parray_new zero maxind int64_size :vmath_array_clear !)
(zero ind =)

print_n
print_s (array_clearstr)
print_n
// print array
(for-loop)
(((ind maxarray <) f =) f for)
((ind int64_size *) realind =)
(array_new [ realind ] num =)
print_i (num)
print_n
((ind one +) ind =)
(next)

exit (zero)
(funcend)
#include <math-lib-vect.l1h>
``````

Here is the output of the program:

``````\$ l1vm prog/array-min-max -q
10
5
8
4
3
2
7
23
45
30

min: 2
max: 45
average: 13.7000000000

sorted increasing:
2
3
4
5
7
8
10
23
30
45

sorted decreasing:
45
30
23
10
8
7
5
4
3
2

array_new copy of array:
45
30
23
10
8
7
5
4
3
2

array_new cleared:
0
0
0
0
0
0
0
0
0
0
``````