//function create(*args)
//  Создает массив с указанными элементами
//
//  Параметры:
//      *args -- элементы массива, до 26 аргументов, не <null> типа
//
//  Возвращает:
//      <array>
//
//  Описание:
//      Имитирует конструктор массива, создающий массив с элементами,
//      переданными в качестве аргументов. Пропущенные или элементы,
//      равные null не включаются в массив.
//
function create(a=null,b=null,c=null,d=null,e=null,f=null,g=null,
                h=null,i=null,j=null,k=null,l=null,m=null,n=null,
                o=null,p=null,q=null,r=null,s=null,t=null,u=null,
                v=null,w=null,x=null,y=null,z=null) export
    res=new Array();
    temp=new Array();
    exstr="";
    for _i=97 to 122 do
        exstr=exstr+"temp.add("+char(_i)+");";
    enddo;
    execute(exstr);
    for each item in temp do
        if item<>null then
            res.add(item);
        endif;
    enddo;
    return res;
endfunction

/////////////////////////////////////////////////////////////////////////////

//function count(arr,value)
//  Возвращает количество элементов value в массиве arr
//
//  Параметры:
//      arr <array>,<fixedarray>
//      value <any>
//
//  Возвращает:
//      <number>
//
function count(arr,value) export
    if not check.is_array_or_fixedarray(arr) then
        raise exception.TypeError("argument 1 must be array or fixedarray",
                                  new Structure("arr,value",arr,value));
    endif;
    res=0;
    for each item in arr do
        if item=value then
            res=res+1;
        endif;
    enddo;
    return res;
endfunction

/////////////////////////////////////////////////////////////////////////////

//function copy(arr)
//  Возвращает копию массива arr
//
//  Параметры:
//      arr <array>,<fixedarray>
//
//  Возвращает:
//      <array>,<fixedarray>
//
function copy(arr) export
    if not check.is_array_or_fixedarray(arr) then
        raise exception.TypeError("argument 1 must be array or fixedarray",
                                  new Structure("arr",arr));
    endif;
    res=new Array();
    execute("
    |for each item in arr do
    |    res.add(item);
    |enddo;");
    return ?(check.is_array(res),res,array.freeze(res));
endfunction

/////////////////////////////////////////////////////////////////////////////

//function freeze(arr)
//  "Замораживает" массив, создавая из него FixedArray
//
//  Параметры:
//      arr <array>,<fixedarray>
//
//  Возвращает:
//      <fixedarray>
//
//  Описание:
//      Враппер над конструктором FixedArray. Ничего не делает, если передать
//      arr как <fixedarray>.
//
function freeze(arr) export
    if check.is_fixedarray(arr) then
        return arr;
    endif;
    if not check.is_array(arr) then
        raise exception.TypeError("argument 1 must be array",
                                  new Structure("arr",arr));
    endif;
    return new FixedArray(arr);
endfunction

/////////////////////////////////////////////////////////////////////////////

//function frozenset(arr)
//  Создает неизменяемый массив без повторяющихся элементов
//
//  Параметры:
//      arr <array>,<fixedarray>
//
//  Возвращает:
//      <fixedarray>
//
function frozenset(arr) export
    if not check.is_array_or_fixedarray(arr) then
        raise exception.TypeError("argument 1 must be array or fixedarray",
                                  new Structure("arr",arr));
    endif;
    res=new Array();
    for each item in arr do
        if res.find(item)=undefined then
            res.add(item);
        endif;
    enddo;
    return array.freeze(res);
endfunction

/////////////////////////////////////////////////////////////////////////////

//function len(arr)
//  Возвращает количество элементов массива arr
//
//  Параметры:
//      arr <array>,<fixedarray>
//
//  Возвращает:
//      <number>
//
//  Описание:
//      Аналог arr.count()
//
function len(arr) export
    if not check.is_array_or_fixedarray(arr) then
        raise exception.TypeError("argument 1 must be array or fixedarray",
                                  new Structure("arr",arr));
    endif;
    return arr.count();
endfunction

/////////////////////////////////////////////////////////////////////////////

//function merge(arr1,arr2)
//  Создает новый массив из элементов двух массивов
//
//  Параметры:
//      arr1 <array>,<fixedarray>
//      arr2 <array>,<fixedarray>
//
//  Возвращает:
//      <array>
//
function merge(arr1,arr2) export
    if check.is_fixedarray(arr1) then
        arr1=array.update(new Array(),arr1);
    endif;
    if not check.is_array_or_fixedarray(arr1) then
        raise exception.TypeError("argument 1 must be array or fixedarray",
                                  new Structure("arr1,arr2",arr1,arr2));
    endif;
    if not check.is_array_or_fixedarray(arr2) then
        raise exception.TypeError("argument 2 must be array or fixedarray",
                                  new Structure("arr1,arr2",arr1,arr2));
    endif;
    res=new Array();
    for each item in arr1 do
        res.add(item);
    enddo;
    for each item in arr2 do
        res.add(item);
    enddo;
    return res;
endfunction

/////////////////////////////////////////////////////////////////////////////

//function min_n_max(arr)
//  Возвращает максимальный и минимальный элементы массива
//
//  Параметры:
//      arr <array>,<fixedarray>
//
//  Возвращает:
//      <array>
//
//  Описание:
//      Функция является доработаным вариантом идей отсюда:
//      http://habrahabr.ru/blogs/development/92303
//
function min_n_max(arr) export
    l=arr.ubound();
    i=0;min=0;max=0;
    if l=-1 then
        return pair(undefined,undefined);
    elsif l=0 then
        return pair(arr[min],arr[max]);
    else
        while i<l do
            if arr[i]<arr[i+1] then
                if arr[i]<arr[min]   then min=i; endif;
                if arr[i+1]>arr[max] then max=i+1; endif;
            else
                if arr[i+1]<arr[min] then min=i+1; endif;
                if arr[i]>arr[max]   then max=i; endif;
            endif;
            i=i+2;
        enddo;
        if i=l then
            if arr[i]<arr[min] then min=i; endif;
            if arr[i]>arr[max] then max=i; endif;
        endif;
        return pair(arr[min],arr[max]);
    endif;
endfunction

/////////////////////////////////////////////////////////////////////////////

//function pop(arr,start=undefined,end=undefined)
//  Удаляет и возвращает удаленный элемент/набор элементов из массива
//
//  Параметры:
//        arr <array>,<fixedarray>
//      start <undefined>,<number>
//        end <undefined>,<number>,<null>
//
//  Возвращает:
//      <any>,<array>
//
//  Описание:
//      С указанным аргументом start, вырезает элементы с этой позиции.
//      С указанным аргументом end, вырезает элементы по эту позицию.
//      start и end могут быть отрицательными для поиска c конца.
//
//      Для указания диапозона до конца end должен быть установлен в null.
//      По умолчанию, когда start и end undefined, вырезает последний элемент.
//
//      Если результатом выборки является один элемент, то он же и возвращается,
//      иначе возвращается массив вырезанных элементов.
//
function pop(arr,val start=undefined,val end=undefined) export
    if not check.is_array(arr) then
        msg="argument 1 must be array";
        raise exception.TypeError(msg,
                        new Structure("arr,start,end",arr,start,end));
    endif;
    if start<>undefined and not check.is_number(start) then
        msg="argument 2 must be number or undefined";
        raise exception.TypeError(msg,
                        new Structure("arr,start,end",arr,start,end));
    endif;
    if not (end=undefined or end=null) and not check.is_number(end) then
        msg="argument 3 must be number, undefined or null";
        raise exception.TypeError(msg,
                        new Structure("arr,start,end",arr,start,end));
    endif;
    len=arr.ubound();
    if start=undefined and end=undefined then
        start=len;
    elsif start=undefined then
        start=0;
    elsif start<0 then
        start=len+start+1;
        if start<0 then
            start=0;
        endif;
    endif;
    if end=undefined then
        if start>arr.ubound() then
            raise exception.IndexError(
                    "Index `start` is out of range",
                    new Structure("arr,start,end,ubound",
                                   arr,start,end,arr.ubound())
            );
        endif;
        v=arr[start];
        arr.delete(start);
        return v;
    elsif end=null then
        end=len;
    elsif end<0 then
        end=len+end;
    else
        end=end-start;
    endif;
    res=new Array();
    i=start;j=start;
    for i=start to end do
        if i>arr.ubound() or j>end then
            break;
        endif;
        res.add(arr[i]);
        arr.delete(i);
        i=i-1;j=j+1;
    enddo;
    return ?(res.count()=1,res[0],res);
endfunction

/////////////////////////////////////////////////////////////////////////////

//function reverse(arr)
//  Переставляет элементы массива в обратном порядке
//
//  Параметры:
//      arr <array>
//
//  Возвращает:
//      arr
//
function reverse(arr) export
    if not check.is_array(arr) then
        raise exception.TypeError("argument 1 must be array",
                                  new Structure("arr",arr));
    endif;
    len=arr.ubound();
    j=int(len/2);
    for i=0 to j do
        swap(arr[i],arr[len-i]);
    enddo;
    return arr;
endfunction

/////////////////////////////////////////////////////////////////////////////

//function slice(arr,start=0,end=undefined)
//  Возвращает произвольный набор элементов из массива
//
//  Параметры:
//        arr <array>,<fixedarray>
//      start <undefined>,<number>
//        end <undefined>,<number>,<null>
//
//  Возвращает:
//      <any>,<array>
//
//  Описание:
//      С указанным аргументом start, выбирает элементы с этой позиции.
//      С указанным аргументом end, выбирает элементы по эту позицию.
//      start и end могут быть отрицательными для поиска c конца.
//
//      Для указания диапозона до конца end должен быть установлен в null.
//      По умолчанию, когда start=0 и end=undefined, возвращает первый элемент.
//
//      Если результатом выборки является один элемент, то он же и возвращается,
//      иначе возвращается массив вырезанных элементов.
//
function slice(arr,val start=0,val end=undefined) export
    if not check.is_array_or_fixedarray(arr) then
        msg="argument 1 must be array or fixedarray";
        raise exception.TypeError(msg,
                        new Structure("arr,start,end",arr,start,end));
    endif;
    if not check.is_number(start) then
        msg="argument 2 must be number";
        raise exception.TypeError(msg,
                        new Structure("arr,start,end",arr,start,end));
    endif;
    if not (end=undefined or end=null) and not check.is_number(end) then
        msg="argument 3 must be number, undefined or null";
        raise exception.TypeError(msg,
                        new Structure("arr,start,end",arr,start,end));
    endif;
    len=arr.ubound();
    if start<0 then
        start=len+start+1;
        if start<0 then
            start=0;
        endif;
    endif;
    if end=undefined then
        if start>arr.ubound() then
            raise exception.IndexError(
                    "Index `start` is out of range",
                    new Structure("arr,start,end,ubound",
                                   arr,start,end,arr.ubound())
            );
        endif;
        return arr[start];
    elsif end=null then
        end=len;
    elsif end<0 then
        end=len+end;
    else
        end=end-start;
    endif;
    res=new Array();
    i=start;
    while i<=arr.ubound() or i<=end do
        res.add(arr[i]);
    enddo;
    return ?(res.count()=1,res[0],res);
endfunction

/////////////////////////////////////////////////////////////////////////////

//function sort(arr)
//  Сортирует переданный массив по возрастанию алгоритмом quicksort
//
//  Параметры:
//      arr <array>
//
//  Возвращает:
//      arr
//
function sort(arr,left=undefined,right=undefined) export
    if left=undefined then left=0; endif;
    if right=undefined then right=arr.ubound(); endif;
    if right>left then
        pivot_index=partition(arr,left,right);
        sort(arr,left,pivot_index-1);
        sort(arr,pivot_index+1,right);
    endif;
endfunction

function partition(a,p,r)
    x=a[r];
    j=p-1;
    for i=p to r-1 do
        if x>a[i] then
            j=j+1;
            swap(a[i],a[j]);
        endif;
    enddo;
    a[r]=a[j+1];
    a[j+1]=x;
    return j+1;
endfunction

/////////////////////////////////////////////////////////////////////////////

//function update(arr1,arr2)
//  Добавляет элементы массива arr2 в массив arr1
//
//  Параметры:
//      arr1 <array>
//      arr2 <array>,<fixedarray>
//
//  Возвращает:
//      arr1
//
function update(arr1,arr2) export
    if not check.is_array(arr1) then
        raise exception.TypeError("argument 1 must be array",
                                  new Structure("arr1,arr2",arr1,arr2));
    endif;
    if not check.is_array_or_fixedarray(arr2) then
        raise exception.TypeError("argument 2 must be array or fixedarray",
                                  new Structure("arr1,arr2",arr1,arr2));
    endif;
    for each item in arr2 do
        arr1.add(item);
    enddo;
    return arr1;
endfunction