VectorField.h

Go to the documentation of this file.

#ifndef VectorField_H
#define VectorField_H

#include <iostream>
#include <fstream>
#include "algorithms/ls/Vector.h"

namespace algorithms{
namespace ls{

template<int V, int D, typename T=double>
class VectorField {

public:
        int elements;

private:
        Vector<V, T>* f;
        Vector<D, int> size;           // number of grid points for each dimension
        Vector<D, int> offset;

public:
        VectorField();
        VectorField(const Vector<D, int>&);
        ~VectorField();
        Vector<D, int> get_size() const;
        void set_size(const Vector<D, int>&);
        Vector<V, T>& get(const Vector<D, int>&);
        void read(std::ifstream&);
        void write(std::ofstream&) const;
        static void swap(VectorField<V, D, T>&, VectorField<V, D, T>&);
};


template<int V, int D, typename T>
VectorField<V, D, T>::VectorField()
: f(0), elements(0)
  {
  }


template<int V, int D, typename T>
VectorField<V, D, T>::VectorField(const Vector<D, int>& s)inline
: f(0)
  {
        set_size(s);
  }


template <int V, int D, typename T>
VectorField<V, D, T>::~VectorField()
{
        if(f != 0)
                delete[] f;
}

template<int V, int D, typename T>
inline Vector<D, int> VectorField<V, D, T>::get_size() const
{
        return size;
}

template<int V, int D, typename T>
void VectorField<V, D, T>::set_size(const Vector<D, int>& s)
{
        if(f != 0)
                delete[] f;

        size = s;

        elements = 1;
        for(int i=0; i<D; i++) {
                offset[i] = elements;
                elements *= size.x[i];
        }

        f = new Vector<V, T>[elements];
}

template<int V, int D, typename T>
inline Vector<V, T>& VectorField<V, D, T>::get(const Vector<D, int>& pos)
{
        int p=0;
        for(int i=0; i<D; i++)
                p += pos.x[i]*offset[i];

        return f[p];
}


template<int V, int D, typename T>
void VectorField<V, D, T>::read(std::ifstream& in)
{
        in.read((char*)f, elements*sizeof(T)*V);
}


template<int V, int D, typename T>
void VectorField<V, D, T>::write(std::ofstream& out) const
{
        out.write((const char*)f, elements*sizeof(T)*V);
}

template<int V, int D, typename T>
void VectorField<V, D, T>::swap(VectorField<V, D, T>& v1,
                VectorField<V, D, T>& v2)
                {
        Vector<V, T>* f;

        f = v1.f;
        v1.f = v2.f;
        v2.f = f;
                }

}/* close namespace ls */
}/* close namespace algorithms */
#endif