NDDArray.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGNDDArray_HH_
#define _MGNDDArray_HH_

#include "mg/MGCL.h"

// MGNDDArray.h
//

// Forward Declaration
class MGBPointSeq;
class MGKnotVector;
class MGKnot;
class MGIfstream;
class MGOfstream;


class MG_DLL_DECLR MGNDDArray{

public:

MG_DLL_DECLR friend MGNDDArray operator* (double scale, const MGNDDArray& nd);

MG_DLL_DECLR friend std::ostream& operator<< (std::ostream&, const MGNDDArray&);


MGNDDArray():m_capacity(0),m_length(0),m_current(0),m_element(0){;}; 

explicit MGNDDArray(
    int n,      
    const double* data=0
);

MGNDDArray(int n, double init, double increment=1.0);

explicit MGNDDArray(const MGBPointSeq&);

MGNDDArray(MGENDCOND begin, MGENDCOND end, const MGBPointSeq&);

MGNDDArray(MGENDCOND begin, MGENDCOND end, const MGKnotVector& t);

MGNDDArray(const MGNDDArray&, int nnew);

MGNDDArray(const MGNDDArray&, double ts, double te);

MGNDDArray(
    int start_id,           
    int num,                    
    const MGNDDArray& array2    
);

MGNDDArray(
    int id1,            
    int num1,       
    const MGNDDArray& array1,
    int id2,            
    int num2,       
    const MGNDDArray& array2
);

MGNDDArray(const MGNDDArray& nd);

virtual ~MGNDDArray(){if(m_element) delete[] m_element;};

    
double operator[] (int i) const{return m_element[i];};
double operator() (int i) const{return m_element[i];};

double& operator[] (int i){return m_element[i];};
double& operator() (int i){return m_element[i];};

MGNDDArray& operator= (const MGNDDArray& vec2);

MGNDDArray operator+(double) const;
MGNDDArray& operator+=(double);
MGNDDArray operator-(double) const;
MGNDDArray& operator-=(double);

MGNDDArray operator-() const;

MGNDDArray operator*(double scale) const;
MGNDDArray& operator*= (double scale);

bool operator== (const MGNDDArray& t2) const;
bool operator!= (const MGNDDArray& t2) const{return !operator==(t2);}


int add_data(double value, int mult_max=1);

int add_data(const MGKnot& knot, int mult_max);

void copy_removing_multi(
    int start_id,           
    int num,                    
    const MGNDDArray& array2    
);

const double* data(int i=0) const{ return &m_element[i]; };

double* data(int i=0) { return &m_element[i]; };

int del_data(int index);

bool is_null()const{return m_length==0;};

int length() const{ return m_length; };

void set_length(int length);

virtual void set_null();

void store_with_capacityCheck(
    int i,  
    double data
);

virtual int locate(double tau) const;

virtual int locate_multi(int start, int multi, int& index) const;

virtual void change_range(double ts, double te);

MGNDDArray& change_number(int nnew);

double ref(int i) const{ return m_element[i];};

void remove_too_near(
    bool allow_multi=false, 
    double ratio=6. 
);

void remove_too_near(
    MGBPointSeq& ordinates, 
    bool allow_multi=false, 
    double ratio=6. 
);

void reshape(int size, int start=0);

void resize(int nsize);

int capacity() const { return m_capacity; };

MGNDDArray& update_from_knot(const MGKnotVector& t);

virtual int dump_size() const;

virtual int dump(MGOfstream&)const;

virtual int restore(MGIfstream& );
    
protected:
    mutable int m_current;

private:
    int m_capacity; 
    int m_length;   
    double* m_element;

};
 // end of BASE group
#endif