meowpp/math/Transformation.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#ifndef   math_Transformation_H__
#define   math_Transformation_H__

#include "Matrix.h"

#include <cstdlib>

namespace meow{
  template<class Scalar>
  class Transformation{
    private:
      size_t  _inputRows;
      size_t  _inputCols;
      size_t _outputRows;
      size_t _outputCols;
      size_t _psize;
    protected:
      Transformation(size_t  __inputRows, size_t  __inputCols,
                     size_t __outputRows, size_t __outputCols,
                     size_t __psize):
      _inputRows (__inputRows),
      _inputCols (__inputCols),
      _outputRows(__outputRows),
      _outputCols(__outputCols),
      _psize(__psize){
      }
    public:
      virtual Transformation(){ }
      
      size_t     inputRows() const{ return  _inputRows; }
      size_t     inputCols() const{ return  _inputCols; }
      size_t    outputRows() const{ return _outputRows; }
      size_t    outputCols() const{ return _outputCols; }
      size_t parameterSize() const{ return _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 = 0;
      virtual Matrix<Scalar> jacobian    (Matrix<Scalar> const& __x,
                                          size_t                __i) const = 0;
      
      virtual bool inversable() const{ return false; }
      
      virtual Matrix<Scalar> invTransformate(Matrix<Scalar> const& __x) const{
        return Matrix<Scalar>();
      }
      virtual Matrix<Scalar> invJacobian(Matrix<Scalar> const& __x) const{
        return Matrix<Scalar>();
      }
      virtual Matrix<Scalar> invJacobian(Matrix<Scalar> const& __x,
                                         size_t                __i) const{
        return Matrix<Scalar>();
      }
  };
}

#endif // math_Transformation_H__