Jpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
JHermiteSpline.hh
Go to the documentation of this file.
1 #ifndef __JTOOLS__JHERMITESPLINE__
2 #define __JTOOLS__JHERMITESPLINE__
3 
4 #include <utility>
5 #include <cmath>
6 
7 #include "JMath/JZero.hh"
8 #include "JLang/JException.hh"
9 #include "JLang/JClass.hh"
10 #include "JTools/JFunctional.hh"
11 #include "JTools/JDistance.hh"
12 #include "JTools/JResult.hh"
13 #include "JTools/JMapCollection.hh"
14 
15 
16 /**
17  * \author mdejong
18  */
19 
20 namespace JTOOLS {}
21 namespace JPP { using namespace JTOOLS; }
22 
23 namespace JTOOLS {
24 
25  using JLANG::JNoValue;
29 
30 
31  /**
32  * Template base class spline interpolations.
33  *
34  * This class implements the JFunctional interface.
35  *
36  * Note that the data structure of the elements in the collection should have the additional methods:
37  * <pre>
38  * ordinate_type getU() const;
39  * void setU(ordinate_type u);
40  * </pre>
41  * to get and set the derivatives, respectively.
42  *
43  * Note that -by default- the compilation is for a monotonous interpolation.
44  */
45  template<class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
47  public JCollection_t<JElement_t, JDistance_t>,
48  public virtual JFunctional<>
49  {
50  public:
51 
52  typedef JCollection_t<JElement_t, JDistance_t> collection_type;
53 
54  typedef typename collection_type::abscissa_type abscissa_type;
55  typedef typename collection_type::ordinate_type ordinate_type;
56  typedef typename collection_type::value_type value_type;
57  typedef typename collection_type::distance_type distance_type;
58 
59  typedef typename collection_type::const_iterator const_iterator;
60  typedef typename collection_type::const_reverse_iterator const_reverse_iterator;
61  typedef typename collection_type::iterator iterator;
62  typedef typename collection_type::reverse_iterator reverse_iterator;
63 
65 
66 
67  /**
68  * Determination of derivatives.
69  *
70  * \param monotone monotone
71  */
72  void compile(const bool monotone)
73  {
74  const int numberOfElements = this->size();
75 
76  using namespace std;
77 
78  if (numberOfElements >= 2) {
79 
80  {
81  iterator j = this->begin(), i = j++;
82 
83  i->setU((j->getY() - i->getY()) / this->getDistance(i->getX(), j->getX()));
84  }
85 
86  {
87  reverse_iterator j = this->rbegin(), i = j++;
88 
89  i->setU((j->getY() - i->getY()) / this->getDistance(i->getX(), j->getX()));
90  }
91 
92  for (iterator k = this->begin(), i = k++, j = k++; k != this->end(); ++i, ++j, ++k) {
93  j->setU(0.5 * ((j->getY() - i->getY()) / this->getDistance(i->getX(), j->getX()) +
94  (k->getY() - j->getY()) / this->getDistance(j->getX(), k->getX())));
95  }
96 
97  if (monotone) {
98 
99  for (iterator j = this->begin(), i = j++; j != this->end(); ++i, ++j) {
100  if (i->getY() == j->getY()) {
101  j->setU(JMATH::zero);
102  }
103  }
104 
105  for (iterator j = this->begin(), i = j++; j != this->end(); ++i, ++j) {
106 
107  const ordinate_type u = (j->getY() - i->getY()) / this->getDistance(i->getX(), j->getX());
108  const ordinate_type w = (i->getU()*i->getU() + j->getU()*j->getU());
109 
110  if (w > 9.0*u*u) {
111 
112  const ordinate_type v = 3.0*u/sqrt(w);
113 
114  i->setU(v*i->getU());
115  j->setU(v*j->getU());
116  }
117  }
118  }
119  }
120  }
121 
122 
123  protected:
124 
125  static abscissa_type h00 (abscissa_type t) { return (1.0 + 2*t) * (1.0 - t) * (1.0 - t); }
126  static abscissa_type h10 (abscissa_type t) { return t * (1.0 - t) * (1.0 - t); }
127  static abscissa_type h01 (abscissa_type t) { return t * t * (3.0 - 2*t); }
128  static abscissa_type h11 (abscissa_type t) { return t * t * (t - 1.0); }
129 
130  static abscissa_type h00p(abscissa_type t) { return 6 * t * (t - 1.0); }
131  static abscissa_type h10p(abscissa_type t) { return t * (3*t - 4.0) + 1.0; }
132  static abscissa_type h01p(abscissa_type t) { return 6 * t * (1.0 -t); }
133  static abscissa_type h11p(abscissa_type t) { return t * (3*t - 2.0); }
134 
135  static abscissa_type H00 (abscissa_type t) { return t * (t * t * (0.5*t - 1.0) + 1.0); }
136  static abscissa_type H10 (abscissa_type t) { return t * t * (t * (0.25*t - 2.0/3.0) + 0.5); }
137  static abscissa_type H01 (abscissa_type t) { return t * t * t * (1.0 - 0.5*t); }
138  static abscissa_type H11 (abscissa_type t) { return t * t * t * (0.25*t - 1.0/3.0); }
139 
140 
141  /**
142  * Default constructor.
143  */
145  {}
146 
147 
148  /**
149  * Determination of derivatives.
150  */
151  virtual void do_compile()
152  {
153  compile(true);
154  }
155  };
156 
157 
158  /**
159  * Template definition for functional collection with spline interpolation.
160  */
161  template<class JElement_t,
162  template<class, class> class JCollection_t,
163  class JResult_t,
164  class JDistance_t>
166 
167 
168  /**
169  * Template specialisation for functional collection with spline interpolation.
170  */
171  template<class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
172  class JHermiteSplineFunction<JElement_t,
173  JCollection_t,
174  typename JResultType<typename JElement_t::ordinate_type>::result_type,
175  JDistance_t> :
176  public JHermiteSplineCollection<JElement_t, JCollection_t, JDistance_t>,
177  public JFunction<typename JElement_t::abscissa_type,
178  typename JResultType<typename JElement_t::ordinate_type>::result_type>
179  {
180  public:
181 
183 
184  typedef typename collection_type::abscissa_type abscissa_type;
185  typedef typename collection_type::ordinate_type ordinate_type;
186  typedef typename collection_type::value_type value_type;
187  typedef typename collection_type::distance_type distance_type;
188 
189  typedef typename collection_type::const_iterator const_iterator;
190  typedef typename collection_type::const_reverse_iterator const_reverse_iterator;
191  typedef typename collection_type::iterator iterator;
192  typedef typename collection_type::reverse_iterator reverse_iterator;
193 
196 
200 
201 
202  /**
203  * Default constructor.
204  */
206  {}
207 
208 
209  /**
210  * Recursive interpolation method implementation.
211  *
212  * \param pX pointer to abscissa values
213  * \return function value
214  */
215  virtual result_type evaluate(const argument_type* pX) const
216  {
217  if (this->empty()) {
218  return this->getExceptionHandler().action(JEmptyCollection("JHermiteSplineFunction<>::evaluate() no data."));
219  }
220 
221  const argument_type x = *pX;
222 
223  const_iterator p = this->lower_bound(x);
224 
225  if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
226  (p == this->end() && this->getDistance((--p)->getX(), x) > distance_type::precision)) {
227 
228  return this->getExceptionHandler().action(JValueOutOfRange("JHermiteSplineFunction::evaluate() x out of range."));
229  }
230 
231  const_iterator q = p--;
232 
233  const double dx = this->getDistance(p->getX(), q->getX());
234  const double t = this->getDistance(p->getX(), x) / dx;
235 
236  return h00(t)*p->getY() + h10(t)*p->getU()*dx + h01(t)*q->getY() + h11(t)*q->getU()*dx;
237  }
238 
239  protected:
240 
241  using collection_type::h00;
242  using collection_type::h10;
243  using collection_type::h01;
244  using collection_type::h11;
245  };
246 
247 
248  /**
249  * Template specialisation for spline interpolation method with returning JResultHesse data structure.
250  */
251  template<class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
252  class JHermiteSplineFunction<JElement_t,
253  JCollection_t,
254  JResultHesse<typename JResultType<typename JElement_t::ordinate_type>::result_type>,
255  JDistance_t> :
256  public JHermiteSplineCollection<JElement_t, JCollection_t, JDistance_t>,
257  public JFunction<typename JElement_t::abscissa_type,
258  JResultHesse<typename JResultType<typename JElement_t::ordinate_type>::result_type> >
259  {
260  public:
261 
263 
264  typedef typename collection_type::abscissa_type abscissa_type;
265  typedef typename collection_type::ordinate_type ordinate_type;
266  typedef typename collection_type::value_type value_type;
267  typedef typename collection_type::distance_type distance_type;
268 
269  typedef typename collection_type::const_iterator const_iterator;
270  typedef typename collection_type::const_reverse_iterator const_reverse_iterator;
271  typedef typename collection_type::iterator iterator;
272  typedef typename collection_type::reverse_iterator reverse_iterator;
273 
276 
280 
281 
282  /**
283  * Default constructor.
284  */
286  {}
287 
288 
289  /**
290  * Recursive interpolation method implementation.
291  *
292  * \param pX pointer to abscissa values
293  * \return function value
294  */
295  virtual result_type evaluate(const argument_type* pX) const
296  {
297  if (this->empty()) {
298  return this->getExceptionHandler().action(JEmptyCollection("JHermiteSplineFunction<>::evaluate() no data."));
299  }
300 
301  const argument_type x = *pX;
302 
303  const_iterator p = this->lower_bound(x);
304 
305 
306  if ((p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) ||
307  (p == this->end() && this->getDistance((--p)->getX(), x) > distance_type::precision)) {
308 
309  return this->getExceptionHandler().action(JValueOutOfRange("JHermiteSplineFunction::evaluate() x out of range."));
310  }
311 
312  const_iterator q = p--;
313 
314  const double dx = this->getDistance(p->getX(), q->getX());
315  const double t = this->getDistance(p->getX(), x) / dx;
316 
317  result.f = h00 (t)*p->getY() + h10 (t)*p->getU()*dx + h01 (t)*q->getY() + h11 (t)*q->getU()*dx;
318  result.fp = h00p(t)*p->getY()/dx + h10p(t)*p->getU() + h01p(t)*q->getY()/dx + h11p(t)*q->getU();
319 
320  return result;
321  }
322 
323 
324  protected:
325 
326  using collection_type::h00;
327  using collection_type::h10;
328  using collection_type::h01;
329  using collection_type::h11;
330 
331  using collection_type::h00p;
332  using collection_type::h10p;
333  using collection_type::h01p;
334  using collection_type::h11p;
335 
336  private:
338  };
339 
340 
341  /**
342  * Template specialisation for spline interpolation method with returning JResultPDF data structure.
343  *
344  * Note that the data structure of the elements in the collection should have the additional methods:
345  * <pre>
346  * ordinate_type getIntegral() const;
347  * void setIntegral(ordinate_type v);
348  * </pre>
349  * to get and set the integral values, respectively.
350  */
351  template<class JElement_t, template<class, class> class JCollection_t, class JDistance_t>
352  class JHermiteSplineFunction<JElement_t,
353  JCollection_t,
354  JResultPDF<typename JResultType<typename JElement_t::ordinate_type>::result_type>,
355  JDistance_t> :
356  public JHermiteSplineCollection<JElement_t, JCollection_t, JDistance_t>,
357  public JFunction<typename JElement_t::abscissa_type,
358  JResultPDF<typename JResultType<typename JElement_t::ordinate_type>::result_type> >
359  {
360  public:
361 
363 
364  typedef typename collection_type::abscissa_type abscissa_type;
365  typedef typename collection_type::ordinate_type ordinate_type;
366  typedef typename collection_type::value_type value_type;
367  typedef typename collection_type::distance_type distance_type;
368 
369  typedef typename collection_type::const_iterator const_iterator;
370  typedef typename collection_type::const_reverse_iterator const_reverse_iterator;
371  typedef typename collection_type::iterator iterator;
372  typedef typename collection_type::reverse_iterator reverse_iterator;
373 
376 
380 
381 
382  /**
383  * Default constructor.
384  */
386  {}
387 
388 
389  /**
390  * Recursive interpolation method implementation.
391  *
392  * \param pX pointer to abscissa values
393  * \return function value
394  */
395  virtual result_type evaluate(const argument_type* pX) const
396  {
397  if (this->empty()) {
398  return this->getExceptionHandler().action(JEmptyCollection("JHermiteSplineFunction<>::evaluate() no data."));
399  }
400 
401  const argument_type x = *pX;
402 
403  const_iterator p = this->lower_bound(x);
404 
405  if (p == this->begin() && this->getDistance(x, (p++)->getX()) > distance_type::precision) {
406 
407  try {
408 
409  result = this->getExceptionHandler().action(JValueOutOfRange("JHermiteSplineFunction1D<>::operator() x < xmin."));
410 
411  // overwrite integral values
412 
413  result.v = 0;
414  result.V = this->rbegin()->getIntegral();
415 
416  } catch(const JValueOutOfRange& exception) {
417  throw exception;
418  }
419 
420  return result;
421 
422  } else if (p == this->end() && this->getDistance((--p)->getX(), x) > distance_type::precision) {
423 
424  try {
425 
426  result = this->getExceptionHandler().action(JValueOutOfRange("JHermiteSplineFunction1D<>::operator() x > xmax."));
427 
428  // overwrite integral values
429 
430  result.v = this->rbegin()->getIntegral();
431  result.V = this->rbegin()->getIntegral();
432 
433  } catch(const JValueOutOfRange& exception) {
434  throw exception;
435  }
436 
437  return result;
438  }
439 
440  const_iterator q = p--;
441 
442  const double dx = this->getDistance(p->getX(), q->getX());
443  const double t = this->getDistance(p->getX(), x) / dx;
444 
445  result.f = h00 (t)*p->getY() + h10 (t)*p->getU()*dx + h01 (t)*q->getY() + h11 (t)*q->getU()*dx;
446  result.fp = h00p(t)*p->getY()/dx + h10p(t)*p->getU() + h01p(t)*q->getY()/dx + h11p(t)*q->getU();
447  result.v = (p->getIntegral() +
448  (H00 (t)*p->getY() + H10 (t)*p->getU()*dx + H01 (t)*q->getY() + H11 (t)*q->getU()*dx)*dx);
449  result.V = this->rbegin()->getIntegral();
450 
451  return result;
452  }
453 
454 
455  protected:
456 
457  using collection_type::h00;
458  using collection_type::h10;
459  using collection_type::h01;
460  using collection_type::h11;
461 
462  using collection_type::h00p;
463  using collection_type::h10p;
464  using collection_type::h01p;
465  using collection_type::h11p;
466 
467  using collection_type::H00;
468  using collection_type::H10;
469  using collection_type::H01;
470  using collection_type::H11;
471 
472  /**
473  * Determination of derivatives.
474  */
475  virtual void do_compile()
476  {
477  if (!this->empty()) {
478 
479  collection_type::do_compile();
480 
481  this->begin()->setIntegral(JMATH::zero);
482 
483  for (iterator j = this->begin(), i = j++; j != this->end(); ++i, ++j) {
484 
485  const double dx = this->getDistance(i->getX(), j->getX());
486  const ordinate_type y = i->getY() + j->getY();
487  const ordinate_type z = i->getU() - j->getU();
488 
489  const ordinate_type v = dx * 0.50 * y;
490  const ordinate_type w = dx * 1.00 * z*dx/12.0;
491 
492  j->setIntegral(i->getIntegral() + v + w);
493  }
494  }
495  }
496 
497  private:
499  };
500 
501 
502  /**
503  * Template class for spline interpolation in 1D
504  *
505  * This class implements the JFunction1D interface.
506  */
507  template<class JElement_t,
508  template<class, class> class JCollection_t,
509  class JResult_t = typename JElement_t::ordinate_type,
512  public JHermiteSplineFunction<JElement_t, JCollection_t, JResult_t, JDistance_t>,
513  public JFunction1D<typename JElement_t::abscissa_type, JResult_t>
514  {
515  public:
516 
518 
523 
528 
530 
534 
535 
536  /**
537  * Default contructor.
538  */
540  {}
541  };
542 
543 
544  /**
545  * Functional map with spline interpolation.
546  */
547  template<class JKey_t,
548  class JValue_t,
549  template<class, class, class> class JMap_t,
550  class JResult_t,
551  class JDistance_t = JDistance<JKey_t> >
553  public JMap_t<JKey_t, JValue_t, JDistance_t>,
554  public JFunction<JKey_t, JResult_t>
555  {
556  public:
557 
558  typedef JMap_t<JKey_t, JValue_t, JDistance_t> collection_type;
560 
561  typedef typename collection_type::abscissa_type abscissa_type;
562  typedef typename collection_type::ordinate_type ordinate_type;
563  typedef typename collection_type::value_type value_type;
564  typedef typename collection_type::distance_type distance_type;
565 
566  typedef typename collection_type::const_iterator const_iterator;
567  typedef typename collection_type::const_reverse_iterator const_reverse_iterator;
568  typedef typename collection_type::iterator iterator;
569  typedef typename collection_type::reverse_iterator reverse_iterator;
570 
573  typedef typename function_type::JExceptionHandler exceptionhandler_type;
574 
579 
580 
581  /**
582  * Default constructor.
583  */
585  {}
586 
587 
588  /**
589  * Recursive interpolation method implementation.
590  *
591  * \param pX pointer to abscissa values
592  * \return function value
593  */
594  virtual result_type evaluate(const argument_type* pX) const
595  {
596  const argument_type x = *pX;
597 
598  ++pX; // next argument value
599 
600  const_iterator p = this->begin();
601 
602  for (typename JHermiteSplineFunction1D_t::iterator q = buffer.begin(); q != buffer.end(); ++q, ++p) {
603  q->getY() = JFunction<argument_type, data_type>::getValue(p->getY(), pX);
604  }
605 
606  buffer.compile();
607 
608  return buffer(x);
609  }
610 
611 
612  private:
613  /**
614  * Function compilation.
615  */
616  virtual void do_compile()
617  {
618  buffer.clear();
619 
620  for (iterator i = this->begin(); i != this->end(); ++i) {
621  buffer.put(i->getX(), data_type());
622  }
623  }
624 
625 
627  };
628 
629 
630  /**
631  * Conversion of data points to integral values.
632  *
633  * The integration includes the use of 2nd derivatives of the data points of the input spline interpolating function.
634  *
635  * \param input collection
636  * \param output mappable collection
637  * \return integral
638  */
639  template<class JElement_t,
640  template<class, class> class JCollection_t,
641  class JResult_t,
642  class JDistance_t>
643  inline typename JElement_t::ordinate_type
645  typename JMappable<JElement_t>::map_type& output)
646  {
647  typedef typename JElement_t::ordinate_type ordinate_type;
649 
650  ordinate_type V(JMATH::zero);
651 
652  if (input.getSize() > 1) {
653 
654  output.put(input.begin()->getX(), V);
655 
656  for (const_iterator j = input.begin(), i = j++; j != input.end(); ++i, ++j) {
657 
658  const double dx = input.getDistance(i->getX(), j->getX());
659  const ordinate_type y = i->getY() + j->getY();
660  const ordinate_type z = i->getU() - j->getU();
661 
662  const ordinate_type v = dx * 0.50 * y;
663  const ordinate_type w = dx * 1.00 * z*dx/12.0;
664 
665  V += v + w;
666 
667  output.put(j->getX(), V);
668  }
669  }
670 
671  return V;
672  }
673 
674 
675  /**
676  * Conversion of data points to integral values.
677  *
678  * The integration directly uses the integral values of the input spline interpolating function.
679  *
680  * \param input collection
681  * \param output mappable collection
682  * \return integral
683  */
684  template<class JElement_t,
685  template<class, class> class JCollection_t,
686  class JDistance_t>
687  inline typename JElement_t::ordinate_type
688  integrate(const JHermiteSplineFunction1D<JElement_t, JCollection_t, JResultPDF<typename JElement_t::ordinate_type>, JDistance_t>& input,
689  typename JMappable<JElement_t>::map_type& output)
690  {
691  typedef typename JElement_t::ordinate_type ordinate_type;
694 
695  if (input.getSize() > 1) {
696 
697  for (const_iterator i = input.begin(); i != input.end(); ++i) {
698  output.put(i->getX(), i->getIntegral());
699  }
700 
701  return input.rbegin()->getIntegral();
702  }
703 
704  return JMATH::zero;
705  }
706 }
707 
708 #endif
static abscissa_type h01p(abscissa_type t)
function_type::argument_type argument_type
JHermiteSplineFunction1D_t buffer
collection_type::value_type value_type
collection_type::value_type value_type
Exceptions.
collection_type::const_iterator const_iterator
void compile(const bool monotone)
Determination of derivatives.
collection_type::ordinate_type ordinate_type
static abscissa_type h00(abscissa_type t)
collection_type::const_reverse_iterator const_reverse_iterator
JHermiteSplineFunction1D()
Default contructor.
Template class for distance evaluation.
Definition: JDistance.hh:24
This include file containes various data structures that can be used as specific return types for the...
functional_type::argument_type argument_type
Definition: JFunctional.hh:323
JHermiteSplineMap()
Default constructor.
JCollection_t< JElement_t, JDistance_t > collection_type
collection_type::value_type value_type
static abscissa_type H01(abscissa_type t)
Template interface definition for associative collection of elements.
static const JZero zero
Function object to assign zero value.
Definition: JZero.hh:94
static abscissa_type h11(abscissa_type t)
Definition of zero value for any class.
virtual void do_compile()
Determination of derivatives.
Template definition of function object interface in one dimension.
Definition: JFunctional.hh:317
collection_type::const_iterator const_iterator
double getDistance(const JFirst_t &first, const JSecond_t &second)
Get distance between objects.
Definition: JMathToolkit.hh:98
JFunction1D< abscissa_type, JResult_t > function_type
JResultType< ordinate_type >::result_type data_type
virtual void do_compile()
Function compilation.
Exception for missing value.
Definition: JException.hh:180
JMap_t< JKey_t, JValue_t, JDistance_t > collection_type
collection_type::abscissa_type abscissa_type
static result_type getValue(const JFunctional &function, const argument_type *pX)
Recursive function value evaluation.
Definition: JFunctional.hh:106
Template definition of function object interface in multidimensions.
Definition: JFunctional.hh:301
collection_type::reverse_iterator reverse_iterator
static abscissa_type h00p(abscissa_type t)
static abscissa_type h11p(abscissa_type t)
collection_type::distance_type distance_type
collection_type::distance_type distance_type
collection_type::abscissa_type abscissa_type
static abscissa_type h10p(abscissa_type t)
function_type::result_type result_type
Data structure for result including value, first derivative and integrals of function.
Definition: JResult.hh:211
static abscissa_type H10(abscissa_type t)
Template definition of function object interface.
Definition: JFunctional.hh:31
functional_type::result_type result_type
Definition: JFunctional.hh:324
Auxiliary class to evaluate result type.
Definition: JFunctional.hh:377
static abscissa_type h01(abscissa_type t)
collection_type::const_reverse_iterator const_reverse_iterator
void put(typename JClass< key_type >::argument_type key, typename JClass< mapped_type >::argument_type value)
Put pair-wise element (key,value) into collection.
collection_type::iterator iterator
Template class to retreive underlying collection for the given template map.
collection_type::abscissa_type abscissa_type
collection_type::reverse_iterator reverse_iterator
Template base class spline interpolations.
function_type::argument_type argument_type
Exception handler for functional object.
Definition: JFunctional.hh:129
Template class for spline interpolation in 1D.
static abscissa_type H00(abscissa_type t)
function_type::JExceptionHandler exceptionhandler_type
collection_type::ordinate_type ordinate_type
virtual result_type evaluate(const argument_type *pX) const
Recursive interpolation method implementation.
Functional map with spline interpolation.
collection_type::iterator iterator
const JExceptionHandler & getExceptionHandler() const
Get exception handler.
Definition: JFunctional.hh:275
virtual result_type evaluate(const argument_type *pX) const
Recursive interpolation method implementation.
Exception for division by zero.
Definition: JException.hh:252
JHermiteSplineCollection()
Default constructor.
collection_type::iterator iterator
collection_type::reverse_iterator reverse_iterator
Exception for an empty collection.
Definition: JException.hh:126
JFunction< JKey_t, JResult_t > function_type
functional_type::argument_type argument_type
Definition: JFunctional.hh:307
JHermiteSplineFunction1D< JSplineElement2D< argument_type, data_type >, JMapCollection< JMap_t >::template collection_type, result_type > JHermiteSplineFunction1D_t
JHermiteSplineCollection< JElement_t, JCollection_t, JDistance_t > collection_type
collection_type::distance_type distance_type
Exception for accessing a value in a collection that is outside of its range.
Definition: JException.hh:144
Template definition for functional collection with spline interpolation.
static abscissa_type H11(abscissa_type t)
collection_type::ordinate_type ordinate_type
functional_type::result_type result_type
Definition: JFunctional.hh:308
Data structure for result including value and first derivative of function.
Definition: JResult.hh:40
static abscissa_type h10(abscissa_type t)
function_type::result_type result_type
collection_type::const_reverse_iterator const_reverse_iterator
JElement_t::ordinate_type integrate(const JCollection< JElement_t, JDistance_t > &input, typename JMappable< JElement_t >::map_type &output)
Conversion of data points to integral values.
Definition: JCollection.hh:793
collection_type::const_iterator const_iterator
function_type::JExceptionHandler exceptionhandler_type