---

Array.h

Go to the documentation of this file.

/* WARANTY NOTICE AND COPYRIGHT
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

Copyright (C) Michael J. Meyer

matmjm@mindspring.com
spyqqqdia@yahoo.com

*/

#ifndef martingale_array_h    
#define martingale_array_h
// #define SUBSCRIPT_CHECK              // enable to check for subscript out of range error                     

#include "TypedefsMacros.h"
#include <cstdlib>                       // for exit()
#include <string>

MTGL_BEGIN_NAMESPACE(Martingale)



/***************************************************************************************
 *
 *           SUBSCRIPT CHECKING
 *
 **************************************************************************************/

// linker errors if this is a namespace instead of a struct. Why????
struct SubscriptCheck {

static void checkSubscript(int i, int b1, int n1, string str)
{
        if((i<b1)||(i>b1+n1-1)){
                
            cout << "\n\nSubscript out of range: " << str 
                 << "\ni = " << i << " not in [" << b1 << ", " << b1+n1-1 << "]"
                     << "\n index base = " << b1 << ", dimension = " << n1
                 << "\nTerminating.";
            exit(0);
        }
} // end checkSubscript


static void checkSubscript(int i, int j, int b1, int b2, int n1, int n2, string str)
{
        if((i<b1)||(i>b1+n1-1)){ 
                
            cout << "\n\nSubscript out of range: " << str 
                 << "\ni = " << i << " not in [" << b1 << ", " << b1+n1-1 << "]"
                     << "\n index base = " << b1 << ", rows = " << n1
                     << "\nTerminating.";
                exit(0);
        }
                
        
        if((j<b2)||(j>b2+n2-1)){
                
            cout << "\n\n Subscript out of range: " << str 
                 << "\nj = " << j << " not in [" << b2 << ", " << b2+n2-1 << "]"
                     << "\n index base = " << b2 << ", cols = " << n2
                 << "\nTerminating.";
            exit(0);
        }
} // end checkSubscript



static void checkSubscript
(int i, int j, int k, int b1, int b2, int b3, int n1, int n2, int n3, string str)
{
        if((i<b1)||(i>b1+n1-1)){ 
                
            cout << "\n\nSubscript out of range: " << str 
                 << "\ni = " << i << " not in [" << b1 << ", " << b1+n1-1 << "]"
                     << "\nTerminating.";
                exit(0);
        }
                
        
        if((j<b2)||(j>b2+n2-1)){
                
            cout << "\n\n Subscript out of range: " << str 
                 << "\nj = " << j << " not in [" << b2 << ", " << b2+n2-1 << "]"
                 << "\nTerminating.";
            exit(0);
        }
        
        
        if((k<b3)||(k>b3+n3-1)){
                
            cout << "\n\n Subscript out of range: " << str 
                 << "\nj = " << k << " not in [" << b3 << ", " << b3+n3-1 << "]"
                 << "\nTerminating.";
            exit(0);
        }
} // end checkSubscript


}; // end SubscriptCheck




/**********************************************************************************
 *
 *         1 DIMENSIONAL   ARRAY
 *
 *********************************************************************************/


template<typename S>
class Array1D {
        
protected:
        
        int b;
        int n;         
                                
        S* dptr;

        
public:
        

// ACCESSORS

    int getIndexBase() const { return b; }
        
        void setIndexBase(int base){ b=base; }
                
        int getDimension() const { return n; }
        
        void setDimension(int q) { n=q; }
        
        S* getData() const { return dptr; }

        
// CONSTRUCTOR
        
        explicit Array1D(int n_, int b_=0) : 
        b(b_), n(n_) 
        {  
         dptr=new S[n];
                 for(int i=0;i<n;i++) dptr[i]=0;
        } 
        
        
        Array1D(const Array1D& x) : 
        b(x.getIndexBase()), 
        n(x.getDimension()) 
        {  
         dptr=new S[n];
                 S* xdptr=x.getData();
                 for(int i=0;i<n;i++) dptr[i]=xdptr[i];
        } 

        
        ~Array1D(){ delete[] dptr; }
        
   const S& operator[](int i) const 
   { 
           #ifdef SUBSCRIPT_CHECK
              SubscriptCheck::
	      checkSubscript(i,b,n,"Array1D");
           #endif       
           return dptr[i-b]; 
   }
   
   S& operator[](int i)  
   { 
           #ifdef SUBSCRIPT_CHECK
              SubscriptCheck::
	      checkSubscript(i,b,n,"Array1D");
           #endif       
           return dptr[i-b];
   }
   
   Array1D<S>& operator=(const Array1D<S>& B)
   {
           S* dptrB=B.getData();
           for(int j=0;j<n;j++) dptr[j]=dptrB[j];
           b=B.getIndexBase();  
           
           return *this;
   }
   
// EUCLLIDEAN NORM, SCALING
   
    Real norm() const
    {
        Real u=0;
        for(int i=0;i<n;i++) u+=dptr[i]*dptr[i];
        return sqrt(u);
    }
        
        Array1D& scale(S f)
    {
        for(int i=0;i<n;i++) dptr[i]*=f;
        return *this;
    }  
        
        S dotProduct(Array1D<S>& X) const
    {
                Real* a=dptr;
                Real* x=X.getData();
                Real sum=0.0;
                for(int j=0;j<n;j++) sum+=a[j]*x[j];
                        
                return sum;
    }
        
        std::ostream& printSelf(std::ostream& os) const
    {
             os << endl << "Array1D of dimension " << n << ":" << endl;
         for(int i=0;i<n-1;i++) os << dptr[i] << ", ";
         return os << dptr[n-1] << endl << endl;
    } 
                         
                   
}; // end Array1D



/**********************************************************************************
 *
 *         2 DIMENSIONAL   ARRAY
 *
 *********************************************************************************/


template<typename S>
class Array2D {
        
protected:
        
        int b1,b2;
        int n1,n2;         
                                
        S** dptr;

        
public:
        

// ACCESSORS

    int getIndexBase(int j) const 
    {
                switch(j){
                        
                        case 1 : return b1;
                        case 2 : return b2;
                }
        } // end getIndexBase
        
        int getSize(int j) const 
    {
                switch(j){
                        
                        case 1 : return n1;
                        case 2 : return n2;
                }
        } // end getIndexBase

        
// CONSTRUCTOR
        
        Array2D(int n_1, int n_2, int b_1=0, int b_2=0) :
        b1(b_1), b2(b_2),
        n1(n_1), n2(n_2) 
        {  
         dptr=new S*[n_1];
                 for(int i=0;i<n1;i++){
                         
                         dptr[i]=new S[n2];
                         for(int j=0;j<n2;j++)dptr[i][j]=0;
                 }
        } // end constructor

        
        ~Array2D()
    {
                 for(int i=0;i<n1;i++) delete[] dptr[i];
                 delete[] dptr;
        }
        
   const S& operator()(int i, int j) const 
   { 
           #ifdef SUBSCRIPT_CHECK
              SubscriptCheck::
	      checkSubscript(i,j,b1,b2,n1,n2,"Array2D");
           #endif       
           return dptr[i-b1][j-b2]; 
   }
   
   S& operator()(int i, int j) 
   { 
           #ifdef SUBSCRIPT_CHECK
              SubscriptCheck::
	      checkSubscript(i,j,b1,b2,n1,n2,"Array2D");
           #endif       
           return dptr[i-b1][j-b2]; 
   }
                         
   S* operator[](int i)  
   { 
           #ifdef SUBSCRIPT_CHECK
              SubscriptCheck::
	      checkSubscript(i,b1,n1,"Array2D, row i");
           #endif       
           return dptr[i-b1];
   }
   
   std::ostream& printSelf(std::ostream& os) const
   {
            os << endl << "Rectangular " << n1 << " by " << n2 << " array:"
               << endl << endl;
            for(int i=0;i<n1;i++){
                
                for(int j=0;j<n2-1;j++) os << dptr[i][j] << ", ";
                    os << dptr[i][n2-1] << endl;
            }
        return os << endl << endl;
        }
                                

}; // end Array2D




             


/**********************************************************************************
 *
 *         3 DIMENSIONAL   ARRAY
 *
 *********************************************************************************/


template<typename S>
class Array3D {
        
protected:
        
        int b1,b2,b3;
        int n1,n2,n3;         
                                
        S*** dptr;

        
public:
        

// ACCESSORS

    int getIndexBase(int j) const 
    {
                switch(j){
                        
                        case 1 : return b1;
                        case 2 : return b2;
                        case 3 : return b3;
                }
        } // end getIndexBase
        
        int getSize(int j) const 
    {
                switch(j){
                        
                        case 1 : return n1;
                        case 2 : return n2;
                        case 3 : return n3;
                }
        } // end getIndexBase

        
// CONSTRUCTOR
        
        Array3D(int n_1, int n_2, int n_3, int b_1=0, int b_2=0, int b_3=0) : 
        b1(b_1), b2(b_2), b3(b_3),
        n1(n_1), n2(n_2), n3(n_3)
        {  
         dptr=new S**[n_1];
                 for(int i=0;i<n1;i++){
                         
                         dptr[i]=new S*[n2];
                         for(int j=0;j<n2;j++){
                                 
                                 dptr[i][j]=new S[n3];
                                 for(int k=0;k<n3;k++) dptr[i][j][k]=0;
                        }
                }
        } // end constructor
        
        ~Array3D()
    {
                 for(int i=0;i<n1;i++){
                         
                         for(int j=0;j<n2;j++) delete[] dptr[i][j];
                         delete[] dptr[i];
                }
                delete[] dptr;
        }
        
   const S& operator()(int i, int j, int k) const 
   { 
           #ifdef SUBSCRIPT_CHECK
              SubscriptCheck::
	      checkSubscript(i,j,k,b1,b2,b3,n1,n2,n3,"Array3D");
           #endif       
           return dptr[i-b1][j-b2][k-b3]; 
   }
   
   S& operator()(int i, int j, int k) 
   { 
           #ifdef SUBSCRIPT_CHECK
              SubscriptCheck::
	      checkSubscript(i,j,k,b1,b2,b3,n1,n2,n3,"Array3D");
           #endif       
           return dptr[i-b1][j-b2][k-b3]; 
   }
                         
                   
                                

}; // end Array3D




typedef Array1D<Real> RealArray1D;
typedef Array2D<Real> RealArray2D;
typedef Array3D<Real> RealArray3D;

typedef Array1D<int> IntArray1D;
typedef Array2D<int> IntArray2D;
typedef Array3D<int> IntArray3D;

typedef Array1D<long> LongArray1D;
typedef Array2D<long> LongArray2D;

typedef Array1D<unsigned long> UnsignedLongArray1D;
typedef Array2D<unsigned long> UnsignedLongArray2D;






/**********************************************************************************
 *
 *         LIBOR  ARRAY
 *
 *********************************************************************************/


template<typename S>
class LiborArray2D {
        
protected:
        
        int n;  
        
        int nSteps;   
                                
        S** dptr;

        
public:
        

        
// CONSTRUCTOR
        
        LiborArray2D(int dim, int steps) : 
        n(dim), nSteps(steps)
        {  
         dptr=new S*[n*nSteps];
                 for(int t=0;t<n-1;t++)
                 for(int u=0;u<nSteps;u++){
                         
                    int s=t*nSteps+u;             // number of time step         
                    dptr[s]=new S[n-t-1];
                        for(int j=0;j<n-t-1;j++)dptr[s][j]=0;
                 }
        } // end constructor

        
        ~LiborArray2D()
    {
                 for(int t=0;t<n-1;t++)
                 for(int u=0;u<nSteps;u++) delete[] dptr[t*nSteps+u];
                 delete[] dptr;
        }
        
   const S& operator()(int s, int j) const 
   { 
           #ifdef SUBSCRIPT_CHECK
              checkSubscripts(s,j);
           #endif       
           return dptr[s][j-1-s/nSteps]; 
   }
   
   S& operator()(int s, int j) 
   { 
           #ifdef SUBSCRIPT_CHECK
              checkSubscripts(s,j);
           #endif       
           return dptr[s][j-1-s/nSteps]; 
   }
   
private:
   
   // time step s lands in the accrual interval (T_{t-1},T_t].
   int get_t(int s)
   {
           if(s%nSteps==0) return s/nSteps;
           return s/nSteps+1;
   }
   
   void checkSubscripts(int s, int j)
   {
           if((s<0)||(s>n*nSteps-1)){
                   
                   cout << "\n\nLiborArray2D: time step s = " << s 
                        << " not in [0," << n*nSteps-1 << "]"
                        << "\nTerminating.";
                   exit(0);
           }
           
           int t=get_t(s);
           if((j<t)||(j>n-1)){
                   
                   cout << "\n\nLiborArray2D: time step s = " << s << ", t = " << t
                   
                        << "\nLibor index j = " << j << " not in ["<<t<<","<<n-1<<"]"
                        << "\nTerminating.";
                   exit(0);
           }
   } // end checkSubscript
                   
                                

}; // end LiborArray2D




        
        



MTGL_END_NAMESPACE(Martingale)

#endif
 

---