aGrUM  0.16.0
operators4MultiDim_tpl.h
Go to the documentation of this file.
1 
30 #ifndef DOXYGEN_SHOULD_SKIP_THIS
31 
32 // allow operatorsPatterns to be used
33 # define GUM_OPERATOR_PATTERN_ALLOWED 1
34 
35 # include <agrum/multidim/utils/operators/operatorRegister4MultiDim.h>
36 
37 // ==========================================================================
38 // MultiDimArrays functions
39 // ==========================================================================
40 
41 // a specialized function for summing two multiDimArrays
42 
43 // addition taking in argument 2 multiDimArrays
44 # define GUM_MULTI_DIM_OPERATOR_NAME add2MultiDimArrays
45 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) + (y)
46 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
47 # undef GUM_MULTI_DIM_OPERATOR_NAME
48 # undef GUM_MULTI_DIM_OPERATOR
49 
50 # define GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME add2MultiDimArrays
51 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) + (y)
52 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
53 # undef GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME
54 # undef GUM_MULTI_DIM_OPERATOR
55 
56 # define GUM_MULTI_DIM_OPERATOR_POINTER_NAME add2MultiDimArrays4Pointers
57 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) + (*y))
58 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
59 # undef GUM_MULTI_DIM_OPERATOR_POINTER_NAME
60 # undef GUM_MULTI_DIM_OPERATOR
61 
62 # define GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME \
63  add2MultiDimArrays4Pointers
64 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) + (*y))
65 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
66 # undef GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME
67 # undef GUM_MULTI_DIM_OPERATOR
68 
69 // a specialized function for subtracting two multiDimArrays
70 
71 # define GUM_MULTI_DIM_OPERATOR_NAME subtract2MultiDimArrays
72 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) - (y)
73 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
74 # undef GUM_MULTI_DIM_OPERATOR_NAME
75 # undef GUM_MULTI_DIM_OPERATOR
76 
77 # define GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME subtract2MultiDimArrays
78 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) - (y)
79 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
80 # undef GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME
81 # undef GUM_MULTI_DIM_OPERATOR
82 
83 # define GUM_MULTI_DIM_OPERATOR_POINTER_NAME subtract2MultiDimArrays4Pointers
84 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) - (*y))
85 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
86 # undef GUM_MULTI_DIM_OPERATOR_POINTER_NAME
87 # undef GUM_MULTI_DIM_OPERATOR
88 
89 # define GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME \
90  subtract2MultiDimArrays4Pointers
91 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) - (*y))
92 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
93 # undef GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME
94 # undef GUM_MULTI_DIM_OPERATOR
95 
96 // a specialized function for multiplying two multiDimArrays
97 
98 # define GUM_MULTI_DIM_OPERATOR_NAME multiply2MultiDimArrays
99 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) * (y)
100 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
101 # undef GUM_MULTI_DIM_OPERATOR_NAME
102 # undef GUM_MULTI_DIM_OPERATOR
103 
104 # define GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME multiply2MultiDimArrays
105 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) * (y)
106 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
107 # undef GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME
108 # undef GUM_MULTI_DIM_OPERATOR
109 
110 # define GUM_MULTI_DIM_OPERATOR_POINTER_NAME multiply2MultiDimArrays4Pointers
111 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) * (*y))
112 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
113 # undef GUM_MULTI_DIM_OPERATOR_POINTER_NAME
114 # undef GUM_MULTI_DIM_OPERATOR
115 
116 # define GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME \
117  multiply2MultiDimArrays4Pointers
118 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) * (*y))
119 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
120 # undef GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME
121 # undef GUM_MULTI_DIM_OPERATOR
122 
123 // a specialized function for dividing two multiDimArrays
124 
125 # define GUM_MULTI_DIM_OPERATOR_NAME divide2MultiDimArrays
126 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) / (y)
127 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
128 # undef GUM_MULTI_DIM_OPERATOR_NAME
129 # undef GUM_MULTI_DIM_OPERATOR
130 
131 # define GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME divide2MultiDimArrays
132 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) / (y)
133 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
134 # undef GUM_MULTI_DIM_OPERATOR_IMPL2ARRAY_NAME
135 # undef GUM_MULTI_DIM_OPERATOR
136 
137 # define GUM_MULTI_DIM_OPERATOR_POINTER_NAME divide2MultiDimArrays4Pointers
138 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) / (*y))
139 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
140 # undef GUM_MULTI_DIM_OPERATOR_POINTER_NAME
141 # undef GUM_MULTI_DIM_OPERATOR
142 
143 # define GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME \
144  divide2MultiDimArrays4Pointers
145 # define GUM_MULTI_DIM_OPERATOR(x, y) new T((*x) / (*y))
146 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
147 # undef GUM_MULTI_DIM_OPERATOR_POINTER_IMPL2ARRAY_NAME
148 # undef GUM_MULTI_DIM_OPERATOR
149 
150 // ==========================================================================
151 // MultiDimFunctionGraphs functions
152 // ==========================================================================
153 
154 // ///////////////////////////////////////////////////////
155 // a specialized function for summing two multiDimFunctionGraphs
156 // ///////////////////////////////////////////////////////
157 
158 # define GUM_MULTI_DIM_OPERATOR std::plus
159 
160 # define GUM_MULTI_DIM_OPERATOR_NAME add2MultiDimFunctionGraphs
161 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
162 # undef GUM_MULTI_DIM_OPERATOR_NAME
163 
164 # define GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME \
165  add2MultiDimFunctionGraphs
166 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
167 # undef GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME
168 
169 # undef GUM_MULTI_DIM_OPERATOR
170 
171 // ///////////////////////////////////////////////////////
172 // a specialized function for subtracting two multiDimFunctionGraphs
173 // ///////////////////////////////////////////////////////
174 
175 # define GUM_MULTI_DIM_OPERATOR std::minus
176 
177 # define GUM_MULTI_DIM_OPERATOR_NAME subtract2MultiDimFunctionGraphs
178 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
179 # undef GUM_MULTI_DIM_OPERATOR_NAME
180 
181 # define GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME \
182  subtract2MultiDimFunctionGraphs
183 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
184 # undef GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME
185 
186 # undef GUM_MULTI_DIM_OPERATOR
187 
188 // ///////////////////////////////////////////////////////
189 // a specialized function for multiplying two multiDimFunctionGraphs
190 // ///////////////////////////////////////////////////////
191 
192 # define GUM_MULTI_DIM_OPERATOR std::multiplies
193 
194 # define GUM_MULTI_DIM_OPERATOR_NAME multiply2MultiDimFunctionGraphs
195 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
196 # undef GUM_MULTI_DIM_OPERATOR_NAME
197 
198 # define GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME \
199  multiply2MultiDimFunctionGraphs
200 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
201 # undef GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME
202 
203 # undef GUM_MULTI_DIM_OPERATOR
204 
205 // ///////////////////////////////////////////////////////
206 // a specialized function for dividing two multiDimFunctionGraphs
207 // ///////////////////////////////////////////////////////
208 
209 # define GUM_MULTI_DIM_OPERATOR std::divides
210 
211 # define GUM_MULTI_DIM_OPERATOR_NAME divide2MultiDimFunctionGraphs
212 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
213 # undef GUM_MULTI_DIM_OPERATOR_NAME
214 
215 # define GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME \
216  divide2MultiDimFunctionGraphs
217 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
218 # undef GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME
219 
220 # undef GUM_MULTI_DIM_OPERATOR
221 
222 // ///////////////////////////////////////////////////////
223 // a specialized function for finding max of two multiDimFunctionGraphs
224 // ///////////////////////////////////////////////////////
225 
226 # define GUM_MULTI_DIM_OPERATOR Maximizes
227 
228 # define GUM_MULTI_DIM_OPERATOR_NAME maximize2MultiDimFunctionGraphs
229 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
230 # undef GUM_MULTI_DIM_OPERATOR_NAME
231 
232 # define GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME \
233  maximize2MultiDimFunctionGraphs
234 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
235 # undef GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME
236 
237 # undef GUM_MULTI_DIM_OPERATOR
238 
239 // ///////////////////////////////////////////////////////
240 // a specialized function for finding min of two multiDimFunctionGraphs
241 // ///////////////////////////////////////////////////////
242 
243 # define GUM_MULTI_DIM_OPERATOR Minimizes
244 
245 # define GUM_MULTI_DIM_OPERATOR_NAME minimize2MultiDimFunctionGraphs
246 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
247 # undef GUM_MULTI_DIM_OPERATOR_NAME
248 
249 # define GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME \
250  minimize2MultiDimFunctionGraphs
251 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimFunctionGraph.h>
252 # undef GUM_MULTI_DIM_OPERATOR_IMPL2DECISION_GRAPH_NAME
253 
254 # undef GUM_MULTI_DIM_OPERATOR
255 
256 // a specialized function for functionally combining two multiDimArrays
257 
258 # define GUM_MULTI_DIM_OPERATOR_NAME_F combine2MultiDimArrays
259 # define GUM_MULTI_DIM_OPERATOR(x, y) f((x), (y))
260 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimArray.h>
261 # undef GUM_MULTI_DIM_OPERATOR_NAME_F
262 # undef GUM_MULTI_DIM_OPERATOR
263 
264 // the operators that should be used to select appropriately the functions
265 // to combine multiDims
266 
267 // the function to be used to add two MultiDimImplementations
268 # define GUM_MULTI_DIM_OPERATOR_NAME operator+
269 # define GUM_MULTI_DIM_OPERATOR_FUNC_NAME "+"
270 # define GUM_MULTI_DIM_SYMMETRIC_OPERATOR
271 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimImplementation.h>
272 # undef GUM_MULTI_DIM_OPERATOR_NAME
273 # undef GUM_MULTI_DIM_OPERATOR_FUNC_NAME
274 # undef GUM_MULTI_DIM_SYMMETRIC_OPERATOR
275 
276 // the function to be used to multiply two MultiDimImplementations
277 # define GUM_MULTI_DIM_OPERATOR_NAME operator*
278 # define GUM_MULTI_DIM_OPERATOR_FUNC_NAME "*"
279 # define GUM_MULTI_DIM_SYMMETRIC_OPERATOR
280 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimImplementation.h>
281 # undef GUM_MULTI_DIM_OPERATOR_NAME
282 # undef GUM_MULTI_DIM_OPERATOR_FUNC_NAME
283 # undef GUM_MULTI_DIM_SYMMETRIC_OPERATOR
284 
285 // the function to be used to subtract two MultiDimImplementations
286 # define GUM_MULTI_DIM_OPERATOR_NAME operator-
287 # define GUM_MULTI_DIM_OPERATOR_FUNC_NAME "-"
288 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimImplementation.h>
289 # undef GUM_MULTI_DIM_OPERATOR_NAME
290 # undef GUM_MULTI_DIM_OPERATOR_FUNC_NAME
291 
292 // the function to be used to divide two MultiDimImplementations
293 # define GUM_MULTI_DIM_OPERATOR_NAME operator/
294 # define GUM_MULTI_DIM_OPERATOR_FUNC_NAME "/"
295 # include <agrum/multidim/utils/patterns/operatorPattern4MultiDimImplementation.h>
296 # undef GUM_MULTI_DIM_OPERATOR_NAME
297 # undef GUM_MULTI_DIM_OPERATOR_FUNC_NAME
298 
299 // default "basename" functions for combining two MultiDimImplementations
300 
301 # define GUM_MULTI_DIM_OPERATOR_NAME add2MultiDimImplementations
302 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) + (y)
303 # include <agrum/multidim/utils/patterns/operatorPattern4BaseName.h>
304 # undef GUM_MULTI_DIM_OPERATOR_NAME
305 # undef GUM_MULTI_DIM_OPERATOR
306 
307 # define GUM_MULTI_DIM_OPERATOR_NAME subtract2MultiDimImplementations
308 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) - (y)
309 # include <agrum/multidim/utils/patterns/operatorPattern4BaseName.h>
310 # undef GUM_MULTI_DIM_OPERATOR_NAME
311 # undef GUM_MULTI_DIM_OPERATOR
312 
313 # define GUM_MULTI_DIM_OPERATOR_NAME multiply2MultiDimImplementations
314 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) * (y)
315 # include <agrum/multidim/utils/patterns/operatorPattern4BaseName.h>
316 # undef GUM_MULTI_DIM_OPERATOR_NAME
317 # undef GUM_MULTI_DIM_OPERATOR
318 
319 # define GUM_MULTI_DIM_OPERATOR_NAME divide2MultiDimImplementations
320 # define GUM_MULTI_DIM_OPERATOR(x, y) (x) / (y)
321 # include <agrum/multidim/utils/patterns/operatorPattern4BaseName.h>
322 # undef GUM_MULTI_DIM_OPERATOR_NAME
323 # undef GUM_MULTI_DIM_OPERATOR
324 
325 //
326 // DO NOT FORGET TO REGISTER YOUR BINARY FUNCTIONS
327 //
328 
329 namespace gum {
330 
331  // the function used to register all the above functions
332  template < typename GUM_SCALAR >
333  void operators4MultiDimInit() {
334  static bool first_init = true;
335 
336  if (first_init) {
337  first_init = false;
338 
339  std::string MultiDimArrayString("MultiDimArray");
340  std::string MultiDimFunctionGraphString("MultiDimFunctionGraph");
341  std::string BaseNameString("MultiDimImplementation");
342 
343  // register base functions for multiDimArrays
344  registerOperator< GUM_SCALAR >(
345  "+", MultiDimArrayString, MultiDimArrayString, &add2MultiDimArrays);
346  registerOperator< GUM_SCALAR >(
347  "-", MultiDimArrayString, MultiDimArrayString, &subtract2MultiDimArrays);
348  registerOperator< GUM_SCALAR >(
349  "*", MultiDimArrayString, MultiDimArrayString, &multiply2MultiDimArrays);
350  registerOperator< GUM_SCALAR >(
351  "/", MultiDimArrayString, MultiDimArrayString, &divide2MultiDimArrays);
352 
353  // register base functions for multiDimFunctionGraphs
354  registerOperator< GUM_SCALAR >("+",
355  MultiDimFunctionGraphString,
356  MultiDimFunctionGraphString,
357  &add2MultiDimFunctionGraphs);
358  registerOperator< GUM_SCALAR >("-",
359  MultiDimFunctionGraphString,
360  MultiDimFunctionGraphString,
361  &subtract2MultiDimFunctionGraphs);
362  registerOperator< GUM_SCALAR >("*",
363  MultiDimFunctionGraphString,
364  MultiDimFunctionGraphString,
365  &multiply2MultiDimFunctionGraphs);
366  registerOperator< GUM_SCALAR >("/",
367  MultiDimFunctionGraphString,
368  MultiDimFunctionGraphString,
369  &divide2MultiDimFunctionGraphs);
370 
371  // register default basename functions
372  registerOperator< GUM_SCALAR >(
373  "+", BaseNameString, BaseNameString, &add2MultiDimImplementations);
374  registerOperator< GUM_SCALAR >(
375  "-", BaseNameString, BaseNameString, &subtract2MultiDimImplementations);
376  registerOperator< GUM_SCALAR >(
377  "*", BaseNameString, BaseNameString, &multiply2MultiDimImplementations);
378  registerOperator< GUM_SCALAR >(
379  "/", BaseNameString, BaseNameString, &divide2MultiDimImplementations);
380  }
381  }
382 
383  // the function used to register all the above functions
384  template < typename GUM_SCALAR >
385  void pointerOperators4MultiDimInit() {
386  static bool first_init = true;
387 
388  if (first_init) {
389  first_init = false;
390 
391  std::string MultiDimArrayString("MultiDimArray");
392  std::string BaseNameString("MultiDimImplementation");
393 
394  // register base functions for multiDimArrays
395  registerOperator< GUM_SCALAR* >("+",
396  MultiDimArrayString,
397  MultiDimArrayString,
398  &add2MultiDimArrays4Pointers);
399  registerOperator< GUM_SCALAR* >("-",
400  MultiDimArrayString,
401  MultiDimArrayString,
402  &subtract2MultiDimArrays4Pointers);
403  registerOperator< GUM_SCALAR* >("*",
404  MultiDimArrayString,
405  MultiDimArrayString,
406  &multiply2MultiDimArrays4Pointers);
407  registerOperator< GUM_SCALAR* >("/",
408  MultiDimArrayString,
409  MultiDimArrayString,
410  &divide2MultiDimArrays4Pointers);
411  }
412  }
413 
414 } /* namespace gum */
415 
416 // remove permission to use operatorsPatterns
417 # undef GUM_OPERATOR_PATTERN_ALLOWED
418 
419 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
gum::multiply2MultiDimArrays
MultiDimArray< T > * multiply2MultiDimArrays(const MultiDimArray< T > *t1, const MultiDimArray< T > *t2)
a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of...
operatorRegister4MultiDim.h
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.
gum::operators4MultiDimInit
void operators4MultiDimInit()
the function used to register all the operators on multidimImplementations over non-pointers types...
gum::divide2MultiDimArrays4Pointers
MultiDimArray< T *> * divide2MultiDimArrays4Pointers(const MultiDimArray< T * > *t1, const MultiDimArray< T * > *t2)
a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t...
operatorPattern4MultiDimImplementation.h
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.
gum::add2MultiDimArrays4Pointers
MultiDimArray< T *> * add2MultiDimArrays4Pointers(const MultiDimArray< T * > *t1, const MultiDimArray< T * > *t2)
a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1...
gum::subtract2MultiDimFunctionGraphs
MultiDimFunctionGraph< T > * subtract2MultiDimFunctionGraphs(const MultiDimFunctionGraph< T > *t1, const MultiDimFunctionGraph< T > *t2)
a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtractio...
gum
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.
Definition: agrum.h:25
operatorPattern4MultiDimFunctionGraph.h
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.
gum::subtract2MultiDimArrays4Pointers
MultiDimArray< T *> * subtract2MultiDimArrays4Pointers(const MultiDimArray< T * > *t1, const MultiDimArray< T * > *t2)
a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtractio...
gum::multiply2MultiDimArrays4Pointers
MultiDimArray< T *> * multiply2MultiDimArrays4Pointers(const MultiDimArray< T * > *t1, const MultiDimArray< T * > *t2)
a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of...
gum::pointerOperators4MultiDimInit
void pointerOperators4MultiDimInit()
the function used to register all the operators on multidimImplementations over pointers types...
gum::multiply2MultiDimFunctionGraphs
MultiDimFunctionGraph< T > * multiply2MultiDimFunctionGraphs(const MultiDimFunctionGraph< T > *t1, const MultiDimFunctionGraph< T > *t2)
a specialized function for multiplying two multiDimArraysThe function produces a tensorial product of...
gum::add2MultiDimArrays
MultiDimArray< T > * add2MultiDimArrays(const MultiDimArray< T > *t1, const MultiDimArray< T > *t2)
a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1...
gum::subtract2MultiDimArrays
MultiDimArray< T > * subtract2MultiDimArrays(const MultiDimArray< T > *t1, const MultiDimArray< T > *t2)
a specialized function for subtracting two multiDimArraysThe function produces a tensorial subtractio...
gum::add2MultiDimFunctionGraphs
MultiDimFunctionGraph< T > * add2MultiDimFunctionGraphs(const MultiDimFunctionGraph< T > *t1, const MultiDimFunctionGraph< T > *t2)
a specialized function for summing two multiDimArraysThe function produces a tensorial addition of t1...
gum::divide2MultiDimFunctionGraphs
MultiDimFunctionGraph< T > * divide2MultiDimFunctionGraphs(const MultiDimFunctionGraph< T > *t1, const MultiDimFunctionGraph< T > *t2)
a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t...
gum::divide2MultiDimArrays
MultiDimArray< T > * divide2MultiDimArrays(const MultiDimArray< T > *t1, const MultiDimArray< T > *t2)
a specialized function for dividing two multiDimArraysThe function produces a tensorial division of t...
operatorPattern4MultiDimArray.h
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.
operatorPattern4BaseName.h
Copyright 2005-2019 Pierre-Henri WUILLEMIN et Christophe GONZALES (LIP6) {prenom.nom}_at_lip6.fr.
aGrUM 0.16.0
Tue Aug 27 2019 12:07:06
© CG&PHW&others - LIP6 2005-2007-2012
DoXyGeN 1.8.13