KADATH
term_eq_math.cpp
1 /*
2  Copyright 2017 Philippe Grandclement
3 
4  This file is part of Kadath.
5 
6  Kadath is free software: you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation, either version 3 of the License, or
9  (at your option) any later version.
10 
11  Kadath is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with Kadath. If not, see <http://www.gnu.org/licenses/>.
18 */
19 
20 #include "term_eq.hpp"
21 #include "scalar.hpp"
22 #include "tensor_impl.hpp"
23 
24 namespace Kadath {
25 Term_eq operator+ (const Term_eq& aa, double xx) {
26  Term_eq auxi (aa.dom, xx, 0.) ;
27  return aa + auxi ;
28 }
29 
30 Term_eq operator+ (double xx, const Term_eq& aa) {
31  Term_eq auxi (aa.dom, xx, 0.) ;
32  return aa + auxi ;
33 }
34 
35 Term_eq operator- (const Term_eq& aa) {
36  return (-1. * aa) ;
37 }
38 
39 Term_eq Term_eq::der_abs (int i) const {
40 
41  Term_eq res (dom, type_data) ;
42  Index pos(*val_t) ;
43  switch (type_data) {
44  case TERM_D :
45  cerr << "derivative only defined with respect to tensors" << endl ;
46  abort() ;
47  case TERM_T :
48  res.val_t = new Tensor(*val_t, false) ;
49  if (der_t!=nullptr)
50  res.der_t = new Tensor(*der_t, false) ;
51  do {
52  res.val_t->set(pos).set_domain(dom) = (*val_t)(pos)(dom).der_abs(i) ;
53  if (der_t !=nullptr)
54  res.der_t->set(pos).set_domain(dom) = (*der_t)(pos)(dom).der_abs(i) ;
55  }
56  while (pos.inc()) ;
57  break ;
58  default:
59  cerr << "Unknown data storage in operator+" << endl ;
60  abort() ;
61  }
62  return res ;
63 }
64 
65 Term_eq operator+ (const Term_eq& aa, const Term_eq& bb) {
66 
67 
68  bool do_der = true ;
69 
70  int data_res ;
71  assert (aa.dom==bb.dom) ;
72  switch (aa.type_data) {
73  case (TERM_D) :
74  if (aa.der_d==nullptr)
75  do_der = false ;
76  switch (bb.type_data) {
77  case (TERM_D) :
78  data_res = TERM_D ;
79  if (bb.der_d==nullptr)
80  do_der=false ;
81  break ;
82  case (TERM_T) :
83  data_res = TERM_T ;
84  if (bb.der_t==nullptr)
85  do_der = false ;
86  break ;
87  default:
88  cerr << "Unknown data storage in operator+" << endl ;
89  abort() ;
90  }
91  break ;
92  case (TERM_T) :
93  if (aa.der_t==nullptr)
94  do_der = false ;
95  switch (bb.type_data) {
96  case (TERM_D) :
97  if (bb.der_d==nullptr)
98  do_der=false ;
99  data_res = TERM_T ;
100  break ;
101  case (TERM_T) :
102  if (bb.der_t==nullptr)
103  do_der=false ;
104  data_res = TERM_T ;
105  break ;
106  default:
107  cerr << "Unknown data storage in operator+" << endl ;
108  abort() ;
109  }
110  break ;
111  default :
112  cerr << "Unknown data storage in operator+" << endl ;
113  abort() ;
114  }
115 
116  Term_eq res(aa.dom, data_res) ;
117  switch (aa.type_data) {
118  case (TERM_D) :
119  switch (bb.type_data) {
120  case (TERM_D) :
121  res.val_d = new double(*aa.val_d + *bb.val_d) ;
122  res.der_d = (do_der) ? new double (*aa.der_d + *bb.der_d) :nullptr ;
123  break ;
124  case (TERM_T) :
125  res.val_t = new Tensor(add_one_dom(res.dom, *aa.val_d, *bb.val_t)) ;
126  res.der_t = (do_der) ?
127  new Tensor (add_one_dom(res.dom, *aa.der_d, *bb.der_t)) :nullptr;
128  break ;
129  default:
130  cerr << "Unknown data storage in operator+" << endl ;
131  abort() ;
132  }
133  break ;
134  case (TERM_T) :
135  switch (bb.type_data) {
136  case (TERM_D) :
137  res.val_t = new Tensor(add_one_dom(res.dom, *aa.val_t , *bb.val_d)) ;
138  res.der_t = (do_der) ?
139  new Tensor(add_one_dom(res.dom, *aa.der_t , *bb.der_d)) :nullptr;
140  break ;
141  case (TERM_T) :
142  res.val_t = new Tensor(add_one_dom(res.dom, *aa.val_t , *bb.val_t)) ;
143  res.der_t = (do_der) ?
144  new Tensor(add_one_dom(res.dom, *aa.der_t , *bb.der_t)) : nullptr ;
145  break ;
146  default:
147  cerr << "Unknown data storage in operator+" << endl ;
148  abort() ;
149  }
150  break ;
151  default :
152  cerr << "Unknown data storage in operator+" << endl ;
153  abort() ;
154  }
155  return res ;
156 }
157 
158 
159 Term_eq operator- (const Term_eq& aa, const Term_eq& bb) {
160  assert (aa.dom==bb.dom) ;
161  int data_res ;
162  bool do_der = true ;
163  switch (aa.type_data) {
164  case (TERM_D) :
165  if (aa.der_d==nullptr)
166  do_der = false ;
167  switch (bb.type_data) {
168  case (TERM_D) :
169  if (bb.der_d==nullptr)
170  do_der = false ;
171  data_res = TERM_D ;
172  break ;
173  case (TERM_T) :
174  if (bb.der_t==nullptr)
175  do_der = false ;
176  data_res = TERM_T ;
177  break ;
178  default:
179  cerr << "Unknown data storage in operator-" << endl ;
180  abort() ;
181  }
182  break ;
183  case (TERM_T) :
184  if (aa.der_t==nullptr)
185  do_der = false ;
186  switch (bb.type_data) {
187  case (TERM_D) :
188  if (bb.der_d==nullptr)
189  do_der = false ;
190  data_res = TERM_T ;
191  break ;
192  case (TERM_T) :
193  if (bb.der_t==nullptr)
194  do_der = false ;
195  data_res = TERM_T ;
196  break ;
197  default:
198  cerr << "Unknown data storage in operator-" << endl ;
199  abort() ;
200  }
201  break ;
202  default :
203  cerr << "Unknown data storage in operator-" << endl ;
204  abort() ;
205  }
206 
207  Term_eq res(aa.dom, data_res) ;
208  switch (aa.type_data) {
209  case (TERM_D) :
210  switch (bb.type_data) {
211  case (TERM_D) :
212  res.val_d = new double(*aa.val_d - *bb.val_d) ;
213  res.der_d = (do_der) ? new double (*aa.der_d - *bb.der_d) :nullptr ;
214  break ;
215  case (TERM_T) :
216  res.val_t = new Tensor(sub_one_dom(res.dom, *aa.val_d, *bb.val_t)) ;
217  res.der_t = (do_der) ?
218  new Tensor (sub_one_dom(res.dom, *aa.der_d, *bb.der_t)) : nullptr ;
219  break ;
220  default:
221  cerr << "Unknown data storage in operator+" << endl ;
222  abort() ;
223  }
224  break ;
225  case (TERM_T) :
226  switch (bb.type_data) {
227  case (TERM_D) :
228  res.val_t = new Tensor(sub_one_dom(res.dom, *aa.val_t, *bb.val_d)) ;
229  res.der_t = (do_der) ?
230  new Tensor(sub_one_dom(res.dom, *aa.der_t, *bb.der_d)) : nullptr ;
231  break ;
232  case (TERM_T) :
233  res.val_t = new Tensor(sub_one_dom(res.dom, *aa.val_t, *bb.val_t)) ;
234  res.der_t = (do_der) ?
235  new Tensor(sub_one_dom(res.dom, *aa.der_t, *bb.der_t)) : nullptr ;
236  break ;
237  default:
238  cerr << "Unknown data storage in operator+" << endl ;
239  abort() ;
240  }
241  break ;
242  default :
243  cerr << "Unknown data storage in operator+" << endl ;
244  abort() ;
245  }
246  return res ;
247 }
248 
249 Term_eq operator* (const Term_eq& aa, const Term_eq& bb) {
250 
251  assert (aa.dom==bb.dom) ;
252  int data_res ;
253  bool do_der = true ;
254  switch (aa.type_data) {
255  case (TERM_D) :
256  if (aa.der_d==nullptr)
257  do_der = false ;
258  switch (bb.type_data) {
259  case (TERM_D) :
260  if (bb.der_d==nullptr)
261  do_der = false ;
262  data_res = TERM_D ;
263  break ;
264  case (TERM_T) :
265  if (bb.der_t==nullptr)
266  do_der = false ;
267  data_res = TERM_T ;
268  break ;
269  default:
270  cerr << "Unknown data storage in operator*" << endl ;
271  abort() ;
272  }
273  break ;
274  case (TERM_T) :
275  if (aa.der_t==nullptr)
276  do_der=false ;
277  switch (bb.type_data) {
278  case (TERM_D) :
279  if (bb.der_d==nullptr)
280  do_der=false ;
281  data_res = TERM_T ;
282  break ;
283  case (TERM_T) :
284  if (bb.der_t==nullptr)
285  do_der = false ;
286  data_res = TERM_T ;
287  break ;
288  default:
289  cerr << "Unknown data storage in operator*" << endl ;
290  abort() ;
291  }
292  break ;
293  default :
294  cerr << "Unknown data storage in operator*" << endl ;
295  abort() ;
296  }
297 
298  Term_eq res(aa.dom, data_res) ;
299  switch (aa.type_data) {
300  case (TERM_D) :
301  switch (bb.type_data) {
302  case (TERM_D) :
303  res.val_d = new double((*aa.val_d) * (*bb.val_d)) ;
304  res.der_d = (do_der) ?
305  new double ((*aa.der_d)*(*bb.val_d) + (*aa.val_d)*(*bb.der_d)) : nullptr ;
306  break ;
307  case (TERM_T) :
308  res.val_t = new Tensor(mult_one_dom(res.dom, *aa.val_d, *bb.val_t)) ;
309  res.der_t = (do_der) ?
310  new Tensor (add_one_dom(res.dom, mult_one_dom(res.dom, *aa.der_d,*bb.val_t),
311  mult_one_dom(res.dom, *aa.val_d, *bb.der_t))) : nullptr ;
312  break ;
313  default:
314  cerr << "Unknown data storage in operator+" << endl ;
315  abort() ;
316  }
317  break ;
318  case (TERM_T) :
319  switch (bb.type_data) {
320  case (TERM_D) :
321  res.val_t = new Tensor(mult_one_dom(res.dom, *aa.val_t, *bb.val_d)) ;
322  res.der_t = (do_der) ?
323 new Tensor(add_one_dom(res.dom, mult_one_dom(res.dom, *aa.der_t, *bb.val_d), mult_one_dom(res.dom, *aa.val_t, *bb.der_d))) : nullptr ;
324  break ;
325  case (TERM_T) :
326  res.val_t = new Tensor(mult_one_dom(res.dom, *aa.val_t, *bb.val_t)) ;
327  res.der_t = (do_der) ?
328 new Tensor(add_one_dom(res.dom,
329  mult_one_dom(res.dom, *aa.der_t, *bb.val_t), mult_one_dom(res.dom, *aa.val_t, *bb.der_t))) : nullptr ;
330  break ;
331  default:
332  cerr << "Unknown data storage in operator*" << endl ;
333  abort() ;
334  }
335  break ;
336  default :
337  cerr << "Unknown data storage in operator*" << endl ;
338  abort() ;
339  }
340 
341  return res ;
342 }
343 
344 
345 Term_eq operator/ (const Term_eq& aa, const Term_eq& bb) {
346 
347  assert (aa.dom==bb.dom) ;
348  int data_res ;
349  bool do_der = true ;
350  switch (aa.type_data) {
351  case (TERM_D) :
352  if (aa.der_d==nullptr)
353  do_der = false ;
354  switch (bb.type_data) {
355  case (TERM_D) :
356  if (bb.der_d==nullptr)
357  do_der = false ;
358  data_res = TERM_D ;
359  break ;
360  case (TERM_T) :
361  if (bb.der_t==nullptr)
362  do_der = false ;
363  data_res = TERM_T ;
364  break ;
365  default:
366  cerr << "Unknown data storage in operator*" << endl ;
367  abort() ;
368  }
369  break ;
370  case (TERM_T) :
371  if (aa.der_t==nullptr)
372  do_der=false ;
373  switch (bb.type_data) {
374  case (TERM_D) :
375  if (bb.der_d==nullptr)
376  do_der = false ;
377  data_res = TERM_T ;
378  break ;
379  case (TERM_T) :
380  if (bb.der_t==nullptr)
381  do_der = false ;
382  data_res = TERM_T ;
383  break ;
384  default:
385  cerr << "Unknown data storage in operator*" << endl ;
386  abort() ;
387  }
388  break ;
389  default :
390  cerr << "Unknown data storage in operator*" << endl ;
391  abort() ;
392  }
393 
394  Term_eq res(aa.dom, data_res) ;
395  switch (aa.type_data) {
396  case (TERM_D) :
397  switch (bb.type_data) {
398  case (TERM_D) :
399  res.val_d = new double((*aa.val_d) / (*bb.val_d)) ;
400  res.der_d = (do_der) ?
401  new double (((*aa.der_d)*(*bb.val_d) - (*aa.val_d)*(*bb.der_d))/
402  ((*bb.val_d)*(*bb.val_d))) : nullptr ;
403  break ;
404  case (TERM_T) :
405  res.val_t = new Tensor(div_one_dom(res.dom, *aa.val_d, *bb.val_t)) ;
406  res.der_t = (do_der) ? new Tensor (div_one_dom(res.dom,
407  sub_one_dom(res.dom, mult_one_dom(res.dom, *aa.der_d, *bb.val_t),
408  mult_one_dom(res.dom, *aa.val_d, *bb.der_t)),
409  mult_one_dom(res.dom, *bb.val_t, *bb.val_t))) : nullptr ;
410  break ;
411  default:
412  cerr << "Unknown data storage in operator+" << endl ;
413  abort() ;
414  }
415  break ;
416  case (TERM_T) :
417  switch (bb.type_data) {
418  case (TERM_D) :
419  res.val_t = new Tensor(div_one_dom(res.dom, *aa.val_t, *bb.val_d)) ;
420  res.der_t = (do_der) ? new Tensor(div_one_dom(res.dom, sub_one_dom(res.dom,
421  mult_one_dom(res.dom, *aa.der_t, *bb.val_d),
422  mult_one_dom(res.dom, *aa.val_t, *bb.der_d)), (*bb.val_d) * (*bb.val_d))) : nullptr ;
423  break ;
424  case (TERM_T) :
425  res.val_t = new Tensor(div_one_dom(res.dom, *aa.val_t, *bb.val_t)) ;
426  res.der_t = (do_der) ? new Tensor(div_one_dom(res.dom,
427  sub_one_dom(res.dom, mult_one_dom(res.dom, *aa.der_t, *bb.val_t),
428  mult_one_dom(res.dom, *aa.val_t, *bb.der_t)),
429  mult_one_dom(res.dom, *bb.val_t, *bb.val_t))) : nullptr ;
430  break ;
431  default:
432  cerr << "Unknown data storage in operator+" << endl ;
433  abort() ;
434  }
435  break ;
436  default :
437  cerr << "Unknown data storage in operator+" << endl ;
438  abort() ;
439  }
440  return res ;
441 }
442 
443 
444 Term_eq scalar_product (const Term_eq& aa, const Term_eq& bb) {
445 
446  assert (aa.dom==bb.dom) ;
447  bool do_der = true ;
448  switch (aa.type_data) {
449  case (TERM_D) :
450  cerr << "scalar_product only defined with tensors" << endl ;
451  abort() ;
452  break ;
453  case (TERM_T) :
454  if (aa.der_t==nullptr)
455  do_der=false ;
456  switch (bb.type_data) {
457  case (TERM_D) :
458  cerr << "scalar_product only defined with tensors" << endl ;
459  abort() ;
460  break ;
461  case (TERM_T) :
462  if (bb.der_t==nullptr)
463  do_der = false ;
464  break ;
465  default:
466  cerr << "Unknown data storage in operator*" << endl ;
467  abort() ;
468  }
469  break ;
470  default :
471  cerr << "Unknown data storage in operator*" << endl ;
472  abort() ;
473  }
474 
475  // Try to see the parameter :
476 
477  bool param_val = false ;
478  int mval = 0 ;
479 
480  bool param_der = false ;
481  int mder = 0 ;
482  if (aa.type_data==TERM_T) {
483 
484  if (aa.val_t->is_m_quant_affected())
485  param_val = true ;
486  if (bb.val_t->is_m_quant_affected())
487  param_val = true ;
488  if (param_val) {
489  if (aa.val_t->is_m_quant_affected())
490  mval += aa.val_t->get_parameters().get_m_quant() ;
491  if (bb.val_t->is_m_quant_affected())
492  mval += bb.val_t->get_parameters().get_m_quant() ;
493  }
494 
495  if (do_der) {
496  if (aa.der_t->is_m_quant_affected())
497  param_der = true ;
498  if (bb.der_t->is_m_quant_affected())
499  param_der = true ;
500  if (param_der) {
501  if (aa.der_t->is_m_quant_affected())
502  mder += aa.der_t->get_parameters().get_m_quant() ;
503  if (bb.der_t->is_m_quant_affected())
504  mder += bb.der_t->get_parameters().get_m_quant() ;
505  }
506  }
507  }
508 
509  Term_eq res(aa.dom, TERM_T) ;
510  switch (aa.type_data) {
511  case (TERM_D) :
512  cerr << "scalar_product only defined with tensors" << endl ;
513  abort() ;
514  break ;
515  case (TERM_T) :
516  switch (bb.type_data) {
517  case (TERM_D) :
518  cerr << "scalar_product only defined with tensors" << endl ;
519  abort() ;
520  break ;
521  case (TERM_T) :
522  res.val_t = new Tensor(scal_one_dom(res.dom, *aa.val_t, *bb.val_t)) ;
523  if (mval != 0) {
524  res.val_t->set_parameters().set_m_quant() = mval ;
525  }
526 
527  res.der_t = (do_der) ? new Tensor(add_one_dom(res.dom,
528  scal_one_dom(res.dom, *aa.der_t, *bb.val_t), scal_one_dom(res.dom, *aa.val_t, *bb.der_t))) : nullptr ;
529 
530  if (mder != 0) {
531  res.der_t->set_parameters().set_m_quant() = mder ;
532  }
533  break ;
534  default:
535  cerr << "Unknown data storage in operator+" << endl ;
536  abort() ;
537  }
538  break ;
539  default :
540  cerr << "Unknown data storage in operator+" << endl ;
541  abort() ;
542  }
543  return res ;
544 }
545 
546 Term_eq pow (const Term_eq& so, int nn) {
547 
548  if (nn>0) {
549  Term_eq res (so) ;
550  for (int i=1 ; i<nn ; i++)
551  res = res*so ;
552  return res ;
553  }
554  else {
555  Scalar one_scal (so.get_val_t(), false) ;
556  one_scal = 1. ;
557  one_scal.std_base() ;
558  Scalar zero_scal (one_scal) ;
559  zero_scal = 0. ;
560  Term_eq one (so.get_dom(), one_scal, zero_scal) ;
561  Term_eq res (one) ;
562  for (int i=0 ; i<-nn ; i++)
563  res = res / so ;
564  return res ;
565  }
566 }
567 
568 Term_eq operator* (int nn, const Term_eq& so) {
569 
570  Term_eq res (so.dom, so.type_data) ;
571 
572  switch (so.type_data) {
573  case (TERM_D) :
574  res.val_d = new double(double(nn)*(*so.val_d)) ;
575  if (so.der_d!=nullptr)
576  res.der_d = new double(double(nn)*(*so.der_d)) ;
577  break ;
578  case (TERM_T) :
579  res.val_t = new Tensor(mult_one_dom(so.dom, nn, *so.val_t)) ;
580  if (so.der_t!=nullptr)
581  res.der_t = new Tensor(mult_one_dom(so.dom, nn, (*so.der_t))) ;
582  break ;
583  default :
584  cerr << "Unknown data storage in operator+" << endl ;
585  abort() ;
586  }
587  return res ;
588 }
589 
590 Term_eq operator* (const Term_eq& so, int nn) {
591  return nn*so ;
592 }
593 
594 Term_eq operator* (double xx, const Term_eq& so) {
595 
596  Term_eq res (so.dom, so.type_data) ;
597 
598  switch (so.type_data) {
599  case (TERM_D) :
600  res.val_d = new double(xx*(*so.val_d)) ;
601  if (so.der_d!=nullptr)
602  res.der_d = new double(xx*(*so.der_d)) ;
603  break ;
604  case (TERM_T) :
605  res.val_t = new Tensor(mult_one_dom(so.dom, xx, (*so.val_t))) ;
606  if (so.der_t!=nullptr)
607  res.der_t = new Tensor(mult_one_dom(so.dom, xx, (*so.der_t))) ;
608  break ;
609  default :
610  cerr << "Unknown data storage in operator+" << endl ;
611  abort() ;
612  }
613  return res ;
614 }
615 
616 Term_eq operator* (const Scalar& fact, const Term_eq& so) {
617 
618  Term_eq res (so.dom, so.type_data) ;
619 
620  switch (so.type_data) {
621  case (TERM_D) :
622  cerr << "Multiplication of a Term_èeq by a Scalar onlyu defined for Tensorial type" << endl ;
623  abort() ;
624  break ;
625  case (TERM_T) :
626  res.val_t = new Tensor(mult_one_dom(so.dom, fact, *so.val_t)) ;
627  if (so.der_t!=nullptr)
628  res.der_t = new Tensor(mult_one_dom(so.dom, fact, *so.der_t)) ;
629  break ;
630  default :
631  cerr << "Unknown data storage in operator+" << endl ;
632  abort() ;
633  }
634  return res ;
635 }
636 
637 Term_eq operator* (const Term_eq& so, double xx) {
638  return xx*so ;
639 }
640 
641 Term_eq operator/ (const Term_eq& so, double xx) {
642 
643  Term_eq res (so.dom, so.type_data) ;
644 
645  switch (so.type_data) {
646  case (TERM_D) :
647  res.val_d = new double((*so.val_d)/xx) ;
648  if (so.der_d!=nullptr)
649  res.der_d = new double((*so.der_d)/xx) ;
650  break ;
651  case (TERM_T) :
652  res.val_t = new Tensor(div_one_dom(so.dom, (*so.val_t), xx)) ;
653  if (so.der_t!=nullptr)
654  res.der_t = new Tensor(div_one_dom(so.dom, (*so.der_t), xx)) ;
655  break ;
656  default :
657  cerr << "Unknown data storage in operator/" << endl ;
658  abort() ;
659  }
660  return res ;
661 }
662 
663 Term_eq sqrt (const Term_eq& so) {
664 
665  Term_eq res (so.dom, so.type_data) ;
666 
667  switch (so.type_data) {
668  case (TERM_D) :
669  res.val_d = new double(sqrt(*so.val_d)) ;
670  if (so.der_d!=nullptr)
671  res.der_d = new double((*so.der_d)/2./sqrt(*so.val_d)) ;
672  break ;
673  case (TERM_T) :
674  res.val_t = new Tensor(sqrt_one_dom(so.dom, *so.val_t)) ;
675  if (so.der_t!=nullptr)
676  res.der_t = new Tensor(div_one_dom(so.dom, (*so.der_t), 2*sqrt_one_dom(so.dom, *so.val_t))) ;
677  break ;
678  default :
679  cerr << "Unknown data storage in operator/" << endl ;
680  abort() ;
681  }
682  return res ;
683 }
684 
685 Term_eq partial (const Term_eq& so, char ind) {
686  Term_eq res (so.dom, so.type_data) ;
687  switch (so.type_data) {
688  case (TERM_D) :
689  cerr << "Partial only defined with respect to tensors" << endl ;
690  abort() ;
691  case (TERM_T) :
692  res.val_t = new Tensor(partial_one_dom(so.dom, ind, *so.val_t)) ;
693  if (so.der_t!=nullptr)
694  res.der_t = new Tensor(partial_one_dom(so.dom, ind, (*so.der_t))) ;
695  break ;
696  default :
697  cerr << "Unknown data storage in partial" << endl ;
698  abort() ;
699  }
700  return res ;
701 }
702 
703 Term_eq div_1mx2 (const Term_eq& so) {
704  assert (so.type_data==TERM_T) ;
705 
706  return so.val_t->get_space().get_domain(so.dom)->div_1mx2_term_eq(so) ;
707 }
708 }
Kadath::Domain::div_1mx2_term_eq
virtual Term_eq div_1mx2_term_eq(const Term_eq &) const
Returns the division by of a Term_eq.
Definition: domain.cpp:1765
Kadath::Index
Class that gives the position inside a multi-dimensional Array.
Definition: index.hpp:38
Kadath::Index::inc
bool inc(int increm, int var=0)
Increments the position of the Index.
Definition: index.hpp:99
Kadath::Param_tensor::get_m_quant
int get_m_quant() const
Returns .
Definition: tensor.hpp:747
Kadath::Param_tensor::set_m_quant
int & set_m_quant()
Sets .
Definition: tensor.hpp:757
Kadath::Scalar
The class Scalar does not really implements scalars in the mathematical sense but rather tensorial co...
Definition: scalar.hpp:67
Kadath::Scalar::set_domain
Val_domain & set_domain(int)
Read/write of a particular Val_domain.
Definition: scalar.hpp:555
Kadath::Space::get_domain
const Domain * get_domain(int i) const
returns a pointer on the domain.
Definition: space.hpp:1385
Kadath::Tensor
Tensor handling.
Definition: tensor.hpp:149
Kadath::Tensor::set_parameters
Param_tensor & set_parameters()
Read/write of the parameters.
Definition: tensor.hpp:314
Kadath::Tensor::get_parameters
const Param_tensor & get_parameters() const
Returns a pointer on the possible additional parameter.
Definition: tensor.hpp:311
Kadath::Tensor::set
Scalar & set(const Array< int > &ind)
Returns the value of a component (read/write version).
Definition: tensor_impl.hpp:91
Kadath::Tensor::is_m_quant_affected
bool is_m_quant_affected() const
Checks whether the additional parameter is affected (used for boson stars for instance).
Definition: tensor.hpp:326
Kadath::Tensor::get_space
const Space & get_space() const
Returns the Space.
Definition: tensor.hpp:499
Kadath::Term_eq
This class is intended to describe the manage objects appearing in the equations.
Definition: term_eq.hpp:62
Kadath::Term_eq::der_t
Tensor * der_t
Pointer on the variation, if the Term_eq is a Tensor.
Definition: term_eq.hpp:69
Kadath::Term_eq::type_data
const int type_data
Flag describing the type of data :
Definition: term_eq.hpp:75
Kadath::Term_eq::val_d
double * val_d
Pointer on the value, if the Term_eq is a double.
Definition: term_eq.hpp:66
Kadath::Term_eq::get_dom
int get_dom() const
Definition: term_eq.hpp:135
Kadath::Term_eq::dom
const int dom
Index of the Domain where the Term_eq is defined.
Definition: term_eq.hpp:65
Kadath::Term_eq::der_abs
Term_eq der_abs(int i) const
Computes the derivative wrt to an absolute coordinate (i.e.
Definition: term_eq_math.cpp:39
Kadath::Term_eq::der_d
double * der_d
Pointer on the variation if the Term_eq is a double.
Definition: term_eq.hpp:67
Kadath::Term_eq::get_val_t
Tensor const & get_val_t() const
Definition: term_eq.hpp:355
Kadath::Term_eq::val_t
Tensor * val_t
Pointer on the value, if the Term_eq is a Tensor.
Definition: term_eq.hpp:68
Kadath::Val_domain::der_abs
Val_domain der_abs(int i) const
Computes the derivative with respect to an absolute coordinate (typically Cartesian).
Definition: val_domain.cpp:681