AbstractFunction.h 5.64 KB
Newer Older
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
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  crystal growth group                                                  ==
// ==                                                                        ==
// ==  Stiftung caesar                                                       ==
// ==  Ludwig-Erhard-Allee 2                                                 ==
// ==  53175 Bonn                                                            ==
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  http://www.caesar.de/cg/AMDiS                                         ==
// ==                                                                        ==
// ============================================================================

/** \file AbstractFunction.h */

#ifndef AMDIS_ABSTRACTFUNCTION_H
#define AMDIS_ABSTRACTFUNCTION_H

#include "Global.h"
#include "MemoryManager.h"

namespace AMDiS {

  // ============================================================================
  // ===== class AbstractFunction ===============================================
  // ============================================================================

  /** 
   * \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:
    /** \brief
     * Constructor.
     */
52
53
    AbstractFunction(int degree = 0) : 
      degree_(degree) 
Thomas Witkowski's avatar
Thomas Witkowski committed
54
    {}
55

Thomas Witkowski's avatar
Thomas Witkowski committed
56
    virtual ~AbstractFunction() {}
57
58
59
60

    /** \brief
     * Returns \ref degree_.
     */
61
62
    inline int getDegree() const { 
      return degree_; 
Thomas Witkowski's avatar
Thomas Witkowski committed
63
    }
64
65
66
67

    /** \brief
     * Deligates the evaluation to overriden method f.
     */
68
    virtual ReturnType operator()(const ArgumentType& x) const = 0;
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

  protected:
    int degree_;
  };

  // ============================================================================
  // ===== class BinaryAbstractFunction =========================================
  // ============================================================================

  /**
   * \ingroup Common
   *
   * \brief
   * Interface for binary functions. 
   */
  template<typename ReturnType, 
	   typename ArgumentType1, 
	   typename ArgumentType2>
  class BinaryAbstractFunction
  {
  public:
    /** \brief
     * Constructor.
     */
93
94
95
    BinaryAbstractFunction(int degree = 0) : 
      degree_(degree) 
    {};
96
97
98
99
100
101

    virtual ~BinaryAbstractFunction() {};

    /** \brief
     * Returns \ref degree_.
     */
102
103
104
    inline int getDegree() const { 
      return degree_; 
    };
105
106
107
108

    /** \brief
     * Deligates the evaluation to overriden method f.
     */
109
110
    virtual ReturnType operator()(const ArgumentType1& x,
				  const ArgumentType2& y) const = 0;
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

  protected:
    int degree_;
  };

  // ============================================================================
  // ===== class TertiaryAbstractFunction =======================================
  // ============================================================================

  /**
   * \ingroup Common
   *
   * \brief
   * Interface for tertiary functions. 
   */
  template<typename ReturnType, 
	   typename ArgumentType1, 
	   typename ArgumentType2,
	   typename ArgumentType3>
  class TertiaryAbstractFunction
  {
  public:
    /** \brief
     * Constructor.
     */
136
137
138
    TertiaryAbstractFunction(int degree = 0) : 
      degree_(degree) 
    {};
139
140
141
142
143
144

    virtual ~TertiaryAbstractFunction() {};

    /** \brief
     * Returns \ref degree_.
     */
145
146
147
    inline int getDegree() const { 
      return degree_; 
    };
148
149
150
151

    /** \brief
     * function evaluation.
     */
152
153
154
    virtual ReturnType operator()(const ArgumentType1& x,
				  const ArgumentType2& y,
				  const ArgumentType3& z) const = 0;
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

  protected:
    int degree_;
  };


  // ============================================================================
  // ===== class QuartAbstractFunction =======================================
  // ============================================================================

  /**
   * \ingroup Common
   *
   * \brief
   * Interface for quart functions. 
   */
  template<typename ReturnType, 
	   typename ArgumentType1, 
	   typename ArgumentType2, 
	   typename ArgumentType3,
	   typename ArgumentType4>
  class QuartAbstractFunction
  {
  public:
    /** \brief
     * Constructor.
     */
182
183
184
    QuartAbstractFunction(int degree = 0) : 
      degree_(degree) 
    {};
185
186
187
188
189
190

    virtual ~QuartAbstractFunction() {};

    /** \brief
     * Returns \ref degree_.
     */
191
192
193
    inline int getDegree() const { 
      return degree_; 
    };
194
195
196
197

    /** \brief
     * function evaluation.
     */
198
199
200
201
    virtual ReturnType operator()(const ArgumentType1& x,
				  const ArgumentType2& y,
				  const ArgumentType3& z,
				  const ArgumentType4& u) const = 0;
202
203
204
205
206
207
208
209
210
211
212

  protected:
    int degree_;
  };




}

#endif // AMDIS_ABSTRACTFUNCTION_H