Transformation.h

Go to the documentation of this file.

#ifndef   math_Transformation_H__
#define   math_Transformation_H__

#include "Matrix.h"
#include "../Self.h"

#include <list>
#include <cstdlib>

namespace meow {

template<class Scalar>
class Transformation {
private:
  struct Myself {
    size_t  inputRows_;
    size_t  inputCols_;
    size_t outputRows_;
    size_t outputCols_;
    size_t      psize_;

    Myself(Myself const& b):
    inputRows_(b.inputRows_), inputCols_(b.inputCols_),
    outputRows_(b.outputRows_), outputCols_(b.outputCols_),
    psize_(b.psize_) {
    }

    Myself(size_t ir, size_t ic, size_t or_, size_t oc, size_t ps):
    inputRows_(ir), inputCols_(ic), outputRows_(or_), outputCols_(oc),
    psize_(ps) {
    }

    ~Myself() {
    }
  };

  Self<Myself> const self;
protected:
  Transformation(size_t  inputRows, size_t  inputCols,
                 size_t outputRows, size_t outputCols,
                 size_t psize):
  self(Myself(inputRows, inputCols, outputRows, outputCols, psize)) {
  }

  Transformation(Transformation const& b):
  self(b.self, Self<Myself>::COPY_FROM) {
  }

  Transformation& copyFrom(Transformation const& b) {
    self().copyFrom(b.self);
    return *this;
  }

  Transformation& referenceFrom(Transformation const& b) {
    self().referenceFrom(b.self);
    return *this;
  }
public:
  virtual ~Transformation() {
  }

  size_t inputRows() const {
    return self->inputRows_;
  }

  size_t inputCols() const {
    return self->inputCols_;
  }

  size_t outputRows() const {
    return self->outputRows_;
  }

  size_t outputCols() const {
    return self->outputCols_;
  }

  size_t parameterSize() const {
    return self->psize_;
  }

  virtual Scalar parameter(size_t i) const = 0;

  virtual Scalar parameter(size_t i, Scalar const& s) = 0;

  virtual Matrix<Scalar> transformate(Matrix<Scalar> const& x) const = 0;

  virtual Matrix<Scalar> jacobian(Matrix<Scalar> const& x) const {
    return Matrix<Scalar>();
  }

  virtual Matrix<Scalar> jacobian(Matrix<Scalar> const& x, size_t i) const {
    return Matrix<Scalar>();
  }

  virtual bool inversable() const { return false; }

  virtual Matrix<Scalar> transformateInv(Matrix<Scalar> const& x) const {
    return Matrix<Scalar>();
  }

  virtual Matrix<Scalar> jacobianInv(Matrix<Scalar> const& x) const {
    return Matrix<Scalar>();
  }

  virtual Matrix<Scalar> jacobianInv(Matrix<Scalar> const& x, size_t i) const {
    return Matrix<Scalar>();
  }
};

} // meow

#endif // math_Transformation_H__