/* -*- C++ -*- */

/*
   Copyright 2007 Deutsches Forschungszentrum fuer Kuenstliche Intelligenz 
   or its licensors, as applicable.
   
   You may not use this file except under the terms of the accompanying license.
   
   Licensed under the Apache License, Version 2.0 (the "License"); you
   may not use this file except in compliance with the License. You may
   obtain a copy of the License at http:  www.apache.org/licenses/LICENSE-2.0
   
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
   
   Project: 
   File: 
   Purpose: 
   Responsible: tmb
   Reviewer: 
   Primary Repository: 
   Web Sites: www.iupr.org, www.dfki.de
*/

/* we want array bounds checking etc. in this compilation unit */
// why? do we really want slow narray.copy() in Lua? --IM
$#undef UNSAFE

$#include <math.h>
$#include "colib.h"

$using namespace colib;

$ template<class T,class S>
$ void put(narray<T> *a,int i,S value) { a->at(i) = value; }
$ template<class T,class S>
$ void put(narray<T> *a,int i,int j,S value) { a->at(i,j) = value; }
$ template<class T,class S>
$ void put(narray<T> *a,int i,int j,int k,S value) { a->at(i,j,k) = value; }
$ template<class T,class S>
$ void put(narray<T> *a,int i,int j,int k,int l,S value) { a->at(i,j,k,l) = value; }

// narray functionality

class floatarray {
    floatarray();
    floatarray(int d0);
    floatarray(int d0,int d1);
    floatarray(int d0,int d1,int d2);
    floatarray(int d0,int d1,int d2,int d3);
    ~floatarray();
    void dealloc();
    void resize(int d0,int d1=0,int d2=0,int d3=0);
    void renew(int d0,int d1=0,int d2=0,int d3=0);
    void reshape(int d0,int d1=0,int d2=0,int d3=0);
    int rank() const;
    int dim(int i) const;
    float &at(int i0);
    float &at(int i0,int i1);
    float &at(int i0,int i1,int i2);
    float &at(int i0,int i1,int i2,int i3);
    int length1d() const;
    float &at1d(int i) const;
    void reserve(int n);
    void grow_to(int n);
    int length();
    void push(const float &value);
    void push(float &value);
    float &pop();
    float &last();
    void clear();
    tolua_outside void put(int,float);
    tolua_outside void put(int,int,float);
    tolua_outside void put(int,int,int,float);
    tolua_outside void put(int,int,int,int,float);
    void move(floatarray &);
    void swap(floatarray &);
    void copy(floatarray &);
    void copy(intarray &);
    void copy(bytearray &);
    void samedims(floatarray &);
    void makelike(floatarray &);
    void equal(floatarray &);
    void fill(float);
    void makelike(floatarray &,float);
};

class intarray {
    intarray();
    intarray(int d0);
    intarray(int d0,int d1);
    intarray(int d0,int d1,int d2);
    intarray(int d0,int d1,int d2,int d3);
    ~intarray();
    void dealloc();
    void resize(int d0,int d1=0,int d2=0,int d3=0);
    void renew(int d0,int d1=0,int d2=0,int d3=0);
    void reshape(int d0,int d1=0,int d2=0,int d3=0);
    int rank() const;
    int dim(int i) const;
    int &at(int i0);
    int &at(int i0,int i1);
    int &at(int i0,int i1,int i2);
    int &at(int i0,int i1,int i2,int i3);
    int length1d() const;
    int &at1d(int i) const;
    void reserve(int n);
    void grow_to(int n);
    int length();
    void push(const int &value);
    void push(int &value);
    int &pop();
    int &last();
    void clear();
    tolua_outside void put(int,int);
    tolua_outside void put(int,int,int);
    tolua_outside void put(int,int,int,int);
    tolua_outside void put(int,int,int,int,int);
    void move(intarray &);
    void swap(intarray &);
    void copy(floatarray &);
    void copy(intarray &);
    void copy(bytearray &);
    void samedims(intarray &);
    void makelike(intarray &);
    void equal(intarray &);
    void fill(int);
    void makelike(intarray &,int);
};

typedef unsigned char byte;

class bytearray {
    bytearray();
    bytearray(int d0);
    bytearray(int d0,int d1);
    bytearray(int d0,int d1,int d2);
    bytearray(int d0,int d1,int d2,int d3);
    ~bytearray();
    void dealloc();
    void resize(int d0,int d1=0,int d2=0,int d3=0);
    void renew(int d0,int d1=0,int d2=0,int d3=0);
    void reshape(int d0,int d1=0,int d2=0,int d3=0);
    int rank() const;
    int dim(int i) const;
    byte &at(int i0);
    byte &at(int i0,int i1);
    byte &at(int i0,int i1,int i2);
    byte &at(int i0,int i1,int i2,int i3);
    int length1d() const;
    byte &at1d(int i) const;
    void reserve(int n);
    void grow_to(int n);
    int length();
    void push(int value);
    byte &pop();
    byte &last();
    void clear();
    tolua_outside void put(int,int);
    tolua_outside void put(int,int,int);
    tolua_outside void put(int,int,int,int);
    tolua_outside void put(int,int,int,int,int);
    void move(bytearray &);
    void swap(bytearray &);
    void copy(floatarray &);
    void copy(intarray &);
    void copy(bytearray &);
    void samedims(bytearray &);
    void makelike(bytearray &);
    void equal(bytearray &);
    void fill(int);
    void makelike(bytearray &,int);
};

struct rectangle {
    int x0;
    int y0;
    int x1;
    int y1;
    rectangle();
    rectangle(const rectangle &r);
    rectangle(int x0,int y0,int x1,int y1);
    bool empty();
    int width();
    int height();
    void include(int x,int y);
    bool contains(int x,int y);
    void intersect(rectangle other);
    void include(rectangle other);
    rectangle intersection(rectangle other);
    rectangle inclusion(rectangle other);
    rectangle grow(int offset);
    int xcenter();
    int ycenter();
    void print();
    void println();
    int area();
    bool overlaps(const rectangle &other);
    bool includes(int x,int y);
    bool includes(float x,float y);
    bool includes(const rectangle &other);
    rectangle dilated_by(int dx0,int dy0,int dx1,int dy1);
    float aspect();
    float centricity(const rectangle &other);
    float fraction_covered_by(const rectangle &other);
};

class rectarray {
    rectarray();
    rectarray(int d0);
    rectarray(int d0,int d1);
    rectarray(int d0,int d1,int d2);
    rectarray(int d0,int d1,int d2,int d3);
    ~rectarray();
    void dealloc();
    void resize(int d0,int d1=0,int d2=0,int d3=0);
    void renew(int d0,int d1=0,int d2=0,int d3=0);
    void reshape(int d0,int d1=0,int d2=0,int d3=0);
    int rank() const;
    int dim(int i) const;
    rectangle &at(int i0);
    rectangle &at(int i0,int i1);
    rectangle &at(int i0,int i1,int i2);
    rectangle &at(int i0,int i1,int i2,int i3);
    int length1d() const;
    rectangle &at1d(int i) const;
    void reserve(int n);
    void grow_to(int n);
    int length();
    void push(const rectangle &value);
    void push(rectangle &value);
    rectangle &push();
    rectangle &pop();
    rectangle &last();
    void clear();
    void move(rectarray &);
    void swap(rectarray &);
    void copy(rectarray &);
    void samedims(rectarray &);
    void makelike(rectarray &);
    // void equal(rectarray &);
    void fill(rectangle);
    void makelike(rectarray &,rectangle);
};

struct nuchar {
    nuchar();
    nuchar(const nuchar &c);
    explicit nuchar(int x);
    int ord();
};

class nustring {
    nustring();
    nustring(int d0);
    nustring(const char *);
    ~nustring();
    void dealloc();
    void resize(int d0);
    void renew(int d0);
    void reshape(int d0);
    int length();
    int rank() const;
    int dim(int i) const;
    nuchar &at(int i0);
    nuchar &at1d(int i) const;
    void reserve(int n);
    void grow_to(int n);
    void push(const nuchar &value);
    void push(nuchar &value);
    nuchar &push();
    nuchar &pop();
    nuchar &last();
    void clear();
    int utf8Length();
    void utf8Decode @ decode(const char *s,int size=-1);
    char *mallocUtf8Encode @ utf8();
    //int length1d() const;
    //void utf8Encode(char *result,int size);
    //void utf8Encode(narray<char> &data);
    //void utf8Decode(narray<char> &data);
    //char *newUtf8Encode();
};


module narray {

    void move(floatarray &dest,floatarray &src);
    void copy(floatarray &dest,floatarray &src);
    bool samedims(floatarray &a,floatarray &b);
    void makelike(floatarray &a,floatarray &b);
    bool equal(floatarray &a,floatarray &b);
    void fill(floatarray &a,float value);

    void move(nustring &dest,nustring &src);
    void copy(nustring &dest,nustring &src);
    bool equal(nustring &a,nustring &b);

    void move(intarray &dest,intarray &src);
    void copy(intarray &dest,intarray &src);
    bool samedims(intarray &a,intarray &b);
    void makelike(intarray &a,intarray &b);
    bool equal(intarray &a,intarray &b);
    void fill(intarray &a,int value);

    void move(bytearray &dest,bytearray &src);
    void copy(bytearray &dest,bytearray &src);
    bool samedims(bytearray &a,bytearray &b);
    void makelike(bytearray &a,bytearray &b);
    bool equal(bytearray &a,bytearray &b);
    void fill(bytearray &a,byte value);

    void copy(floatarray &dest,bytearray &src);
    void copy(bytearray &dest,floatarray &src);
    void copy(intarray &dest,bytearray &src);
    void copy(bytearray &dest,intarray &src);
    void copy(floatarray &dest,intarray &src);
    void copy(intarray &dest,floatarray &src);

    void samedims(floatarray &dest,bytearray &src);
    void samedims(bytearray &dest,floatarray &src);
    void samedims(intarray &dest,bytearray &src);
    void samedims(bytearray &dest,intarray &src);
    void samedims(floatarray &dest,intarray &src);
    void samedims(intarray &dest,floatarray &src);

    void makelike(floatarray &dest,bytearray &src);
    void makelike(bytearray &dest,floatarray &src);
    void makelike(intarray &dest,bytearray &src);
    void makelike(bytearray &dest,intarray &src);
    void makelike(floatarray &dest,intarray &src);
    void makelike(intarray &dest,floatarray &src);

// narray-utils

    double dist2squared(floatarray &a,floatarray &b);
    double dist2(floatarray &a,floatarray &b);
    double norm2(floatarray &a);
    void normalize2(floatarray &a);
    void make_random(floatarray &v,int n,float scale);
    void perturb(floatarray &v,float scale);
    void make_unit_vector(floatarray &a,int n,int i);

    float max(floatarray &);
    float min(floatarray &);
    double sum(floatarray &);
    double product(floatarray &);
    int argmax(floatarray &);
    int argmin(floatarray &);
    void randomly_permute(floatarray &a);
    void iota(floatarray &v,int n);
    void add(floatarray &out,floatarray &v);

    int max(intarray &);
    int min(intarray &);
    double sum(intarray &);
    double product(intarray &);
    int argmax(intarray &);
    int argmin(intarray &);
    void randomly_permute(intarray &a);
    void iota(intarray &v,int n);
    void add(intarray &out,intarray &v);

    int max(bytearray &);
    int min(bytearray &);
    double sum(bytearray &);
    double product(bytearray &);
    int argmax(bytearray &);
    int argmin(bytearray &);
    void randomly_permute(bytearray &a);
    void iota(bytearray &v,int n);
    void add(bytearray &out,bytearray &v);

// quicksort

    void quicksort(intarray &values);

// rectangles

    void reverse(intarray &,intarray &);
    void reverse(intarray &);
    void reverse(floatarray &,floatarray &);
    void reverse(floatarray &);
    void reverse(bytearray &,bytearray &);
    void reverse(bytearray &);
    void remove_left(floatarray &,int);
    void remove_left(intarray &,int);
    void remove_left(bytearray &,int);

    int rowcompare(floatarray &values,int i,int j);
    void rowswap(floatarray &values,int i,int j);
    void rowcopy(floatarray &values,int i,int j);
    void rowcopy(floatarray &a,int i,floatarray &b);
    void rowcopy(floatarray &a,floatarray &b,int i);
    bool rowsorted(floatarray &data);
    bool rowsorted(floatarray &data,intarray &permutation);
    void check_rowsorted(floatarray &data);
    void check_rowsorted(floatarray &data,intarray &permutation);
    void rowsort(intarray &index,floatarray &values,int start,int end);
    void rowsort(intarray &index,floatarray &values);
    void rowpermute(floatarray &data,intarray &permutation);
    void rowsort(floatarray &data);
    void rowpush(floatarray &table,floatarray &data);

    int rowcompare(intarray &values,int i,int j);
    void rowswap(intarray &values,int i,int j);
    void rowcopy(intarray &values,int i,int j);
    void rowcopy(intarray &a,int i,intarray &b);
    void rowcopy(intarray &a,intarray &b,int i);
    void check_rowsorted(intarray &data);
    void check_rowsorted(intarray &data,intarray &permutation);
    bool rowsorted(intarray &data);
    bool rowsorted(intarray &data,intarray &permutation);
    void rowsort(intarray &index,intarray &values,int start,int end);
    void rowsort(intarray &index,intarray &values);
    void rowpermute(intarray &data,intarray &permutation);
    void rowsort(intarray &data);
    void rowpush(intarray &table,intarray &data);

    int rowcompare(bytearray &values,int i,int j);
    void rowswap(bytearray &values,int i,int j);
    void rowcopy(bytearray &values,int i,int j);
    void rowcopy(bytearray &a,int i,bytearray &b);
    void rowcopy(bytearray &a,bytearray &b,int i);
    void check_rowsorted(bytearray &data);
    void check_rowsorted(bytearray &data,intarray &permutation);
    bool rowsorted(bytearray &data);
    bool rowsorted(bytearray &data,intarray &permutation);
    void rowsort(intarray &index,bytearray &values,int start,int end);
    void rowsort(intarray &index,bytearray &values);
    void rowpermute(bytearray &data,intarray &permutation);
    void rowsort(bytearray &data);
    void rowpush(bytearray &table,bytearray &data);

$using namespace narray_ops;

    void abs(bytearray &out);
    void max(bytearray &out,int in);
    void min(bytearray &out,int in);
    void add(bytearray &out,int in);
    void sub(bytearray &out,int in);
    void sub(int in,bytearray &out);
    void mul(bytearray &out,int in);
    void div(bytearray &out,int in);
    void max(bytearray &out,bytearray &in);
    void min(bytearray &out,bytearray &in);
    void add(bytearray &out,bytearray &in);
    void sub(bytearray &out,bytearray &in);
    void mul(bytearray &out,bytearray &in);
    void div(bytearray &out,bytearray &in);
    void add(bytearray &out,bytearray &in1,bytearray &in2);
    void sub(bytearray &out,bytearray &in1,bytearray &in2);
    void mul(bytearray &out,bytearray &in1,bytearray &in2);
    void div(bytearray &out,bytearray &in1,bytearray &in2);
    void greater(bytearray &out,int in,int no,int yes);
    void less(bytearray &out,int in,int no,int yes);

    void abs(intarray &out);
    void max(intarray &out,int in);
    void min(intarray &out,int in);
    void add(intarray &out,int in);
    void sub(intarray &out,int in);
    void sub(int in,intarray &out);
    void mul(intarray &out,int in);
    void div(intarray &out,int in);
    void max(intarray &out,intarray &in);
    void min(intarray &out,intarray &in);
    void add(intarray &out,intarray &in);
    void sub(intarray &out,intarray &in);
    void mul(intarray &out,intarray &in);
    void div(intarray &out,intarray &in);
    void add(intarray &out,intarray &in1,intarray &in2);
    void sub(intarray &out,intarray &in1,intarray &in2);
    void mul(intarray &out,intarray &in1,intarray &in2);
    void div(intarray &out,intarray &in1,intarray &in2);
    void greater(intarray &out,int in,int no,int yes);
    void less(intarray &out,int in,int no,int yes);

    void abs(floatarray &out);
    void exp(floatarray &out);
    void log(floatarray &out);
    void sin(floatarray &out);
    void cos(floatarray &out);
    void max(floatarray &out,float in);
    void min(floatarray &out,float in);
    void add(floatarray &out,float in);
    void sub(floatarray &out,float in);
    void sub(float in,floatarray &out);
    void mul(floatarray &out,float in);
    void div(floatarray &out,float in);
    void pow(floatarray &out,float in);
    void max(floatarray &out,floatarray &in);
    void min(floatarray &out,floatarray &in);
    void add(floatarray &out,floatarray &in);
    void sub(floatarray &out,floatarray &in);
    void mul(floatarray &out,floatarray &in);
    void div(floatarray &out,floatarray &in);
    void pow(floatarray &out,floatarray &in);
    void add(floatarray &out,floatarray &in1,floatarray &in2);
    void sub(floatarray &out,floatarray &in1,floatarray &in2);
    void mul(floatarray &out,floatarray &in1,floatarray &in2);
    void div(floatarray &out,floatarray &in1,floatarray &in2);
    void pow(floatarray &out,floatarray &in1,floatarray &in2);
    void greater(floatarray &out,float in,float no,float yes);
    void less(floatarray &out,float in,float no,float yes);

    void max(floatarray &out,bytearray &in);
    void min(floatarray &out,bytearray &in);
    void add(floatarray &out,bytearray &in);
    void sub(floatarray &out,bytearray &in);
    void mul(floatarray &out,bytearray &in);
    void div(floatarray &out,bytearray &in);
    void pow(floatarray &out,bytearray &in);
    void add(floatarray &out,bytearray &in1,bytearray &in2);
    void sub(floatarray &out,bytearray &in1,bytearray &in2);
    void mul(floatarray &out,bytearray &in1,bytearray &in2);
    void div(floatarray &out,bytearray &in1,bytearray &in2);
    void pow(floatarray &out,bytearray &in1,bytearray &in2);
}