AbstractFunction.h 3.68 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/******************************************************************************
 *
 * AMDiS - Adaptive multidimensional simulations
 *
 * Copyright (C) 2013 Dresden University of Technology. All Rights Reserved.
 * Web: https://fusionforge.zih.tu-dresden.de/projects/amdis
 *
 * Authors: 
 * Simon Vey, Thomas Witkowski, Andreas Naumann, Simon Praetorius, et al.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * This file is part of AMDiS
 *
 * See also license.opensource.txt in the distribution.
 * 
 ******************************************************************************/
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

/** \file AbstractFunction.h */

#ifndef AMDIS_ABSTRACTFUNCTION_H
#define AMDIS_ABSTRACTFUNCTION_H

#include "Global.h"

namespace AMDiS {

  /** 
   * \ingroup Common
   * 
   * \brief
   * An AbstractFunction object represents a function 
   * f : ArgumentType -> ReturnType. 
   *
   * AbstractFunction is a pure virtual class interface class.
   * To create your own function you have to derive AbstractFunction and
   * overload operator(). 
   */
  template<typename ReturnType, typename ArgumentType>
  class AbstractFunction
  {
  public:
47
    /// Constructor.
48
49
    AbstractFunction(int degree = 0) : 
      degree_(degree) 
Thomas Witkowski's avatar
Thomas Witkowski committed
50
    {}
51

Thomas Witkowski's avatar
Thomas Witkowski committed
52
    virtual ~AbstractFunction() {}
53

54
    /// Returns \ref degree_.
Thomas Witkowski's avatar
Thomas Witkowski committed
55
56
    inline int getDegree() const 
    { 
57
      return degree_; 
Thomas Witkowski's avatar
Thomas Witkowski committed
58
    }
59

60
    /// Deligates the evaluation to overriden method f.
61
    virtual ReturnType operator()(const ArgumentType& x) const = 0;
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

  protected:
    int degree_;
  };

  /**
   * \ingroup Common
   *
   * \brief
   * Interface for binary functions. 
   */
  template<typename ReturnType, 
	   typename ArgumentType1, 
	   typename ArgumentType2>
  class BinaryAbstractFunction
  {
  public:
79
    /// Constructor.
80
81
    BinaryAbstractFunction(int degree = 0) : 
      degree_(degree) 
82
    {}
83

84
    virtual ~BinaryAbstractFunction() {}
85

86
    /// Returns \ref degree_.
Thomas Witkowski's avatar
Thomas Witkowski committed
87
88
    inline int getDegree() const 
    { 
89
      return degree_; 
90
    }
91

92
    /// Deligates the evaluation to overriden method f.
93
94
    virtual ReturnType operator()(const ArgumentType1& x,
				  const ArgumentType2& y) const = 0;
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

  protected:
    int degree_;
  };

  /**
   * \ingroup Common
   *
   * \brief
   * Interface for tertiary functions. 
   */
  template<typename ReturnType, 
	   typename ArgumentType1, 
	   typename ArgumentType2,
	   typename ArgumentType3>
  class TertiaryAbstractFunction
  {
  public:
113
    /// Constructor.
114
115
    TertiaryAbstractFunction(int degree = 0) : 
      degree_(degree) 
116
    {}
117

118
    virtual ~TertiaryAbstractFunction() {}
119

120
    /// Returns \ref degree_.
Thomas Witkowski's avatar
Thomas Witkowski committed
121
122
    inline int getDegree() const 
    { 
123
      return degree_; 
124
    }
125

126
    /// function evaluation.
127
128
129
    virtual ReturnType operator()(const ArgumentType1& x,
				  const ArgumentType2& y,
				  const ArgumentType3& z) const = 0;
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

  protected:
    int degree_;
  };

  /**
   * \ingroup Common
   *
   * \brief
   * Interface for quart functions. 
   */
  template<typename ReturnType, 
	   typename ArgumentType1, 
	   typename ArgumentType2, 
	   typename ArgumentType3,
	   typename ArgumentType4>
  class QuartAbstractFunction
  {
  public:
149
    /// Constructor.
150
151
    QuartAbstractFunction(int degree = 0) : 
      degree_(degree) 
152
    {}
153

154
    virtual ~QuartAbstractFunction() {}
155

156
    /// Returns \ref degree_.
Thomas Witkowski's avatar
Thomas Witkowski committed
157
158
    inline int getDegree() const 
    { 
159
      return degree_; 
160
    }
161

162
    /// function evaluation.
163
164
165
166
    virtual ReturnType operator()(const ArgumentType1& x,
				  const ArgumentType2& y,
				  const ArgumentType3& z,
				  const ArgumentType4& u) const = 0;
167
168
169
170
171
172
173
174
175
176
177

  protected:
    int degree_;
  };




}

#endif // AMDIS_ABSTRACTFUNCTION_H