Chemical Data Processing Library C++ API - Version 1.4.0
Functional.hpp
Go to the documentation of this file.
1 /*
2  * Functional.hpp
3  *
4  * Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library 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 GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with this library; see the file COPYING. If not, write to
18  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21 
27 #ifndef CDPL_MATH_FUNCTIONAL_HPP
28 #define CDPL_MATH_FUNCTIONAL_HPP
29 
30 #include <boost/algorithm/clamp.hpp>
31 
32 #include "CDPL/Math/Check.hpp"
33 #include "CDPL/Math/CommonType.hpp"
34 #include "CDPL/Math/TypeTraits.hpp"
35 #include "CDPL/Base/Exceptions.hpp"
36 
37 
38 namespace CDPL
39 {
40 
41  namespace Math
42  {
43 
44  template <typename E>
45  class VectorExpression;
46  template <typename E>
47  class MatrixExpression;
48  template <typename E>
49  class QuaternionExpression;
50  template <typename E>
51  class GridExpression;
52 
63  template <typename T1, typename T2>
64  struct ScalarBinaryAssignmentFunctor
65  {
66 
70  typedef T1 Argument1Type;
71 
75  typedef const T2& Argument2Type;
76  };
77 
83  template <typename T1, typename T2>
84  struct ScalarAssignment : public ScalarBinaryAssignmentFunctor<T1, T2>
85  {
86 
87  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument1Type Argument1Type;
88  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument2Type Argument2Type;
89 
95  static void apply(Argument1Type t1, Argument2Type t2)
96  {
97  t1 = t2;
98  }
99  };
100 
106  template <typename T1, typename T2>
107  struct ScalarAdditionAssignment : public ScalarBinaryAssignmentFunctor<T1, T2>
108  {
109 
110  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument1Type Argument1Type;
111  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument2Type Argument2Type;
112 
118  static void apply(Argument1Type t1, Argument2Type t2)
119  {
120  t1 += t2;
121  }
122  };
123 
129  template <typename T1, typename T2>
130  struct ScalarSubtractionAssignment : public ScalarBinaryAssignmentFunctor<T1, T2>
131  {
132 
133  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument1Type Argument1Type;
134  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument2Type Argument2Type;
135 
141  static void apply(Argument1Type t1, Argument2Type t2)
142  {
143  t1 -= t2;
144  }
145  };
146 
152  template <typename T1, typename T2>
153  struct ScalarMultiplicationAssignment : public ScalarBinaryAssignmentFunctor<T1, T2>
154  {
155 
156  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument1Type Argument1Type;
157  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument2Type Argument2Type;
158 
164  static void apply(Argument1Type t1, Argument2Type t2)
165  {
166  t1 *= t2;
167  }
168  };
169 
175  template <typename T1, typename T2>
176  struct ScalarDivisionAssignment : public ScalarBinaryAssignmentFunctor<T1, T2>
177  {
178 
179  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument1Type Argument1Type;
180  typedef typename ScalarBinaryAssignmentFunctor<T1, T2>::Argument2Type Argument2Type;
181 
187  static void apply(Argument1Type t1, Argument2Type t2)
188  {
189  t1 /= t2;
190  }
191  };
192 
201  template <typename T>
202  struct ScalarUnaryFunctor
203  {
204 
208  typedef T ValueType;
209 
213  typedef const T& ArgumentType;
214 
218  typedef ValueType ResultType;
219  };
220 
225  template <typename T>
226  struct ScalarNegation : public ScalarUnaryFunctor<T>
227  {
228 
229  typedef typename ScalarUnaryFunctor<T>::ValueType ValueType;
230  typedef typename ScalarUnaryFunctor<T>::ArgumentType ArgumentType;
231  typedef typename ScalarUnaryFunctor<T>::ResultType ResultType;
232 
238  static ResultType apply(ArgumentType v)
239  {
240  return -v;
241  }
242  };
243 
248  template <typename T>
249  struct ScalarConjugation : public ScalarUnaryFunctor<T>
250  {
251 
252  typedef typename ScalarUnaryFunctor<T>::ValueType ValueType;
253  typedef typename ScalarUnaryFunctor<T>::ArgumentType ArgumentType;
254  typedef typename ScalarUnaryFunctor<T>::ResultType ResultType;
255 
261  static ResultType apply(ArgumentType v)
262  {
263  return TypeTraits<ValueType>::conj(v);
264  }
265  };
266 
271  template <typename T>
272  struct ScalarRealUnaryFunctor
273  {
274 
278  typedef T ValueType;
279 
283  typedef const T& ArgumentType;
284 
288  typedef typename TypeTraits<T>::RealType ResultType;
289  };
290 
295  template <typename T>
296  struct ScalarReal : public ScalarRealUnaryFunctor<T>
297  {
298 
299  typedef typename ScalarUnaryFunctor<T>::ValueType ValueType;
300  typedef typename ScalarUnaryFunctor<T>::ArgumentType ArgumentType;
301  typedef typename ScalarUnaryFunctor<T>::ResultType ResultType;
302 
308  static ResultType apply(ArgumentType v)
309  {
310  return TypeTraits<ValueType>::real(v);
311  }
312  };
313 
318  template <typename T>
319  struct ScalarImaginary : public ScalarRealUnaryFunctor<T>
320  {
321 
322  typedef typename ScalarUnaryFunctor<T>::ValueType ValueType;
323  typedef typename ScalarUnaryFunctor<T>::ArgumentType ArgumentType;
324  typedef typename ScalarUnaryFunctor<T>::ResultType ResultType;
325 
331  static ResultType apply(ArgumentType v)
332  {
333  return TypeTraits<ValueType>::imag(v);
334  }
335  };
336 
346  template <typename T1, typename T2>
347  struct ScalarBinaryFunctor
348  {
349 
353  typedef const T1& Argument1Type;
354 
358  typedef const T2& Argument2Type;
359 
363  typedef typename CommonType<T1, T2>::Type ResultType;
364  };
365 
371  template <typename T1, typename T2>
372  struct ScalarAddition : public ScalarBinaryFunctor<T1, T2>
373  {
374 
375  typedef typename ScalarBinaryFunctor<T1, T2>::Argument1Type Argument1Type;
376  typedef typename ScalarBinaryFunctor<T1, T2>::Argument2Type Argument2Type;
377  typedef typename ScalarBinaryFunctor<T1, T2>::ResultType ResultType;
378 
385  static ResultType apply(Argument1Type t1, Argument2Type t2)
386  {
387  return (t1 + t2);
388  }
389  };
390 
396  template <typename T1, typename T2>
397  struct ScalarSubtraction : public ScalarBinaryFunctor<T1, T2>
398  {
399 
400  typedef typename ScalarBinaryFunctor<T1, T2>::Argument1Type Argument1Type;
401  typedef typename ScalarBinaryFunctor<T1, T2>::Argument2Type Argument2Type;
402  typedef typename ScalarBinaryFunctor<T1, T2>::ResultType ResultType;
403 
410  static ResultType apply(Argument1Type t1, Argument2Type t2)
411  {
412  return (t1 - t2);
413  }
414  };
415 
421  template <typename T1, typename T2>
422  struct ScalarMultiplication : public ScalarBinaryFunctor<T1, T2>
423  {
424 
425  typedef typename ScalarBinaryFunctor<T1, T2>::Argument1Type Argument1Type;
426  typedef typename ScalarBinaryFunctor<T1, T2>::Argument2Type Argument2Type;
427  typedef typename ScalarBinaryFunctor<T1, T2>::ResultType ResultType;
428 
435  static ResultType apply(Argument1Type t1, Argument2Type t2)
436  {
437  return (t1 * t2);
438  }
439  };
440 
446  template <typename T1, typename T2>
447  struct ScalarDivision : public ScalarBinaryFunctor<T1, T2>
448  {
449 
450  typedef typename ScalarBinaryFunctor<T1, T2>::Argument1Type Argument1Type;
451  typedef typename ScalarBinaryFunctor<T1, T2>::Argument2Type Argument2Type;
452  typedef typename ScalarBinaryFunctor<T1, T2>::ResultType ResultType;
453 
460  static ResultType apply(Argument1Type t1, Argument2Type t2)
461  {
462  return (t1 / t2);
463  }
464  };
465 
471  template <typename V1, typename V2>
472  struct VectorScalarBinaryFunctor
473  {
474 
478  typedef typename CommonType<typename V1::ValueType, typename V2::ValueType>::Type ResultType;
479  };
480 
486  template <typename V1, typename V2>
487  struct VectorInnerProduct : public VectorScalarBinaryFunctor<V1, V2>
488  {
489 
490  typedef typename VectorScalarBinaryFunctor<V1, V2>::ResultType ResultType;
491 
499  static ResultType apply(const VectorExpression<V1>& e1, const VectorExpression<V2>& e2)
500  {
501  typedef typename CommonType<typename V1::SizeType, typename V2::SizeType>::Type SizeType;
502 
503  SizeType size = CDPL_MATH_CHECK_SIZE_EQUALITY(SizeType(e1().getSize()), SizeType(e2().getSize()), Base::SizeError);
504  ResultType res = ResultType();
505 
506  for (SizeType i = 0; i < size; i++)
507  res += e1()(i) * e2()(i);
508 
509  return res;
510  }
511  };
512 
519  template <typename V1, typename V2, typename T>
520  struct VectorAngleCosine : public VectorScalarBinaryFunctor<V1, V2>
521  {
522 
523  typedef typename CommonType<typename VectorInnerProduct<V1, V2>::ResultType, T>::Type ResultType;
524 
533  static ResultType apply(const VectorExpression<V1>& e1, const VectorExpression<V2>& e2, const T& sd, bool clamp)
534  {
535  ResultType res = VectorInnerProduct<V1, V2>::apply(e1, e2) / sd;
536 
537  if (!clamp)
538  return res;
539 
540  return boost::algorithm::clamp(res, ResultType(-1), ResultType(1));
541  }
542  };
543 
549  template <typename V1, typename V2>
550  struct VectorBooleanBinaryFunctor
551  {
552 
556  typedef bool ResultType;
557 
561  typedef typename CommonType<typename V1::SizeType, typename V2::SizeType>::Type SizeType;
562 
566  typedef typename CommonType<typename V1::ValueType, typename V2::ValueType>::Type ValueType;
567  };
568 
574  template <typename V1, typename V2>
575  struct VectorEquality : public VectorBooleanBinaryFunctor<V1, V2>
576  {
577 
578  typedef typename VectorBooleanBinaryFunctor<V1, V2>::SizeType SizeType;
579  typedef typename VectorBooleanBinaryFunctor<V1, V2>::ValueType ValueType;
580  typedef typename VectorBooleanBinaryFunctor<V1, V2>::ResultType ResultType;
581 
588  static ResultType apply(const VectorExpression<V1>& e1, const VectorExpression<V2>& e2)
589  {
590  if (SizeType(e1().getSize()) != SizeType(e2().getSize()))
591  return false;
592 
593  for (SizeType i = 0, size = e1().getSize(); i < size; i++)
594  if (ValueType(e1()(i)) != ValueType(e2()(i)))
595  return false;
596 
597  return true;
598  }
599  };
600 
607  template <typename V1, typename V2, typename T>
608  struct Scalar3VectorBooleanTernaryFunctor
609  {
610 
614  typedef bool ResultType;
615 
619  typedef const T& Argument3Type;
620 
624  typedef typename CommonType<typename V1::SizeType, typename V2::SizeType>::Type SizeType;
625 
629  typedef typename CommonType<typename V1::ValueType, typename V2::ValueType>::Type ValueType;
630  };
631 
638  template <typename V1, typename V2, typename T>
639  struct VectorToleranceEquality : public Scalar3VectorBooleanTernaryFunctor<V1, V2, T>
640  {
641 
642  typedef typename Scalar3VectorBooleanTernaryFunctor<V1, V2, T>::SizeType SizeType;
643  typedef typename Scalar3VectorBooleanTernaryFunctor<V1, V2, T>::ValueType ValueType;
644  typedef typename Scalar3VectorBooleanTernaryFunctor<V1, V2, T>::ResultType ResultType;
645  typedef typename Scalar3VectorBooleanTernaryFunctor<V1, V2, T>::Argument3Type Argument3Type;
646 
654  static ResultType apply(const VectorExpression<V1>& e1, const VectorExpression<V2>& e2, Argument3Type epsilon)
655  {
656  typedef typename CommonType<typename TypeTraits<ValueType>::RealType, T>::Type ComparisonType;
657 
658  if (SizeType(e1().getSize()) != SizeType(e2().getSize()))
659  return false;
660 
661  ComparisonType norm_inf_max(epsilon);
662 
663  for (SizeType i = 0, size = e1().getSize(); i < size; i++)
664  if (ComparisonType(TypeTraits<ValueType>::normInf(e2()(i) - e1()(i))) > norm_inf_max)
665  return false;
666 
667  return true;
668  }
669  };
670 
676  template <typename V1, typename V2>
677  struct VectorBinaryFunctor
678  {
679 
683  typedef typename CommonType<typename V1::ValueType, typename V2::ValueType>::Type ResultType;
684  };
685 
691  template <typename V1, typename V2>
692  struct VectorCrossProduct : public VectorBinaryFunctor<V1, V2>
693  {
694 
695  typedef typename VectorScalarBinaryFunctor<V1, V2>::ResultType ResultType;
696 
708  template <typename E1, typename E2, typename SizeType>
709  static ResultType apply(const VectorExpression<E1>& e1, const VectorExpression<E2>& e2, SizeType i)
710  {
711  CDPL_MATH_CHECK(e1().getSize() == 3, "Invalid vector size", Base::SizeError);
712  CDPL_MATH_CHECK(e2().getSize() == 3, "Invalid vector size", Base::SizeError);
713 
714  switch (i) {
715 
716  case 0:
717  return (e1()(1) * e2()(2) - e1()(2) * e2()(1)); // c1 = a2 * b3 - a3 * b2;
718 
719  case 1:
720  return (e1()(2) * e2()(0) - e1()(0) * e2()(2)); // c2 = a3 * b1 - a1 * b3;
721 
722  case 2:
723  return (e1()(0) * e2()(1) - e1()(1) * e2()(0)); // c3 = a1 * b2 - a2 * b1;
724 
725  default:
726  return ResultType();
727  }
728  }
729  };
730 
735  template <typename V>
736  struct VectorScalarUnaryFunctor
737  {
738 
742  typedef typename V::ValueType ResultType;
743 
747  typedef typename V::SizeType SizeType;
748  };
749 
754  template <typename V>
755  struct VectorElementSum : public VectorScalarUnaryFunctor<V>
756  {
757 
758  typedef typename VectorScalarUnaryFunctor<V>::ResultType ResultType;
759 
765  static ResultType apply(const VectorExpression<V>& e)
766  {
767  typedef typename V::SizeType SizeType;
768 
769  ResultType res = ResultType();
770 
771  for (SizeType i = 0, size = e().getSize(); i < size; i++)
772  res += e()(i);
773 
774  return res;
775  }
776  };
777 
778  template <typename V>
783  struct VectorScalarRealUnaryFunctor
784  {
785 
789  typedef typename V::ValueType ValueType;
790 
794  typedef typename TypeTraits<ValueType>::RealType RealType;
795 
799  typedef RealType ResultType;
800  };
801 
806  template <typename V>
807  struct VectorNorm1 : public VectorScalarRealUnaryFunctor<V>
808  {
809 
810  typedef typename VectorScalarRealUnaryFunctor<V>::ValueType ValueType;
811  typedef typename VectorScalarRealUnaryFunctor<V>::RealType RealType;
812  typedef typename VectorScalarRealUnaryFunctor<V>::ResultType ResultType;
813 
819  static ResultType apply(const VectorExpression<V>& e)
820  {
821  typedef typename V::SizeType SizeType;
822 
823  RealType res = RealType();
824 
825  for (SizeType i = 0, size = e().getSize(); i < size; i++)
826  res += TypeTraits<ValueType>::norm1(e()(i));
827 
828  return res;
829  }
830  };
831 
836  template <typename V>
837  struct VectorNorm2 : public VectorScalarRealUnaryFunctor<V>
838  {
839 
840  typedef typename VectorScalarRealUnaryFunctor<V>::ValueType ValueType;
841  typedef typename VectorScalarRealUnaryFunctor<V>::RealType RealType;
842  typedef typename VectorScalarRealUnaryFunctor<V>::ResultType ResultType;
843 
849  static ResultType apply(const VectorExpression<V>& e)
850  {
851  typedef typename V::SizeType SizeType;
852 
853  RealType res2 = RealType();
854 
855  for (SizeType i = 0, size = e().getSize(); i < size; i++) {
856  RealType t = TypeTraits<ValueType>::norm2(e()(i));
857 
858  res2 += t * t;
859  }
860 
861  return TypeTraits<RealType>::sqrt(res2);
862  }
863  };
864 
869  template <typename V>
870  struct VectorNormInfinity : public VectorScalarRealUnaryFunctor<V>
871  {
872 
873  typedef typename VectorScalarRealUnaryFunctor<V>::ValueType ValueType;
874  typedef typename VectorScalarRealUnaryFunctor<V>::RealType RealType;
875  typedef typename VectorScalarRealUnaryFunctor<V>::ResultType ResultType;
876 
882  static ResultType apply(const VectorExpression<V>& e)
883  {
884  typedef typename V::SizeType SizeType;
885 
886  RealType res = RealType();
887 
888  for (SizeType i = 0, size = e().getSize(); i < size; i++) {
889  RealType t = TypeTraits<ValueType>::normInf(e()(i));
890 
891  if (t > res)
892  res = t;
893  }
894 
895  return res;
896  }
897  };
898 
903  template <typename V>
904  struct VectorScalarIndexUnaryFunctor
905  {
906 
910  typedef typename V::ValueType ValueType;
911 
915  typedef typename TypeTraits<ValueType>::RealType RealType;
916 
920  typedef typename V::SizeType ResultType;
921  };
922 
927  template <typename V>
928  struct VectorNormInfinityIndex : public VectorScalarIndexUnaryFunctor<V>
929  {
930 
931  typedef typename VectorScalarIndexUnaryFunctor<V>::ValueType ValueType;
932  typedef typename VectorScalarIndexUnaryFunctor<V>::RealType RealType;
933  typedef typename VectorScalarIndexUnaryFunctor<V>::ResultType ResultType;
934 
940  static ResultType apply(const VectorExpression<V>& e)
941  {
942  typedef typename V::SizeType SizeType;
943 
944  RealType norm = RealType();
945  ResultType res = ResultType(0);
946 
947  for (SizeType i = 0, size = e().getSize(); i < size; i++) {
948  RealType t = TypeTraits<ValueType>::normInf(e()(i));
949 
950  if (t > norm) {
951  norm = t;
952  res = ResultType(i);
953  }
954  }
955 
956  return res;
957  }
958  };
959 
965  template <typename M1, typename M2>
966  struct MatrixBooleanBinaryFunctor
967  {
968 
972  typedef bool ResultType;
973 
977  typedef typename CommonType<typename M1::SizeType, typename M2::SizeType>::Type SizeType;
978 
982  typedef typename CommonType<typename M1::ValueType, typename M2::ValueType>::Type ValueType;
983  };
984 
990  template <typename M1, typename M2>
991  struct MatrixEquality : public MatrixBooleanBinaryFunctor<M1, M2>
992  {
993 
994  typedef typename MatrixBooleanBinaryFunctor<M1, M2>::SizeType SizeType;
995  typedef typename MatrixBooleanBinaryFunctor<M1, M2>::ValueType ValueType;
996  typedef typename MatrixBooleanBinaryFunctor<M1, M2>::ResultType ResultType;
997 
1004  static ResultType apply(const MatrixExpression<M1>& e1, const MatrixExpression<M2>& e2)
1005  {
1006  if (SizeType(e1().getSize1()) != SizeType(e2().getSize1()))
1007  return false;
1008 
1009  if (SizeType(e1().getSize2()) != SizeType(e2().getSize2()))
1010  return false;
1011 
1012  for (SizeType i = 0, size1 = e1().getSize1(); i < size1; i++)
1013  for (SizeType j = 0, size2 = e1().getSize2(); j < size2; j++)
1014  if (ValueType(e1()(i, j)) != ValueType(e2()(i, j)))
1015  return false;
1016 
1017  return true;
1018  }
1019  };
1020 
1027  template <typename M1, typename M2, typename T>
1028  struct Scalar3MatrixBooleanTernaryFunctor
1029  {
1030 
1034  typedef bool ResultType;
1035 
1039  typedef const T& Argument3Type;
1040 
1044  typedef typename CommonType<typename M1::SizeType, typename M2::SizeType>::Type SizeType;
1045 
1049  typedef typename CommonType<typename M1::ValueType, typename M2::ValueType>::Type ValueType;
1050  };
1051 
1058  template <typename M1, typename M2, typename T>
1059  struct MatrixToleranceEquality : public Scalar3MatrixBooleanTernaryFunctor<M1, M2, T>
1060  {
1061 
1062  typedef typename Scalar3MatrixBooleanTernaryFunctor<M1, M2, T>::SizeType SizeType;
1063  typedef typename Scalar3MatrixBooleanTernaryFunctor<M1, M2, T>::ValueType ValueType;
1064  typedef typename Scalar3MatrixBooleanTernaryFunctor<M1, M2, T>::ResultType ResultType;
1065  typedef typename Scalar3MatrixBooleanTernaryFunctor<M1, M2, T>::Argument3Type Argument3Type;
1066 
1074  static ResultType apply(const MatrixExpression<M1>& e1, const MatrixExpression<M2>& e2, Argument3Type epsilon)
1075  {
1076  typedef typename CommonType<typename TypeTraits<ValueType>::RealType, T>::Type ComparisonType;
1077 
1078  if (SizeType(e1().getSize1()) != SizeType(e2().getSize1()))
1079  return false;
1080 
1081  if (SizeType(e1().getSize2()) != SizeType(e2().getSize2()))
1082  return false;
1083 
1084  ComparisonType norm_inf_max(epsilon);
1085 
1086  for (SizeType i = 0, size1 = e1().getSize1(); i < size1; i++)
1087  for (SizeType j = 0, size2 = e1().getSize2(); j < size2; j++)
1088  if (ComparisonType(TypeTraits<ValueType>::normInf(e2()(i, j) - e1()(i, j))) > norm_inf_max)
1089  return false;
1090 
1091  return true;
1092  }
1093  };
1094 
1099  template <typename M>
1100  struct MatrixScalarUnaryFunctor
1101  {
1102 
1106  typedef typename M::ValueType ResultType;
1107  };
1108 
1113  template <typename M>
1114  struct MatrixElementSum : public MatrixScalarUnaryFunctor<M>
1115  {
1116 
1117  typedef typename MatrixScalarUnaryFunctor<M>::ResultType ResultType;
1118 
1124  static ResultType apply(const MatrixExpression<M>& e)
1125  {
1126  typedef typename M::SizeType SizeType;
1127 
1128  ResultType res = ResultType();
1129  SizeType size1 = e().getSize1();
1130  SizeType size2 = e().getSize2();
1131 
1132  for (SizeType i = 0; i < size1; i++)
1133  for (SizeType j = 0; j < size2; j++)
1134  res += e()(i, j);
1135 
1136  return res;
1137  }
1138  };
1139 
1144  template <typename M>
1145  struct MatrixTrace : public MatrixScalarUnaryFunctor<M>
1146  {
1147 
1148  typedef typename MatrixScalarUnaryFunctor<M>::ResultType ResultType;
1149 
1156  static ResultType apply(const MatrixExpression<M>& e)
1157  {
1158  typedef typename M::SizeType SizeType;
1159 
1160  SizeType size = CDPL_MATH_CHECK_SIZE_EQUALITY(e().getSize1(), e().getSize2(), Base::SizeError);
1161  ResultType res = ResultType();
1162 
1163  for (SizeType i = 0; i < size; i++)
1164  res += e()(i, i);
1165 
1166  return res;
1167  }
1168  };
1169 
1174  template <typename M>
1175  struct MatrixScalarRealUnaryFunctor
1176  {
1177 
1181  typedef typename M::ValueType ValueType;
1182 
1186  typedef typename TypeTraits<ValueType>::RealType RealType;
1187 
1191  typedef RealType ResultType;
1192  };
1193 
1198  template <typename M>
1199  struct MatrixNorm1 : public MatrixScalarRealUnaryFunctor<M>
1200  {
1201 
1202  typedef typename MatrixScalarRealUnaryFunctor<M>::ValueType ValueType;
1203  typedef typename MatrixScalarRealUnaryFunctor<M>::RealType RealType;
1204  typedef typename MatrixScalarRealUnaryFunctor<M>::ResultType ResultType;
1205 
1211  static ResultType apply(const MatrixExpression<M>& e)
1212  {
1213  typedef typename M::SizeType SizeType;
1214 
1215  RealType res = RealType();
1216  SizeType size1 = e().getSize1();
1217  SizeType size2 = e().getSize2();
1218 
1219  for (SizeType j = 0; j < size2; j++) {
1220  RealType t = RealType();
1221 
1222  for (SizeType i = 0; i < size1; i++)
1223  t += TypeTraits<ValueType>::norm1(e()(i, j));
1224 
1225  if (t > res)
1226  res = t;
1227  }
1228 
1229  return res;
1230  }
1231  };
1232 
1237  template <typename M>
1238  struct MatrixNormFrobenius : public MatrixScalarRealUnaryFunctor<M>
1239  {
1240 
1241  typedef typename MatrixScalarRealUnaryFunctor<M>::ValueType ValueType;
1242  typedef typename MatrixScalarRealUnaryFunctor<M>::RealType RealType;
1243  typedef typename MatrixScalarRealUnaryFunctor<M>::ResultType ResultType;
1244 
1250  static ResultType apply(const MatrixExpression<M>& e)
1251  {
1252  typedef typename M::SizeType SizeType;
1253 
1254  RealType res2 = RealType();
1255  SizeType size1 = e().getSize1();
1256  SizeType size2 = e().getSize2();
1257 
1258  for (SizeType i = 0; i < size1; i++) {
1259  for (SizeType j = 0; j < size2; j++) {
1260  RealType t = TypeTraits<ValueType>::norm2(e()(i, j));
1261 
1262  res2 += t * t;
1263  }
1264  }
1265 
1266  return TypeTraits<RealType>::sqrt(res2);
1267  }
1268  };
1269 
1274  template <typename M>
1275  struct MatrixNormInfinity : public MatrixScalarRealUnaryFunctor<M>
1276  {
1277 
1278  typedef typename MatrixScalarRealUnaryFunctor<M>::ValueType ValueType;
1279  typedef typename MatrixScalarRealUnaryFunctor<M>::RealType RealType;
1280  typedef typename MatrixScalarRealUnaryFunctor<M>::ResultType ResultType;
1281 
1287  static ResultType apply(const MatrixExpression<M>& e)
1288  {
1289  typedef typename M::SizeType SizeType;
1290 
1291  RealType res = RealType();
1292  SizeType size1 = e().getSize1();
1293  SizeType size2 = e().getSize2();
1294 
1295  for (SizeType i = 0; i < size1; i++) {
1296  RealType t = RealType();
1297 
1298  for (SizeType j = 0; j < size2; j++)
1299  t += TypeTraits<ValueType>::normInf(e()(i, j));
1300 
1301  if (t > res)
1302  res = t;
1303  }
1304 
1305  return res;
1306  }
1307  };
1308 
1313  template <typename V>
1314  struct VectorMatrixUnaryFunctor
1315  {
1316 
1320  typedef typename V::ValueType ResultType;
1321 
1325  typedef typename V::SizeType SizeType;
1326  };
1327 
1332  template <typename V>
1333  struct DiagonalMatrixFromVector : public VectorMatrixUnaryFunctor<V>
1334  {
1335 
1336  typedef typename VectorScalarUnaryFunctor<V>::ResultType ResultType;
1337  typedef typename VectorScalarUnaryFunctor<V>::SizeType SizeType;
1338 
1347  template <typename E>
1348  static ResultType apply(const VectorExpression<E>& e, SizeType i, SizeType j)
1349  {
1350  if (i == j)
1351  return e()(i);
1352 
1353  return ResultType();
1354  }
1355  };
1356 
1361  template <typename V>
1362  struct CrossProductMatrixFromVector : public VectorMatrixUnaryFunctor<V>
1363  {
1364 
1365  typedef typename VectorScalarUnaryFunctor<V>::ResultType ResultType;
1366  typedef typename VectorScalarUnaryFunctor<V>::SizeType SizeType;
1367 
1377  template <typename E>
1378  static ResultType apply(const VectorExpression<E>& e, SizeType i, SizeType j)
1379  {
1380  CDPL_MATH_CHECK(e().getSize() == 3, "Invalid vector size", Base::SizeError);
1381 
1382  // | 0 -a3 a2 |
1383  // cross([a1, a2, a3]) = | a3 0 -a1 |
1384  // | -a2 a1 0 |
1385  switch (i) {
1386 
1387  case 0:
1388  switch (j) {
1389 
1390  case 1:
1391  return -e()(2);
1392 
1393  case 2:
1394  return e()(1);
1395 
1396  default:
1397  return ResultType();
1398  }
1399 
1400  case 1:
1401  switch (j) {
1402 
1403  case 0:
1404  return e()(2);
1405 
1406  case 2:
1407  return -e()(0);
1408 
1409  default:
1410  return ResultType();
1411  }
1412 
1413  case 2:
1414  switch (j) {
1415 
1416  case 0:
1417  return -e()(1);
1418 
1419  case 1:
1420  return e()(0);
1421 
1422  default:
1423  return ResultType();
1424  }
1425 
1426  default:
1427  return ResultType();
1428  }
1429  }
1430  };
1431 
1437  template <typename M, typename V>
1438  struct MatrixVectorBinaryFunctor
1439  {
1440 
1444  typedef typename CommonType<typename M::ValueType, typename V::ValueType>::Type ValueType;
1445 
1449  typedef typename CommonType<typename M::SizeType, typename V::SizeType>::Type SizeType;
1450 
1454  typedef ValueType ResultType;
1455  };
1456 
1462  template <typename M, typename V>
1463  struct MatrixVectorProduct : public MatrixVectorBinaryFunctor<M, V>
1464  {
1465 
1466  typedef typename MatrixVectorBinaryFunctor<M, V>::ValueType ValueType;
1467  typedef typename MatrixVectorBinaryFunctor<M, V>::SizeType SizeType;
1468  typedef typename MatrixVectorBinaryFunctor<M, V>::ResultType ResultType;
1469 
1480  template <typename E1, typename E2>
1481  static ResultType apply(const MatrixExpression<E1>& e1, const VectorExpression<E2>& e2, SizeType i)
1482  {
1483  SizeType size = CDPL_MATH_CHECK_SIZE_EQUALITY(SizeType(e1().getSize2()), SizeType(e2().getSize()), Base::SizeError);
1484  ResultType res = ResultType();
1485 
1486  for (SizeType j = 0; j < size; j++)
1487  res += e1()(i, j) * e2()(j);
1488 
1489  return res;
1490  }
1491  };
1492 
1498  template <typename V, typename M>
1499  struct VectorMatrixProduct : public MatrixVectorBinaryFunctor<M, V>
1500  {
1501 
1502  typedef typename MatrixVectorBinaryFunctor<M, V>::ValueType ValueType;
1503  typedef typename MatrixVectorBinaryFunctor<M, V>::SizeType SizeType;
1504  typedef typename MatrixVectorBinaryFunctor<M, V>::ResultType ResultType;
1505 
1516  template <typename E1, typename E2>
1517  static ResultType apply(const VectorExpression<E1>& e1, const MatrixExpression<E2>& e2, SizeType i)
1518  {
1519  SizeType size = CDPL_MATH_CHECK_SIZE_EQUALITY(SizeType(e1().getSize()), SizeType(e2().getSize1()), Base::SizeError);
1520  ResultType res = ResultType();
1521 
1522  for (SizeType j = 0; j < size; j++)
1523  res += e1()(j) * e2()(j, i);
1524 
1525  return res;
1526  }
1527  };
1528 
1534  template <typename M1, typename M2>
1535  struct MatrixBinaryFunctor
1536  {
1537 
1541  typedef typename CommonType<typename M1::ValueType, typename M2::ValueType>::Type ValueType;
1542 
1546  typedef typename CommonType<typename M1::SizeType, typename M2::SizeType>::Type SizeType;
1547 
1551  typedef ValueType ResultType;
1552  };
1553 
1559  template <typename M1, typename M2>
1560  struct MatrixProduct : public MatrixBinaryFunctor<M1, M2>
1561  {
1562 
1563  typedef typename MatrixVectorBinaryFunctor<M1, M2>::ValueType ValueType;
1564  typedef typename MatrixVectorBinaryFunctor<M1, M2>::SizeType SizeType;
1565  typedef typename MatrixVectorBinaryFunctor<M1, M2>::ResultType ResultType;
1566 
1578  template <typename E1, typename E2>
1579  static ResultType apply(const MatrixExpression<E1>& e1, const MatrixExpression<E2>& e2, SizeType i, SizeType j)
1580  {
1581  SizeType size = CDPL_MATH_CHECK_SIZE_EQUALITY(SizeType(e1().getSize2()), SizeType(e2().getSize1()), Base::SizeError);
1582  ResultType res = ResultType();
1583 
1584  for (SizeType k = 0; k < size; k++)
1585  res += e1()(i, k) * e2()(k, j);
1586 
1587  return res;
1588  }
1589  };
1590 
1596  template <typename Q1, typename Q2>
1597  struct QuaternionBooleanBinaryFunctor
1598  {
1599 
1603  typedef bool ResultType;
1604 
1608  typedef typename CommonType<typename Q1::ValueType, typename Q2::ValueType>::Type ValueType;
1609  };
1610 
1616  template <typename Q1, typename Q2>
1617  struct QuaternionEquality : public QuaternionBooleanBinaryFunctor<Q1, Q2>
1618  {
1619 
1620  typedef typename QuaternionBooleanBinaryFunctor<Q1, Q2>::ValueType ValueType;
1621  typedef typename QuaternionBooleanBinaryFunctor<Q1, Q2>::ResultType ResultType;
1622 
1629  static ResultType apply(const QuaternionExpression<Q1>& e1, const QuaternionExpression<Q2>& e2)
1630  {
1631  return (ValueType(e1().getC1()) == ValueType(e2().getC1()) && ValueType(e1().getC2()) == ValueType(e2().getC2()) && ValueType(e1().getC3()) == ValueType(e2().getC3()) && ValueType(e1().getC4()) == ValueType(e2().getC4()));
1632  }
1633  };
1634 
1641  template <typename Q1, typename Q2, typename T>
1642  struct Scalar3QuaternionBooleanTernaryFunctor
1643  {
1644 
1648  typedef bool ResultType;
1649 
1653  typedef const T& Argument3Type;
1654 
1658  typedef typename CommonType<typename Q1::ValueType, typename Q2::ValueType>::Type ValueType;
1659  };
1660 
1667  template <typename Q1, typename Q2, typename T>
1668  struct QuaternionToleranceEquality : public Scalar3QuaternionBooleanTernaryFunctor<Q1, Q2, T>
1669  {
1670 
1671  typedef typename Scalar3QuaternionBooleanTernaryFunctor<Q1, Q2, T>::ValueType ValueType;
1672  typedef typename Scalar3QuaternionBooleanTernaryFunctor<Q1, Q2, T>::ResultType ResultType;
1673  typedef typename Scalar3QuaternionBooleanTernaryFunctor<Q1, Q2, T>::Argument3Type Argument3Type;
1674 
1682  static ResultType apply(const QuaternionExpression<Q1>& e1, const QuaternionExpression<Q2>& e2, Argument3Type epsilon)
1683  {
1684  typedef typename CommonType<typename TypeTraits<ValueType>::RealType, T>::Type ComparisonType;
1685 
1686  ComparisonType norm_inf_max(epsilon);
1687 
1688  return (ComparisonType(TypeTraits<ValueType>::normInf(e2().getC1() - e1().getC1())) <= norm_inf_max && ComparisonType(TypeTraits<ValueType>::normInf(e2().getC2() - e1().getC2())) <= norm_inf_max && ComparisonType(TypeTraits<ValueType>::normInf(e2().getC3() - e1().getC3())) <= norm_inf_max && ComparisonType(TypeTraits<ValueType>::normInf(e2().getC4() - e1().getC4())) <= norm_inf_max);
1689  }
1690  };
1691 
1696  template <typename Q>
1697  struct QuaternionScalarUnaryFunctor
1698  {
1699 
1703  typedef typename Q::ValueType ResultType;
1704  };
1705 
1710  template <typename Q>
1711  struct QuaternionElementSum : public QuaternionScalarUnaryFunctor<Q>
1712  {
1713 
1714  typedef typename QuaternionScalarUnaryFunctor<Q>::ResultType ResultType;
1715 
1721  static ResultType apply(const QuaternionExpression<Q>& e)
1722  {
1723  return (e().getC1() + e().getC2() + e().getC3() + e().getC4());
1724  }
1725  };
1726 
1731  template <typename Q>
1732  struct QuaternionScalarRealUnaryFunctor
1733  {
1734 
1738  typedef typename Q::ValueType ValueType;
1739 
1743  typedef ValueType RealType;
1744 
1748  typedef RealType ResultType;
1749  };
1750 
1755  template <typename Q>
1756  struct QuaternionNorm : public QuaternionScalarRealUnaryFunctor<Q>
1757  {
1758 
1759  typedef typename QuaternionScalarRealUnaryFunctor<Q>::ValueType ValueType;
1760  typedef typename QuaternionScalarRealUnaryFunctor<Q>::RealType RealType;
1761  typedef typename QuaternionScalarRealUnaryFunctor<Q>::ResultType ResultType;
1762 
1768  static ResultType apply(const QuaternionExpression<Q>& e)
1769  {
1770  RealType t = e().getC1() * e().getC1() +
1771  e().getC2() * e().getC2() +
1772  e().getC3() * e().getC3() +
1773  e().getC4() * e().getC4();
1774 
1775  return TypeTraits<RealType>::sqrt(t);
1776  }
1777  };
1778 
1783  template <typename Q>
1784  struct QuaternionNorm2 : public QuaternionScalarRealUnaryFunctor<Q>
1785  {
1786 
1787  typedef typename QuaternionScalarRealUnaryFunctor<Q>::ValueType ValueType;
1788  typedef typename QuaternionScalarRealUnaryFunctor<Q>::RealType RealType;
1789  typedef typename QuaternionScalarRealUnaryFunctor<Q>::ResultType ResultType;
1790 
1796  static ResultType apply(const QuaternionExpression<Q>& e)
1797  {
1798  RealType t = e().getC1() * e().getC1() +
1799  e().getC2() * e().getC2() +
1800  e().getC3() * e().getC3() +
1801  e().getC4() * e().getC4();
1802 
1803  return t;
1804  }
1805  };
1806 
1811  template <typename Q>
1812  struct QuaternionUnaryFunctor
1813  {
1814 
1818  typedef typename Q::ValueType ResultType;
1819  };
1820 
1825  template <typename Q>
1826  struct QuaternionUnreal : public QuaternionUnaryFunctor<Q>
1827  {
1828 
1829  typedef typename QuaternionUnaryFunctor<Q>::ResultType ResultType;
1830 
1837  template <typename E>
1838  static ResultType applyC1(const QuaternionExpression<E>& e)
1839  {
1840  return ResultType();
1841  }
1842 
1849  template <typename E>
1850  static ResultType applyC2(const QuaternionExpression<E>& e)
1851  {
1852  return e().getC2();
1853  }
1854 
1861  template <typename E>
1862  static ResultType applyC3(const QuaternionExpression<E>& e)
1863  {
1864  return e().getC3();
1865  }
1866 
1873  template <typename E>
1874  static ResultType applyC4(const QuaternionExpression<E>& e)
1875  {
1876  return e().getC4();
1877  }
1878  };
1879 
1884  template <typename Q>
1885  struct QuaternionConjugate : public QuaternionUnaryFunctor<Q>
1886  {
1887 
1888  typedef typename QuaternionUnaryFunctor<Q>::ResultType ResultType;
1889 
1896  template <typename E>
1897  static ResultType applyC1(const QuaternionExpression<E>& e)
1898  {
1899  return e().getC1();
1900  }
1901 
1908  template <typename E>
1909  static ResultType applyC2(const QuaternionExpression<E>& e)
1910  {
1911  return -e().getC2();
1912  }
1913 
1920  template <typename E>
1921  static ResultType applyC3(const QuaternionExpression<E>& e)
1922  {
1923  return -e().getC3();
1924  }
1925 
1932  template <typename E>
1933  static ResultType applyC4(const QuaternionExpression<E>& e)
1934  {
1935  return -e().getC4();
1936  }
1937  };
1938 
1944  template <typename T, typename Q>
1945  struct Scalar1QuaternionBinaryFunctor
1946  {
1947 
1951  typedef typename CommonType<T, typename Q::ValueType>::Type ResultType;
1952 
1956  typedef const T& Argument1Type;
1957  };
1958 
1964  template <typename T, typename Q>
1965  struct Scalar1QuaternionAddition : public Scalar1QuaternionBinaryFunctor<T, Q>
1966  {
1967 
1968  typedef typename Scalar1QuaternionBinaryFunctor<T, Q>::Argument1Type Argument1Type;
1969  typedef typename Scalar1QuaternionBinaryFunctor<T, Q>::ResultType ResultType;
1970 
1978  template <typename E>
1979  static ResultType applyC1(Argument1Type t, const QuaternionExpression<E>& e)
1980  {
1981  return (t + e().getC1());
1982  }
1983 
1990  template <typename E>
1991  static ResultType applyC2(Argument1Type, const QuaternionExpression<E>& e)
1992  {
1993  return e().getC2();
1994  }
1995 
2002  template <typename E>
2003  static ResultType applyC3(Argument1Type, const QuaternionExpression<E>& e)
2004  {
2005  return e().getC3();
2006  }
2007 
2014  template <typename E>
2015  static ResultType applyC4(Argument1Type, const QuaternionExpression<E>& e)
2016  {
2017  return e().getC4();
2018  }
2019  };
2020 
2026  template <typename T, typename Q>
2027  struct Scalar1QuaternionSubtraction : public Scalar1QuaternionBinaryFunctor<T, Q>
2028  {
2029 
2030  typedef typename Scalar1QuaternionBinaryFunctor<T, Q>::Argument1Type Argument1Type;
2031  typedef typename Scalar1QuaternionBinaryFunctor<T, Q>::ResultType ResultType;
2032 
2040  template <typename E>
2041  static ResultType applyC1(Argument1Type t, const QuaternionExpression<E>& e)
2042  {
2043  return (t - e().getC1());
2044  }
2045 
2052  template <typename E>
2053  static ResultType applyC2(Argument1Type, const QuaternionExpression<E>& e)
2054  {
2055  return -e().getC2();
2056  }
2057 
2064  template <typename E>
2065  static ResultType applyC3(Argument1Type, const QuaternionExpression<E>& e)
2066  {
2067  return -e().getC3();
2068  }
2069 
2076  template <typename E>
2077  static ResultType applyC4(Argument1Type, const QuaternionExpression<E>& e)
2078  {
2079  return -e().getC4();
2080  }
2081  };
2082 
2088  template <typename Q, typename T>
2089  struct Scalar2QuaternionBinaryFunctor
2090  {
2091 
2095  typedef typename CommonType<typename Q::ValueType, T>::Type ResultType;
2096 
2100  typedef const T& Argument2Type;
2101  };
2102 
2108  template <typename Q, typename T>
2109  struct Scalar2QuaternionAddition : public Scalar2QuaternionBinaryFunctor<Q, T>
2110  {
2111 
2112  typedef typename Scalar2QuaternionBinaryFunctor<Q, T>::Argument2Type Argument2Type;
2113  typedef typename Scalar2QuaternionBinaryFunctor<Q, T>::ResultType ResultType;
2114 
2122  template <typename E>
2123  static ResultType applyC1(const QuaternionExpression<E>& e, Argument2Type t)
2124  {
2125  return (e().getC1() + t);
2126  }
2127 
2134  template <typename E>
2135  static ResultType applyC2(const QuaternionExpression<E>& e, Argument2Type)
2136  {
2137  return e().getC2();
2138  }
2139 
2146  template <typename E>
2147  static ResultType applyC3(const QuaternionExpression<E>& e, Argument2Type)
2148  {
2149  return e().getC3();
2150  }
2151 
2158  template <typename E>
2159  static ResultType applyC4(const QuaternionExpression<E>& e, Argument2Type)
2160  {
2161  return e().getC4();
2162  }
2163  };
2164 
2170  template <typename Q, typename T>
2171  struct Scalar2QuaternionSubtraction : public Scalar2QuaternionBinaryFunctor<Q, T>
2172  {
2173 
2174  typedef typename Scalar2QuaternionBinaryFunctor<Q, T>::Argument2Type Argument2Type;
2175  typedef typename Scalar2QuaternionBinaryFunctor<Q, T>::ResultType ResultType;
2176 
2184  template <typename E>
2185  static ResultType applyC1(const QuaternionExpression<E>& e, Argument2Type t)
2186  {
2187  return (e().getC1() - t);
2188  }
2189 
2196  template <typename E>
2197  static ResultType applyC2(const QuaternionExpression<E>& e, Argument2Type)
2198  {
2199  return e().getC2();
2200  }
2201 
2208  template <typename E>
2209  static ResultType applyC3(const QuaternionExpression<E>& e, Argument2Type)
2210  {
2211  return e().getC3();
2212  }
2213 
2220  template <typename E>
2221  static ResultType applyC4(const QuaternionExpression<E>& e, Argument2Type)
2222  {
2223  return e().getC4();
2224  }
2225  };
2226 
2232  template <typename Q, typename T>
2233  struct QuaternionInverse : public Scalar2QuaternionBinaryFunctor<Q, T>
2234  {
2235 
2236  typedef typename Scalar2QuaternionBinaryFunctor<Q, T>::Argument2Type Argument2Type;
2237  typedef typename Scalar2QuaternionBinaryFunctor<Q, T>::ResultType ResultType;
2238 
2246  template <typename E>
2247  static ResultType applyC1(const QuaternionExpression<E>& e, Argument2Type n2)
2248  {
2249  return (e().getC1() / n2);
2250  }
2251 
2259  template <typename E>
2260  static ResultType applyC2(const QuaternionExpression<E>& e, Argument2Type n2)
2261  {
2262  return (-e().getC2() / n2);
2263  }
2264 
2272  template <typename E>
2273  static ResultType applyC3(const QuaternionExpression<E>& e, Argument2Type n2)
2274  {
2275  return (-e().getC3() / n2);
2276  }
2277 
2285  template <typename E>
2286  static ResultType applyC4(const QuaternionExpression<E>& e, Argument2Type n2)
2287  {
2288  return (-e().getC4() / n2);
2289  }
2290  };
2291 
2297  template <typename Q1, typename Q2>
2298  struct QuaternionBinaryFunctor
2299  {
2300 
2304  typedef typename CommonType<typename Q1::ValueType, typename Q2::ValueType>::Type ResultType;
2305  };
2306 
2312  template <typename Q1, typename Q2>
2313  struct QuaternionProduct : public QuaternionBinaryFunctor<Q1, Q2>
2314  {
2315 
2316  typedef typename QuaternionBinaryFunctor<Q1, Q2>::ResultType ResultType;
2317 
2326  template <typename E1, typename E2>
2327  static ResultType applyC1(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2)
2328  {
2329  // a = a1 * a2 - b1 * b2 - c1 * c2 - d1 * d2
2330  return (e1().getC1() * e2().getC1() - e1().getC2() * e2().getC2() - e1().getC3() * e2().getC3() - e1().getC4() * e2().getC4());
2331  }
2332 
2341  template <typename E1, typename E2>
2342  static ResultType applyC2(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2)
2343  {
2344  // b = a1 * b2 + b1 * a2 + c1 * d2 - d1 * c2
2345  return (e1().getC1() * e2().getC2() + e1().getC2() * e2().getC1() + e1().getC3() * e2().getC4() - e1().getC4() * e2().getC3());
2346  }
2347 
2356  template <typename E1, typename E2>
2357  static ResultType applyC3(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2)
2358  {
2359  // c = a1 * c2 - b1 * d2 + c1 * a2 + d1 * b2
2360  return (e1().getC1() * e2().getC3() - e1().getC2() * e2().getC4() + e1().getC3() * e2().getC1() + e1().getC4() * e2().getC2());
2361  }
2362 
2371  template <typename E1, typename E2>
2372  static ResultType applyC4(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2)
2373  {
2374  // d = a1 * d2 + b1 * c2 - c1 * b2 + d1 * a2
2375  return (e1().getC1() * e2().getC4() + e1().getC2() * e2().getC3() - e1().getC3() * e2().getC2() + e1().getC4() * e2().getC1());
2376  }
2377  };
2378 
2385  template <typename Q1, typename Q2, typename T>
2386  struct Scalar3QuaternionTernaryFunctor
2387  {
2388 
2392  typedef typename CommonType<typename CommonType<typename Q1::ValueType, typename Q2::ValueType>::Type, T>::Type ResultType;
2393 
2397  typedef const T& Argument3Type;
2398  };
2399 
2406  template <typename Q1, typename Q2, typename T>
2407  struct QuaternionDivision : public Scalar3QuaternionTernaryFunctor<Q1, Q2, T>
2408  {
2409 
2410  typedef typename Scalar3QuaternionTernaryFunctor<Q1, Q2, T>::Argument3Type Argument3Type;
2411  typedef typename Scalar3QuaternionTernaryFunctor<Q1, Q2, T>::ResultType ResultType;
2412 
2422  template <typename E1, typename E2>
2423  static ResultType applyC1(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2, Argument3Type n2)
2424  {
2425  // a = (a1 * a2 + b1 * b2 + c1 * c2 + d1 * d2) / n2
2426  return ((e1().getC1() * e2().getC1() + e1().getC2() * e2().getC2() + e1().getC3() * e2().getC3() + e1().getC4() * e2().getC4()) / n2);
2427  }
2428 
2438  template <typename E1, typename E2>
2439  static ResultType applyC2(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2, Argument3Type n2)
2440  {
2441  // b = (-a1 * b2 + b1 * a2 - c1 * d2 + d1 * c2) / n2
2442  return ((-e1().getC1() * e2().getC2() + e1().getC2() * e2().getC1() - e1().getC3() * e2().getC4() + e1().getC4() * e2().getC3()) / n2);
2443  }
2444 
2454  template <typename E1, typename E2>
2455  static ResultType applyC3(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2, Argument3Type n2)
2456  {
2457  // c = (-a1 * c2 + b1 * d2 + c1 * a2 - d1 * b2) / n2
2458  return ((-e1().getC1() * e2().getC3() + e1().getC2() * e2().getC4() + e1().getC3() * e2().getC1() - e1().getC4() * e2().getC2()) / n2);
2459  }
2460 
2470  template <typename E1, typename E2>
2471  static ResultType applyC4(const QuaternionExpression<E1>& e1, const QuaternionExpression<E2>& e2, Argument3Type n2)
2472  {
2473  // d = (-a1 * d2 - b1 * c2 + c1 * b2 + d1 * a2) / n2
2474  return ((-e1().getC1() * e2().getC4() - e1().getC2() * e2().getC3() + e1().getC3() * e2().getC2() + e1().getC4() * e2().getC1()) / n2);
2475  }
2476  };
2477 
2484  template <typename T1, typename Q, typename T2>
2485  struct Scalar13QuaternionTernaryFunctor
2486  {
2487 
2491  typedef typename CommonType<typename CommonType<T1, typename Q::ValueType>::Type, T2>::Type ResultType;
2492 
2496  typedef const T1& Argument1Type;
2497 
2501  typedef const T2& Argument3Type;
2502  };
2503 
2510  template <typename T1, typename Q, typename T2>
2511  struct ScalarQuaternionDivision : public Scalar13QuaternionTernaryFunctor<T1, Q, T2>
2512  {
2513 
2514  typedef typename Scalar13QuaternionTernaryFunctor<T1, Q, T2>::Argument1Type Argument1Type;
2515  typedef typename Scalar13QuaternionTernaryFunctor<T1, Q, T2>::Argument3Type Argument3Type;
2516  typedef typename Scalar13QuaternionTernaryFunctor<T1, Q, T2>::ResultType ResultType;
2517 
2526  template <typename E>
2527  static ResultType applyC1(Argument1Type t, const QuaternionExpression<E>& e, Argument3Type n2)
2528  {
2529  return (t * e().getC1() / n2);
2530  }
2531 
2540  template <typename E>
2541  static ResultType applyC2(Argument1Type t, const QuaternionExpression<E>& e, Argument3Type n2)
2542  {
2543  return (t * -e().getC2() / n2);
2544  }
2545 
2554  template <typename E>
2555  static ResultType applyC3(Argument1Type t, const QuaternionExpression<E>& e, Argument3Type n2)
2556  {
2557  return (t * -e().getC3() / n2);
2558  }
2559 
2568  template <typename E>
2569  static ResultType applyC4(Argument1Type t, const QuaternionExpression<E>& e, Argument3Type n2)
2570  {
2571  return (t * -e().getC4() / n2);
2572  }
2573  };
2574 
2580  template <typename Q, typename V>
2581  struct QuaternionVectorBinaryFunctor
2582  {
2583 
2587  typedef typename CommonType<typename Q::ValueType, typename V::ValueType>::Type ValueType;
2588 
2592  typedef typename V::SizeType SizeType;
2593 
2597  typedef ValueType ResultType;
2598  };
2599 
2606  template <typename Q, typename V>
2607  struct QuaternionVectorRotation : public QuaternionVectorBinaryFunctor<Q, V>
2608  {
2609 
2610  typedef typename QuaternionVectorBinaryFunctor<Q, V>::ValueType ValueType;
2611  typedef typename QuaternionVectorBinaryFunctor<Q, V>::SizeType SizeType;
2612  typedef typename QuaternionVectorBinaryFunctor<Q, V>::ResultType ResultType;
2613 
2624  template <typename E1, typename E2>
2625  static ResultType apply(const QuaternionExpression<E1>& e1, const VectorExpression<E2>& e2, SizeType i)
2626  {
2627  CDPL_MATH_CHECK(e2().getSize() >= 3, "Invalid vector size", Base::SizeError);
2628 
2629  switch (i) {
2630 
2631  case 0: {
2632  // vr1 = (a2 + b2 - c2 - d2) * v1 + (2bc - 2ad) * v2 + (2bd + 2ac) * v3
2633  ValueType t1 = e1().getC1() * e1().getC1() + e1().getC2() * e1().getC2() - e1().getC3() * e1().getC3() - e1().getC4() * e1().getC4();
2634  ValueType t2 = ValueType(2) * (e1().getC2() * e1().getC3() - e1().getC1() * e1().getC4());
2635  ValueType t3 = ValueType(2) * (e1().getC2() * e1().getC4() + e1().getC1() * e1().getC3());
2636 
2637  return (t1 * e2()(0) + t2 * e2()(1) + t3 * e2()(2));
2638  }
2639 
2640  case 1: {
2641  // vr2 = (2bc + 2ad) * v1 + (a2 - b2 + c2 - d2) * v2 + (2cd - 2ab) * v3
2642  ValueType t1 = ValueType(2) * (e1().getC2() * e1().getC3() + e1().getC1() * e1().getC4());
2643  ValueType t2 = e1().getC1() * e1().getC1() - e1().getC2() * e1().getC2() + e1().getC3() * e1().getC3() - e1().getC4() * e1().getC4();
2644  ValueType t3 = ValueType(2) * (e1().getC3() * e1().getC4() - e1().getC1() * e1().getC2());
2645 
2646  return (t1 * e2()(0) + t2 * e2()(1) + t3 * e2()(2));
2647  }
2648 
2649  case 2: {
2650  // vr3 = (2bd - 2ac) * v1 + (2cd + 2ab) * v2 + (a2 - b2 - c2 + d2) * v3
2651  ValueType t1 = ValueType(2) * (e1().getC2() * e1().getC4() - e1().getC1() * e1().getC3());
2652  ValueType t2 = ValueType(2) * (e1().getC3() * e1().getC4() + e1().getC1() * e1().getC2());
2653  ValueType t3 = e1().getC1() * e1().getC1() - e1().getC2() * e1().getC2() - e1().getC3() * e1().getC3() + e1().getC4() * e1().getC4();
2654 
2655  return (t1 * e2()(0) + t2 * e2()(1) + t3 * e2()(2));
2656  }
2657 
2658  default:
2659  return ResultType();
2660  }
2661  }
2662  };
2663 
2669  template <typename G1, typename G2>
2670  struct GridBooleanBinaryFunctor
2671  {
2672 
2676  typedef bool ResultType;
2677 
2681  typedef typename CommonType<typename G1::SizeType, typename G2::SizeType>::Type SizeType;
2682 
2686  typedef typename CommonType<typename G1::ValueType, typename G2::ValueType>::Type ValueType;
2687  };
2688 
2694  template <typename G1, typename G2>
2695  struct GridEquality : public GridBooleanBinaryFunctor<G1, G2>
2696  {
2697 
2698  typedef typename GridBooleanBinaryFunctor<G1, G2>::SizeType SizeType;
2699  typedef typename GridBooleanBinaryFunctor<G1, G2>::ValueType ValueType;
2700  typedef typename GridBooleanBinaryFunctor<G1, G2>::ResultType ResultType;
2701 
2708  static ResultType apply(const GridExpression<G1>& e1, const GridExpression<G2>& e2)
2709  {
2710  if (SizeType(e1().getSize1()) != SizeType(e2().getSize1()))
2711  return false;
2712 
2713  if (SizeType(e1().getSize2()) != SizeType(e2().getSize2()))
2714  return false;
2715 
2716  if (SizeType(e1().getSize3()) != SizeType(e2().getSize3()))
2717  return false;
2718 
2719  for (SizeType i = 0, size1 = e1().getSize1(); i < size1; i++)
2720  for (SizeType j = 0, size2 = e1().getSize2(); j < size2; j++)
2721  for (SizeType k = 0, size3 = e1().getSize3(); k < size3; k++)
2722  if (ValueType(e1()(i, j, k)) != ValueType(e2()(i, j, k)))
2723  return false;
2724 
2725  return true;
2726  }
2727  };
2728 
2735  template <typename G1, typename G2, typename T>
2736  struct Scalar3GridBooleanTernaryFunctor
2737  {
2738 
2742  typedef bool ResultType;
2743 
2747  typedef const T& Argument3Type;
2748 
2752  typedef typename CommonType<typename G1::SizeType, typename G2::SizeType>::Type SizeType;
2753 
2757  typedef typename CommonType<typename G1::ValueType, typename G2::ValueType>::Type ValueType;
2758  };
2759 
2766  template <typename G1, typename G2, typename T>
2767  struct GridToleranceEquality : public Scalar3GridBooleanTernaryFunctor<G1, G2, T>
2768  {
2769 
2770  typedef typename Scalar3GridBooleanTernaryFunctor<G1, G2, T>::SizeType SizeType;
2771  typedef typename Scalar3GridBooleanTernaryFunctor<G1, G2, T>::ValueType ValueType;
2772  typedef typename Scalar3GridBooleanTernaryFunctor<G1, G2, T>::ResultType ResultType;
2773  typedef typename Scalar3GridBooleanTernaryFunctor<G1, G2, T>::Argument3Type Argument3Type;
2774 
2782  static ResultType apply(const GridExpression<G1>& e1, const GridExpression<G2>& e2, Argument3Type epsilon)
2783  {
2784  typedef typename CommonType<typename TypeTraits<ValueType>::RealType, T>::Type ComparisonType;
2785 
2786  if (SizeType(e1().getSize1()) != SizeType(e2().getSize1()))
2787  return false;
2788 
2789  if (SizeType(e1().getSize2()) != SizeType(e2().getSize2()))
2790  return false;
2791 
2792  if (SizeType(e1().getSize3()) != SizeType(e2().getSize3()))
2793  return false;
2794 
2795  ComparisonType norm_inf_max(epsilon);
2796 
2797  for (SizeType i = 0, size1 = e1().getSize1(); i < size1; i++)
2798  for (SizeType j = 0, size2 = e1().getSize2(); j < size2; j++)
2799  for (SizeType k = 0, size3 = e1().getSize3(); k < size3; k++)
2800  if (ComparisonType(TypeTraits<ValueType>::normInf(e2()(i, j, k) - e1()(i, j, k))) > norm_inf_max)
2801  return false;
2802 
2803  return true;
2804  }
2805  };
2806 
2811  template <typename M>
2812  struct GridScalarUnaryFunctor
2813  {
2814 
2818  typedef typename M::ValueType ResultType;
2819  };
2820 
2825  template <typename G>
2826  struct GridElementSum : public GridScalarUnaryFunctor<G>
2827  {
2828 
2829  typedef typename GridScalarUnaryFunctor<G>::ResultType ResultType;
2830 
2836  static ResultType apply(const GridExpression<G>& e)
2837  {
2838  typedef typename G::SizeType SizeType;
2839 
2840  ResultType res = ResultType();
2841  SizeType size1 = e().getSize1();
2842  SizeType size2 = e().getSize2();
2843  SizeType size3 = e().getSize3();
2844 
2845  for (SizeType i = 0; i < size1; i++)
2846  for (SizeType j = 0; j < size2; j++)
2847  for (SizeType k = 0; k < size3; k++)
2848  res += e()(i, j, k);
2849 
2850  return res;
2851  }
2852  };
2853  } // namespace Math
2854 } // namespace CDPL
2855 
2856 #endif // CDPL_MATH_FUNCTIONAL_HPP
Exceptions.hpp
Definition of exception classes.
Check.hpp
Definition of various preprocessor macros for error checking.
CDPL_MATH_CHECK
#define CDPL_MATH_CHECK(expr, msg, e)
Throws the exception e with message msg when the boolean expression expr evaluates to false.
Definition: Check.hpp:47
CDPL_MATH_CHECK_SIZE_EQUALITY
#define CDPL_MATH_CHECK_SIZE_EQUALITY(size1, size2, e)
Throws the exception e if size1 differs from size2, otherwise returns std::min(size1,...
Definition: Check.hpp:84
CommonType.hpp
Common type deduction.
TypeTraits.hpp
Definition of type traits.
CDPL::Base::SizeError
Thrown to indicate that the size of a (multidimensional) array is not correct.
Definition: Base/Exceptions.hpp:133
CDPL::Math::GridExpression
CRTP base class of all grid expression types.
Definition: Expression.hpp:188
CDPL::Math::MatrixExpression
CRTP base class of all matrix expression types.
Definition: Expression.hpp:108
CDPL::Math::QuaternionExpression
CRTP base class of all quaternion expression types.
Definition: Expression.hpp:148
CDPL::Math::VectorExpression
CRTP base class of all vector expression types.
Definition: Expression.hpp:68
CDPL::Chem::AtomType::T
constexpr unsigned int T
Specifies Hydrogen (Tritium).
Definition: AtomType.hpp:67
CDPL::Math::norm
QuaternionNorm< E >::ResultType norm(const QuaternionExpression< E > &e)
Returns the norm (Euclidean length) of the quaternion expression e.
Definition: QuaternionExpression.hpp:1574
CDPL
The namespace of the Chemical Data Processing Library.
CDPL::Math::CommonType
Trait that resolves the common arithmetic type of T1 and T2 via std::common_type.
Definition: CommonType.hpp:46
CDPL::Math::CommonType::Type
std::common_type< T1, T2 >::type Type
The common type.
Definition: CommonType.hpp:51
CDPL::Math::CrossProductMatrixFromVector
Functor producing the cross-product (skew-symmetric) matrix element at (i, j) for a 3D vector express...
Definition: Functional.hpp:1363
CDPL::Math::CrossProductMatrixFromVector::SizeType
VectorScalarUnaryFunctor< V >::SizeType SizeType
Definition: Functional.hpp:1366
CDPL::Math::CrossProductMatrixFromVector::apply
static ResultType apply(const VectorExpression< E > &e, SizeType i, SizeType j)
Returns the (i, j) element of the skew-symmetric matrix corresponding to the 3D vector e.
Definition: Functional.hpp:1378
CDPL::Math::CrossProductMatrixFromVector::ResultType
VectorScalarUnaryFunctor< V >::ResultType ResultType
Definition: Functional.hpp:1365
CDPL::Math::DiagonalMatrixFromVector
Functor producing the diagonal matrix element at (i, j) from a vector expression ( on the diagonal,...
Definition: Functional.hpp:1334
CDPL::Math::DiagonalMatrixFromVector::SizeType
VectorScalarUnaryFunctor< V >::SizeType SizeType
Definition: Functional.hpp:1337
CDPL::Math::DiagonalMatrixFromVector::apply
static ResultType apply(const VectorExpression< E > &e, SizeType i, SizeType j)
Returns if i equals j, otherwise 0.
Definition: Functional.hpp:1348
CDPL::Math::DiagonalMatrixFromVector::ResultType
VectorScalarUnaryFunctor< V >::ResultType ResultType
Definition: Functional.hpp:1336
CDPL::Math::GridBooleanBinaryFunctor
Base class for binary functors that take two grid expressions and return a bool result (Math::GridEqu...
Definition: Functional.hpp:2671
CDPL::Math::GridBooleanBinaryFunctor::SizeType
CommonType< typename G1::SizeType, typename G2::SizeType >::Type SizeType
The unsigned size type (common type of the two grid size types).
Definition: Functional.hpp:2681
CDPL::Math::GridBooleanBinaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:2676
CDPL::Math::GridBooleanBinaryFunctor::ValueType
CommonType< typename G1::ValueType, typename G2::ValueType >::Type ValueType
The element value type (common type of the two grid element types).
Definition: Functional.hpp:2686
CDPL::Math::GridElementSum
Functor returning the sum of all elements of a grid expression.
Definition: Functional.hpp:2827
CDPL::Math::GridElementSum::ResultType
GridScalarUnaryFunctor< G >::ResultType ResultType
Definition: Functional.hpp:2829
CDPL::Math::GridElementSum::apply
static ResultType apply(const GridExpression< G > &e)
Returns the element sum of e.
Definition: Functional.hpp:2836
CDPL::Math::GridEquality
Functor checking element-wise equality of two grid expressions.
Definition: Functional.hpp:2696
CDPL::Math::GridEquality::apply
static ResultType apply(const GridExpression< G1 > &e1, const GridExpression< G2 > &e2)
Tells whether e1 and e2 have the same dimensions and equal element values.
Definition: Functional.hpp:2708
CDPL::Math::GridEquality::ResultType
GridBooleanBinaryFunctor< G1, G2 >::ResultType ResultType
Definition: Functional.hpp:2700
CDPL::Math::GridEquality::SizeType
GridBooleanBinaryFunctor< G1, G2 >::SizeType SizeType
Definition: Functional.hpp:2698
CDPL::Math::GridEquality::ValueType
GridBooleanBinaryFunctor< G1, G2 >::ValueType ValueType
Definition: Functional.hpp:2699
CDPL::Math::GridScalarUnaryFunctor
Base class for unary functors that take a grid expression and return a scalar result (Math::GridEleme...
Definition: Functional.hpp:2813
CDPL::Math::GridScalarUnaryFunctor::ResultType
M::ValueType ResultType
The scalar result type (the grid's element value type).
Definition: Functional.hpp:2818
CDPL::Math::GridToleranceEquality
Functor checking element-wise approximate equality of two grid expressions within an absolute toleran...
Definition: Functional.hpp:2768
CDPL::Math::GridToleranceEquality::ValueType
Scalar3GridBooleanTernaryFunctor< G1, G2, T >::ValueType ValueType
Definition: Functional.hpp:2771
CDPL::Math::GridToleranceEquality::ResultType
Scalar3GridBooleanTernaryFunctor< G1, G2, T >::ResultType ResultType
Definition: Functional.hpp:2772
CDPL::Math::GridToleranceEquality::SizeType
Scalar3GridBooleanTernaryFunctor< G1, G2, T >::SizeType SizeType
Definition: Functional.hpp:2770
CDPL::Math::GridToleranceEquality::Argument3Type
Scalar3GridBooleanTernaryFunctor< G1, G2, T >::Argument3Type Argument3Type
Definition: Functional.hpp:2773
CDPL::Math::GridToleranceEquality::apply
static ResultType apply(const GridExpression< G1 > &e1, const GridExpression< G2 > &e2, Argument3Type epsilon)
Tells whether e1 and e2 agree element-wise within the absolute tolerance epsilon.
Definition: Functional.hpp:2782
CDPL::Math::MatrixBinaryFunctor
Base class for binary functors that take two matrix expressions and return a matrix element scalar re...
Definition: Functional.hpp:1536
CDPL::Math::MatrixBinaryFunctor::ResultType
ValueType ResultType
The scalar result type (alias for ValueType).
Definition: Functional.hpp:1551
CDPL::Math::MatrixBinaryFunctor::ValueType
CommonType< typename M1::ValueType, typename M2::ValueType >::Type ValueType
The element value type (common type of the two matrix element types).
Definition: Functional.hpp:1541
CDPL::Math::MatrixBinaryFunctor::SizeType
CommonType< typename M1::SizeType, typename M2::SizeType >::Type SizeType
The unsigned size type (common type of the two matrix size types).
Definition: Functional.hpp:1546
CDPL::Math::MatrixBooleanBinaryFunctor
Base class for binary functors that take two matrix expressions and return a bool result (Math::Matri...
Definition: Functional.hpp:967
CDPL::Math::MatrixBooleanBinaryFunctor::SizeType
CommonType< typename M1::SizeType, typename M2::SizeType >::Type SizeType
The unsigned size type (common type of the two matrix size types).
Definition: Functional.hpp:977
CDPL::Math::MatrixBooleanBinaryFunctor::ValueType
CommonType< typename M1::ValueType, typename M2::ValueType >::Type ValueType
The element value type (common type of the two matrix element types).
Definition: Functional.hpp:982
CDPL::Math::MatrixBooleanBinaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:972
CDPL::Math::MatrixElementSum
Functor returning the sum of all elements of a matrix expression.
Definition: Functional.hpp:1115
CDPL::Math::MatrixElementSum::ResultType
MatrixScalarUnaryFunctor< M >::ResultType ResultType
Definition: Functional.hpp:1117
CDPL::Math::MatrixElementSum::apply
static ResultType apply(const MatrixExpression< M > &e)
Returns the element sum of e.
Definition: Functional.hpp:1124
CDPL::Math::MatrixEquality
Functor checking element-wise equality of two matrix expressions.
Definition: Functional.hpp:992
CDPL::Math::MatrixEquality::SizeType
MatrixBooleanBinaryFunctor< M1, M2 >::SizeType SizeType
Definition: Functional.hpp:994
CDPL::Math::MatrixEquality::ResultType
MatrixBooleanBinaryFunctor< M1, M2 >::ResultType ResultType
Definition: Functional.hpp:996
CDPL::Math::MatrixEquality::apply
static ResultType apply(const MatrixExpression< M1 > &e1, const MatrixExpression< M2 > &e2)
Tells whether e1 and e2 have the same dimensions and equal element values.
Definition: Functional.hpp:1004
CDPL::Math::MatrixEquality::ValueType
MatrixBooleanBinaryFunctor< M1, M2 >::ValueType ValueType
Definition: Functional.hpp:995
CDPL::Math::MatrixNorm1
Functor returning the L1 (maximum absolute column sum) norm of a matrix expression.
Definition: Functional.hpp:1200
CDPL::Math::MatrixNorm1::ResultType
MatrixScalarRealUnaryFunctor< M >::ResultType ResultType
Definition: Functional.hpp:1204
CDPL::Math::MatrixNorm1::RealType
MatrixScalarRealUnaryFunctor< M >::RealType RealType
Definition: Functional.hpp:1203
CDPL::Math::MatrixNorm1::ValueType
MatrixScalarRealUnaryFunctor< M >::ValueType ValueType
Definition: Functional.hpp:1202
CDPL::Math::MatrixNorm1::apply
static ResultType apply(const MatrixExpression< M > &e)
Returns the L1 norm of e.
Definition: Functional.hpp:1211
CDPL::Math::MatrixNormFrobenius
Functor returning the Frobenius norm of a matrix expression.
Definition: Functional.hpp:1239
CDPL::Math::MatrixNormFrobenius::apply
static ResultType apply(const MatrixExpression< M > &e)
Returns the Frobenius norm of e.
Definition: Functional.hpp:1250
CDPL::Math::MatrixNormFrobenius::ResultType
MatrixScalarRealUnaryFunctor< M >::ResultType ResultType
Definition: Functional.hpp:1243
CDPL::Math::MatrixNormFrobenius::RealType
MatrixScalarRealUnaryFunctor< M >::RealType RealType
Definition: Functional.hpp:1242
CDPL::Math::MatrixNormFrobenius::ValueType
MatrixScalarRealUnaryFunctor< M >::ValueType ValueType
Definition: Functional.hpp:1241
CDPL::Math::MatrixNormInfinity
Functor returning the L∞ (maximum absolute row sum) norm of a matrix expression.
Definition: Functional.hpp:1276
CDPL::Math::MatrixNormInfinity::apply
static ResultType apply(const MatrixExpression< M > &e)
Returns the L∞ norm of e.
Definition: Functional.hpp:1287
CDPL::Math::MatrixNormInfinity::ResultType
MatrixScalarRealUnaryFunctor< M >::ResultType ResultType
Definition: Functional.hpp:1280
CDPL::Math::MatrixNormInfinity::ValueType
MatrixScalarRealUnaryFunctor< M >::ValueType ValueType
Definition: Functional.hpp:1278
CDPL::Math::MatrixNormInfinity::RealType
MatrixScalarRealUnaryFunctor< M >::RealType RealType
Definition: Functional.hpp:1279
CDPL::Math::MatrixProduct
Functor returning element (i, j) of the matrix product .
Definition: Functional.hpp:1561
CDPL::Math::MatrixProduct::ValueType
MatrixVectorBinaryFunctor< M1, M2 >::ValueType ValueType
Definition: Functional.hpp:1563
CDPL::Math::MatrixProduct::SizeType
MatrixVectorBinaryFunctor< M1, M2 >::SizeType SizeType
Definition: Functional.hpp:1564
CDPL::Math::MatrixProduct::ResultType
MatrixVectorBinaryFunctor< M1, M2 >::ResultType ResultType
Definition: Functional.hpp:1565
CDPL::Math::MatrixProduct::apply
static ResultType apply(const MatrixExpression< E1 > &e1, const MatrixExpression< E2 > &e2, SizeType i, SizeType j)
Returns element (i, j) of the matrix product .
Definition: Functional.hpp:1579
CDPL::Math::MatrixScalarRealUnaryFunctor
Base class for unary functors that take a matrix expression and return a real-valued scalar (Math::Ma...
Definition: Functional.hpp:1176
CDPL::Math::MatrixScalarRealUnaryFunctor::ValueType
M::ValueType ValueType
The matrix's element value type.
Definition: Functional.hpp:1181
CDPL::Math::MatrixScalarRealUnaryFunctor::ResultType
RealType ResultType
The real-valued result type.
Definition: Functional.hpp:1191
CDPL::Math::MatrixScalarRealUnaryFunctor::RealType
TypeTraits< ValueType >::RealType RealType
The real-valued type derived from ValueType via Math::TypeTraits.
Definition: Functional.hpp:1186
CDPL::Math::MatrixScalarUnaryFunctor
Base class for unary functors that take a matrix expression and return a scalar result (Math::MatrixE...
Definition: Functional.hpp:1101
CDPL::Math::MatrixScalarUnaryFunctor::ResultType
M::ValueType ResultType
The scalar result type (the matrix's element value type).
Definition: Functional.hpp:1106
CDPL::Math::MatrixToleranceEquality
Functor checking element-wise approximate equality of two matrix expressions within an absolute toler...
Definition: Functional.hpp:1060
CDPL::Math::MatrixToleranceEquality::apply
static ResultType apply(const MatrixExpression< M1 > &e1, const MatrixExpression< M2 > &e2, Argument3Type epsilon)
Tells whether e1 and e2 agree element-wise within the absolute tolerance epsilon.
Definition: Functional.hpp:1074
CDPL::Math::MatrixToleranceEquality::ValueType
Scalar3MatrixBooleanTernaryFunctor< M1, M2, T >::ValueType ValueType
Definition: Functional.hpp:1063
CDPL::Math::MatrixToleranceEquality::Argument3Type
Scalar3MatrixBooleanTernaryFunctor< M1, M2, T >::Argument3Type Argument3Type
Definition: Functional.hpp:1065
CDPL::Math::MatrixToleranceEquality::ResultType
Scalar3MatrixBooleanTernaryFunctor< M1, M2, T >::ResultType ResultType
Definition: Functional.hpp:1064
CDPL::Math::MatrixToleranceEquality::SizeType
Scalar3MatrixBooleanTernaryFunctor< M1, M2, T >::SizeType SizeType
Definition: Functional.hpp:1062
CDPL::Math::MatrixTrace
Functor returning the trace (sum of diagonal entries) of a matrix expression.
Definition: Functional.hpp:1146
CDPL::Math::MatrixTrace::ResultType
MatrixScalarUnaryFunctor< M >::ResultType ResultType
Definition: Functional.hpp:1148
CDPL::Math::MatrixTrace::apply
static ResultType apply(const MatrixExpression< M > &e)
Returns the trace of e.
Definition: Functional.hpp:1156
CDPL::Math::MatrixVectorBinaryFunctor
Base class for binary functors that take a matrix expression and a vector expression and return a vec...
Definition: Functional.hpp:1439
CDPL::Math::MatrixVectorBinaryFunctor::ResultType
ValueType ResultType
The scalar result type (alias for ValueType).
Definition: Functional.hpp:1454
CDPL::Math::MatrixVectorBinaryFunctor::ValueType
CommonType< typename M::ValueType, typename V::ValueType >::Type ValueType
The element value type (common type of the matrix and vector element types).
Definition: Functional.hpp:1444
CDPL::Math::MatrixVectorBinaryFunctor::SizeType
CommonType< typename M::SizeType, typename V::SizeType >::Type SizeType
The unsigned size type (common type of the matrix and vector size types).
Definition: Functional.hpp:1449
CDPL::Math::MatrixVectorProduct
Functor returning element i of the matrix-vector product .
Definition: Functional.hpp:1464
CDPL::Math::MatrixVectorProduct::ValueType
MatrixVectorBinaryFunctor< M, V >::ValueType ValueType
Definition: Functional.hpp:1466
CDPL::Math::MatrixVectorProduct::ResultType
MatrixVectorBinaryFunctor< M, V >::ResultType ResultType
Definition: Functional.hpp:1468
CDPL::Math::MatrixVectorProduct::SizeType
MatrixVectorBinaryFunctor< M, V >::SizeType SizeType
Definition: Functional.hpp:1467
CDPL::Math::MatrixVectorProduct::apply
static ResultType apply(const MatrixExpression< E1 > &e1, const VectorExpression< E2 > &e2, SizeType i)
Returns element i of the matrix-vector product .
Definition: Functional.hpp:1481
CDPL::Math::QuaternionBinaryFunctor
Base class for per-component binary functors that take two quaternion expressions and produce a quate...
Definition: Functional.hpp:2299
CDPL::Math::QuaternionBinaryFunctor::ResultType
CommonType< typename Q1::ValueType, typename Q2::ValueType >::Type ResultType
The component result type (common type of the two quaternion element types).
Definition: Functional.hpp:2304
CDPL::Math::QuaternionBooleanBinaryFunctor
Base class for binary functors that take two quaternion expressions and return a bool result (Math::Q...
Definition: Functional.hpp:1598
CDPL::Math::QuaternionBooleanBinaryFunctor::ValueType
CommonType< typename Q1::ValueType, typename Q2::ValueType >::Type ValueType
The component value type (common type of the two quaternion element types).
Definition: Functional.hpp:1608
CDPL::Math::QuaternionBooleanBinaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:1603
CDPL::Math::QuaternionConjugate
Per-component functor returning the quaternion conjugate (keeps C1, negates C2/C3/C4).
Definition: Functional.hpp:1886
CDPL::Math::QuaternionConjugate::applyC4
static ResultType applyC4(const QuaternionExpression< E > &e)
Returns the C4 component of the conjugate (equals -e.getC4()).
Definition: Functional.hpp:1933
CDPL::Math::QuaternionConjugate::applyC2
static ResultType applyC2(const QuaternionExpression< E > &e)
Returns the C2 component of the conjugate (equals -e.getC2()).
Definition: Functional.hpp:1909
CDPL::Math::QuaternionConjugate::applyC3
static ResultType applyC3(const QuaternionExpression< E > &e)
Returns the C3 component of the conjugate (equals -e.getC3()).
Definition: Functional.hpp:1921
CDPL::Math::QuaternionConjugate::applyC1
static ResultType applyC1(const QuaternionExpression< E > &e)
Returns the C1 component of the conjugate (equals e.getC1()).
Definition: Functional.hpp:1897
CDPL::Math::QuaternionConjugate::ResultType
QuaternionUnaryFunctor< Q >::ResultType ResultType
Definition: Functional.hpp:1888
CDPL::Math::QuaternionDivision
Per-component functor returning the quaternion division (n2 is the precomputed squared norm of e_2).
Definition: Functional.hpp:2408
CDPL::Math::QuaternionDivision::applyC3
static ResultType applyC3(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2, Argument3Type n2)
Returns the C3 component of the quaternion division .
Definition: Functional.hpp:2455
CDPL::Math::QuaternionDivision::applyC1
static ResultType applyC1(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2, Argument3Type n2)
Returns the C1 component of the quaternion division .
Definition: Functional.hpp:2423
CDPL::Math::QuaternionDivision::ResultType
Scalar3QuaternionTernaryFunctor< Q1, Q2, T >::ResultType ResultType
Definition: Functional.hpp:2411
CDPL::Math::QuaternionDivision::applyC4
static ResultType applyC4(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2, Argument3Type n2)
Returns the C4 component of the quaternion division .
Definition: Functional.hpp:2471
CDPL::Math::QuaternionDivision::applyC2
static ResultType applyC2(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2, Argument3Type n2)
Returns the C2 component of the quaternion division .
Definition: Functional.hpp:2439
CDPL::Math::QuaternionDivision::Argument3Type
Scalar3QuaternionTernaryFunctor< Q1, Q2, T >::Argument3Type Argument3Type
Definition: Functional.hpp:2410
CDPL::Math::QuaternionElementSum
Functor returning the sum of the four components of a quaternion expression.
Definition: Functional.hpp:1712
CDPL::Math::QuaternionElementSum::ResultType
QuaternionScalarUnaryFunctor< Q >::ResultType ResultType
Definition: Functional.hpp:1714
CDPL::Math::QuaternionElementSum::apply
static ResultType apply(const QuaternionExpression< Q > &e)
Returns the component sum of e.
Definition: Functional.hpp:1721
CDPL::Math::QuaternionEquality
Functor checking component-wise equality of two quaternion expressions.
Definition: Functional.hpp:1618
CDPL::Math::QuaternionEquality::apply
static ResultType apply(const QuaternionExpression< Q1 > &e1, const QuaternionExpression< Q2 > &e2)
Tells whether e1 and e2 have equal components.
Definition: Functional.hpp:1629
CDPL::Math::QuaternionEquality::ResultType
QuaternionBooleanBinaryFunctor< Q1, Q2 >::ResultType ResultType
Definition: Functional.hpp:1621
CDPL::Math::QuaternionEquality::ValueType
QuaternionBooleanBinaryFunctor< Q1, Q2 >::ValueType ValueType
Definition: Functional.hpp:1620
CDPL::Math::QuaternionInverse
Per-component functor returning the multiplicative inverse of a quaternion expression (n2 is the pre...
Definition: Functional.hpp:2234
CDPL::Math::QuaternionInverse::applyC3
static ResultType applyC3(const QuaternionExpression< E > &e, Argument2Type n2)
Returns the C3 component of the multiplicative inverse .
Definition: Functional.hpp:2273
CDPL::Math::QuaternionInverse::ResultType
Scalar2QuaternionBinaryFunctor< Q, T >::ResultType ResultType
Definition: Functional.hpp:2237
CDPL::Math::QuaternionInverse::applyC1
static ResultType applyC1(const QuaternionExpression< E > &e, Argument2Type n2)
Returns the C1 (real) component of the multiplicative inverse .
Definition: Functional.hpp:2247
CDPL::Math::QuaternionInverse::Argument2Type
Scalar2QuaternionBinaryFunctor< Q, T >::Argument2Type Argument2Type
Definition: Functional.hpp:2236
CDPL::Math::QuaternionInverse::applyC2
static ResultType applyC2(const QuaternionExpression< E > &e, Argument2Type n2)
Returns the C2 component of the multiplicative inverse .
Definition: Functional.hpp:2260
CDPL::Math::QuaternionInverse::applyC4
static ResultType applyC4(const QuaternionExpression< E > &e, Argument2Type n2)
Returns the C4 component of the multiplicative inverse .
Definition: Functional.hpp:2286
CDPL::Math::QuaternionNorm2
Functor returning the squared norm of a quaternion expression.
Definition: Functional.hpp:1785
CDPL::Math::QuaternionNorm2::RealType
QuaternionScalarRealUnaryFunctor< Q >::RealType RealType
Definition: Functional.hpp:1788
CDPL::Math::QuaternionNorm2::apply
static ResultType apply(const QuaternionExpression< Q > &e)
Returns .
Definition: Functional.hpp:1796
CDPL::Math::QuaternionNorm2::ResultType
QuaternionScalarRealUnaryFunctor< Q >::ResultType ResultType
Definition: Functional.hpp:1789
CDPL::Math::QuaternionNorm2::ValueType
QuaternionScalarRealUnaryFunctor< Q >::ValueType ValueType
Definition: Functional.hpp:1787
CDPL::Math::QuaternionNorm
Functor returning the (Euclidean) norm of a quaternion expression.
Definition: Functional.hpp:1757
CDPL::Math::QuaternionNorm::ResultType
QuaternionScalarRealUnaryFunctor< Q >::ResultType ResultType
Definition: Functional.hpp:1761
CDPL::Math::QuaternionNorm::apply
static ResultType apply(const QuaternionExpression< Q > &e)
Returns .
Definition: Functional.hpp:1768
CDPL::Math::QuaternionNorm::ValueType
QuaternionScalarRealUnaryFunctor< Q >::ValueType ValueType
Definition: Functional.hpp:1759
CDPL::Math::QuaternionNorm::RealType
QuaternionScalarRealUnaryFunctor< Q >::RealType RealType
Definition: Functional.hpp:1760
CDPL::Math::QuaternionProduct
Per-component functor returning the Hamilton product of two quaternion expressions.
Definition: Functional.hpp:2314
CDPL::Math::QuaternionProduct::ResultType
QuaternionBinaryFunctor< Q1, Q2 >::ResultType ResultType
Definition: Functional.hpp:2316
CDPL::Math::QuaternionProduct::applyC3
static ResultType applyC3(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
Returns the C3 component of the Hamilton product .
Definition: Functional.hpp:2357
CDPL::Math::QuaternionProduct::applyC2
static ResultType applyC2(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
Returns the C2 component of the Hamilton product .
Definition: Functional.hpp:2342
CDPL::Math::QuaternionProduct::applyC4
static ResultType applyC4(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
Returns the C4 component of the Hamilton product .
Definition: Functional.hpp:2372
CDPL::Math::QuaternionProduct::applyC1
static ResultType applyC1(const QuaternionExpression< E1 > &e1, const QuaternionExpression< E2 > &e2)
Returns the C1 component of the Hamilton product .
Definition: Functional.hpp:2327
CDPL::Math::QuaternionScalarRealUnaryFunctor
Base class for unary functors that take a quaternion expression and return a real-valued scalar (Math...
Definition: Functional.hpp:1733
CDPL::Math::QuaternionScalarRealUnaryFunctor::ResultType
RealType ResultType
The real-valued result type.
Definition: Functional.hpp:1748
CDPL::Math::QuaternionScalarRealUnaryFunctor::ValueType
Q::ValueType ValueType
The quaternion's component value type.
Definition: Functional.hpp:1738
CDPL::Math::QuaternionScalarRealUnaryFunctor::RealType
ValueType RealType
The real-valued type (alias for ValueType).
Definition: Functional.hpp:1743
CDPL::Math::QuaternionScalarUnaryFunctor
Base class for unary functors that take a quaternion expression and return a scalar result (Math::Qua...
Definition: Functional.hpp:1698
CDPL::Math::QuaternionScalarUnaryFunctor::ResultType
Q::ValueType ResultType
The scalar result type (the quaternion's element value type).
Definition: Functional.hpp:1703
CDPL::Math::QuaternionToleranceEquality
Functor checking component-wise approximate equality of two quaternion expressions within an absolute...
Definition: Functional.hpp:1669
CDPL::Math::QuaternionToleranceEquality::Argument3Type
Scalar3QuaternionBooleanTernaryFunctor< Q1, Q2, T >::Argument3Type Argument3Type
Definition: Functional.hpp:1673
CDPL::Math::QuaternionToleranceEquality::ValueType
Scalar3QuaternionBooleanTernaryFunctor< Q1, Q2, T >::ValueType ValueType
Definition: Functional.hpp:1671
CDPL::Math::QuaternionToleranceEquality::ResultType
Scalar3QuaternionBooleanTernaryFunctor< Q1, Q2, T >::ResultType ResultType
Definition: Functional.hpp:1672
CDPL::Math::QuaternionToleranceEquality::apply
static ResultType apply(const QuaternionExpression< Q1 > &e1, const QuaternionExpression< Q2 > &e2, Argument3Type epsilon)
Tells whether e1 and e2 agree component-wise within the absolute tolerance epsilon.
Definition: Functional.hpp:1682
CDPL::Math::QuaternionUnaryFunctor
Base class for per-component unary functors that take a quaternion expression and produce a quaternio...
Definition: Functional.hpp:1813
CDPL::Math::QuaternionUnaryFunctor::ResultType
Q::ValueType ResultType
The component result type (the quaternion's element value type).
Definition: Functional.hpp:1818
CDPL::Math::QuaternionUnreal
Per-component functor returning the unreal (pure-quaternion) part of a quaternion expression (zeros C...
Definition: Functional.hpp:1827
CDPL::Math::QuaternionUnreal::ResultType
QuaternionUnaryFunctor< Q >::ResultType ResultType
Definition: Functional.hpp:1829
CDPL::Math::QuaternionUnreal::applyC1
static ResultType applyC1(const QuaternionExpression< E > &e)
Returns the C1 component of the unreal part (always zero).
Definition: Functional.hpp:1838
CDPL::Math::QuaternionUnreal::applyC2
static ResultType applyC2(const QuaternionExpression< E > &e)
Returns the C2 component of the unreal part (equals e.getC2()).
Definition: Functional.hpp:1850
CDPL::Math::QuaternionUnreal::applyC3
static ResultType applyC3(const QuaternionExpression< E > &e)
Returns the C3 component of the unreal part (equals e.getC3()).
Definition: Functional.hpp:1862
CDPL::Math::QuaternionUnreal::applyC4
static ResultType applyC4(const QuaternionExpression< E > &e)
Returns the C4 component of the unreal part (equals e.getC4()).
Definition: Functional.hpp:1874
CDPL::Math::QuaternionVectorBinaryFunctor
Base class for binary functors that take a quaternion expression and a vector expression and return a...
Definition: Functional.hpp:2582
CDPL::Math::QuaternionVectorBinaryFunctor::ResultType
ValueType ResultType
The scalar result type (alias for ValueType).
Definition: Functional.hpp:2597
CDPL::Math::QuaternionVectorBinaryFunctor::SizeType
V::SizeType SizeType
The unsigned size type used by the vector.
Definition: Functional.hpp:2592
CDPL::Math::QuaternionVectorBinaryFunctor::ValueType
CommonType< typename Q::ValueType, typename V::ValueType >::Type ValueType
The element value type (common type of the quaternion and vector element types).
Definition: Functional.hpp:2587
CDPL::Math::QuaternionVectorRotation
Functor returning element i of the rotated 3-dimensional vector (quaternion rotation of by ).
Definition: Functional.hpp:2608
CDPL::Math::QuaternionVectorRotation::SizeType
QuaternionVectorBinaryFunctor< Q, V >::SizeType SizeType
Definition: Functional.hpp:2611
CDPL::Math::QuaternionVectorRotation::ResultType
QuaternionVectorBinaryFunctor< Q, V >::ResultType ResultType
Definition: Functional.hpp:2612
CDPL::Math::QuaternionVectorRotation::ValueType
QuaternionVectorBinaryFunctor< Q, V >::ValueType ValueType
Definition: Functional.hpp:2610
CDPL::Math::QuaternionVectorRotation::apply
static ResultType apply(const QuaternionExpression< E1 > &e1, const VectorExpression< E2 > &e2, SizeType i)
Returns element i ( ) of the rotated 3D vector .
Definition: Functional.hpp:2625
CDPL::Math::Scalar13QuaternionTernaryFunctor
Base class for per-component ternary functors that take a scalar T1 (lhs), a quaternion expression,...
Definition: Functional.hpp:2486
CDPL::Math::Scalar13QuaternionTernaryFunctor::Argument1Type
const T1 & Argument1Type
The first (scalar) argument type.
Definition: Functional.hpp:2496
CDPL::Math::Scalar13QuaternionTernaryFunctor::Argument3Type
const T2 & Argument3Type
The third (scalar) argument type.
Definition: Functional.hpp:2501
CDPL::Math::Scalar13QuaternionTernaryFunctor::ResultType
CommonType< typename CommonType< T1, typename Q::ValueType >::Type, T2 >::Type ResultType
The component result type (common type of T1, the quaternion's element value type,...
Definition: Functional.hpp:2491
CDPL::Math::Scalar1QuaternionAddition
Per-component functor returning (scalar t added to the real component of e).
Definition: Functional.hpp:1966
CDPL::Math::Scalar1QuaternionAddition::applyC4
static ResultType applyC4(Argument1Type, const QuaternionExpression< E > &e)
Returns the C4 component of .
Definition: Functional.hpp:2015
CDPL::Math::Scalar1QuaternionAddition::applyC1
static ResultType applyC1(Argument1Type t, const QuaternionExpression< E > &e)
Returns the C1 component of .
Definition: Functional.hpp:1979
CDPL::Math::Scalar1QuaternionAddition::Argument1Type
Scalar1QuaternionBinaryFunctor< T, Q >::Argument1Type Argument1Type
Definition: Functional.hpp:1968
CDPL::Math::Scalar1QuaternionAddition::applyC3
static ResultType applyC3(Argument1Type, const QuaternionExpression< E > &e)
Returns the C3 component of .
Definition: Functional.hpp:2003
CDPL::Math::Scalar1QuaternionAddition::applyC2
static ResultType applyC2(Argument1Type, const QuaternionExpression< E > &e)
Returns the C2 component of .
Definition: Functional.hpp:1991
CDPL::Math::Scalar1QuaternionAddition::ResultType
Scalar1QuaternionBinaryFunctor< T, Q >::ResultType ResultType
Definition: Functional.hpp:1969
CDPL::Math::Scalar1QuaternionBinaryFunctor
Base class for per-component binary functors that take a scalar T (lhs) and a quaternion expression (...
Definition: Functional.hpp:1946
CDPL::Math::Scalar1QuaternionBinaryFunctor::ResultType
CommonType< T, typename Q::ValueType >::Type ResultType
The component result type (common type of the scalar and the quaternion's element value type).
Definition: Functional.hpp:1951
CDPL::Math::Scalar1QuaternionBinaryFunctor::Argument1Type
const T & Argument1Type
The first (scalar) argument type.
Definition: Functional.hpp:1956
CDPL::Math::Scalar1QuaternionSubtraction
Per-component functor returning (scalar t with the quaternion e subtracted).
Definition: Functional.hpp:2028
CDPL::Math::Scalar1QuaternionSubtraction::Argument1Type
Scalar1QuaternionBinaryFunctor< T, Q >::Argument1Type Argument1Type
Definition: Functional.hpp:2030
CDPL::Math::Scalar1QuaternionSubtraction::ResultType
Scalar1QuaternionBinaryFunctor< T, Q >::ResultType ResultType
Definition: Functional.hpp:2031
CDPL::Math::Scalar1QuaternionSubtraction::applyC2
static ResultType applyC2(Argument1Type, const QuaternionExpression< E > &e)
Returns the C2 component of .
Definition: Functional.hpp:2053
CDPL::Math::Scalar1QuaternionSubtraction::applyC3
static ResultType applyC3(Argument1Type, const QuaternionExpression< E > &e)
Returns the C3 component of .
Definition: Functional.hpp:2065
CDPL::Math::Scalar1QuaternionSubtraction::applyC1
static ResultType applyC1(Argument1Type t, const QuaternionExpression< E > &e)
Returns the C1 component of .
Definition: Functional.hpp:2041
CDPL::Math::Scalar1QuaternionSubtraction::applyC4
static ResultType applyC4(Argument1Type, const QuaternionExpression< E > &e)
Returns the C4 component of .
Definition: Functional.hpp:2077
CDPL::Math::Scalar2QuaternionAddition
Per-component functor returning (scalar t added to the real component of e).
Definition: Functional.hpp:2110
CDPL::Math::Scalar2QuaternionAddition::applyC4
static ResultType applyC4(const QuaternionExpression< E > &e, Argument2Type)
Returns the C4 component of .
Definition: Functional.hpp:2159
CDPL::Math::Scalar2QuaternionAddition::applyC3
static ResultType applyC3(const QuaternionExpression< E > &e, Argument2Type)
Returns the C3 component of .
Definition: Functional.hpp:2147
CDPL::Math::Scalar2QuaternionAddition::Argument2Type
Scalar2QuaternionBinaryFunctor< Q, T >::Argument2Type Argument2Type
Definition: Functional.hpp:2112
CDPL::Math::Scalar2QuaternionAddition::ResultType
Scalar2QuaternionBinaryFunctor< Q, T >::ResultType ResultType
Definition: Functional.hpp:2113
CDPL::Math::Scalar2QuaternionAddition::applyC1
static ResultType applyC1(const QuaternionExpression< E > &e, Argument2Type t)
Returns the C1 component of .
Definition: Functional.hpp:2123
CDPL::Math::Scalar2QuaternionAddition::applyC2
static ResultType applyC2(const QuaternionExpression< E > &e, Argument2Type)
Returns the C2 component of .
Definition: Functional.hpp:2135
CDPL::Math::Scalar2QuaternionBinaryFunctor
Base class for per-component binary functors that take a quaternion expression (lhs) and a scalar T (...
Definition: Functional.hpp:2090
CDPL::Math::Scalar2QuaternionBinaryFunctor::ResultType
CommonType< typename Q::ValueType, T >::Type ResultType
The component result type (common type of the quaternion's element value type and the scalar).
Definition: Functional.hpp:2095
CDPL::Math::Scalar2QuaternionBinaryFunctor::Argument2Type
const T & Argument2Type
The second (scalar) argument type.
Definition: Functional.hpp:2100
CDPL::Math::Scalar2QuaternionSubtraction
Per-component functor returning (scalar t subtracted from the real component of e).
Definition: Functional.hpp:2172
CDPL::Math::Scalar2QuaternionSubtraction::applyC2
static ResultType applyC2(const QuaternionExpression< E > &e, Argument2Type)
Returns the C2 component of .
Definition: Functional.hpp:2197
CDPL::Math::Scalar2QuaternionSubtraction::applyC1
static ResultType applyC1(const QuaternionExpression< E > &e, Argument2Type t)
Returns the C1 component of .
Definition: Functional.hpp:2185
CDPL::Math::Scalar2QuaternionSubtraction::applyC4
static ResultType applyC4(const QuaternionExpression< E > &e, Argument2Type)
Returns the C4 component of .
Definition: Functional.hpp:2221
CDPL::Math::Scalar2QuaternionSubtraction::ResultType
Scalar2QuaternionBinaryFunctor< Q, T >::ResultType ResultType
Definition: Functional.hpp:2175
CDPL::Math::Scalar2QuaternionSubtraction::applyC3
static ResultType applyC3(const QuaternionExpression< E > &e, Argument2Type)
Returns the C3 component of .
Definition: Functional.hpp:2209
CDPL::Math::Scalar2QuaternionSubtraction::Argument2Type
Scalar2QuaternionBinaryFunctor< Q, T >::Argument2Type Argument2Type
Definition: Functional.hpp:2174
CDPL::Math::Scalar3GridBooleanTernaryFunctor
Base class for ternary functors that take two grid expressions plus a tolerance scalar and return a b...
Definition: Functional.hpp:2737
CDPL::Math::Scalar3GridBooleanTernaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:2742
CDPL::Math::Scalar3GridBooleanTernaryFunctor::Argument3Type
const T & Argument3Type
The third (scalar) argument type.
Definition: Functional.hpp:2747
CDPL::Math::Scalar3GridBooleanTernaryFunctor::ValueType
CommonType< typename G1::ValueType, typename G2::ValueType >::Type ValueType
The element value type (common type of the two grid element types).
Definition: Functional.hpp:2757
CDPL::Math::Scalar3GridBooleanTernaryFunctor::SizeType
CommonType< typename G1::SizeType, typename G2::SizeType >::Type SizeType
The unsigned size type (common type of the two grid size types).
Definition: Functional.hpp:2752
CDPL::Math::Scalar3MatrixBooleanTernaryFunctor
Base class for ternary functors that take two matrix expressions plus a tolerance scalar and return a...
Definition: Functional.hpp:1029
CDPL::Math::Scalar3MatrixBooleanTernaryFunctor::ValueType
CommonType< typename M1::ValueType, typename M2::ValueType >::Type ValueType
The element value type (common type of the two matrix element types).
Definition: Functional.hpp:1049
CDPL::Math::Scalar3MatrixBooleanTernaryFunctor::SizeType
CommonType< typename M1::SizeType, typename M2::SizeType >::Type SizeType
The unsigned size type (common type of the two matrix size types).
Definition: Functional.hpp:1044
CDPL::Math::Scalar3MatrixBooleanTernaryFunctor::Argument3Type
const T & Argument3Type
The third (scalar) argument type.
Definition: Functional.hpp:1039
CDPL::Math::Scalar3MatrixBooleanTernaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:1034
CDPL::Math::Scalar3QuaternionBooleanTernaryFunctor
Base class for ternary functors that take two quaternion expressions plus a tolerance scalar and retu...
Definition: Functional.hpp:1643
CDPL::Math::Scalar3QuaternionBooleanTernaryFunctor::ValueType
CommonType< typename Q1::ValueType, typename Q2::ValueType >::Type ValueType
The component value type (common type of the two quaternion element types).
Definition: Functional.hpp:1658
CDPL::Math::Scalar3QuaternionBooleanTernaryFunctor::Argument3Type
const T & Argument3Type
The third (scalar) argument type.
Definition: Functional.hpp:1653
CDPL::Math::Scalar3QuaternionBooleanTernaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:1648
CDPL::Math::Scalar3QuaternionTernaryFunctor
Base class for per-component ternary functors that take two quaternion expressions plus a scalar (Mat...
Definition: Functional.hpp:2387
CDPL::Math::Scalar3QuaternionTernaryFunctor::ResultType
CommonType< typename CommonType< typename Q1::ValueType, typename Q2::ValueType >::Type, T >::Type ResultType
The component result type (common type of the two quaternion element types and the scalar).
Definition: Functional.hpp:2392
CDPL::Math::Scalar3QuaternionTernaryFunctor::Argument3Type
const T & Argument3Type
The third (scalar) argument type.
Definition: Functional.hpp:2397
CDPL::Math::Scalar3VectorBooleanTernaryFunctor
Base class for ternary functors that take two vectors and a scalar tolerance and return a boolean (Ma...
Definition: Functional.hpp:609
CDPL::Math::Scalar3VectorBooleanTernaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:614
CDPL::Math::Scalar3VectorBooleanTernaryFunctor::Argument3Type
const T & Argument3Type
The third (scalar) argument type.
Definition: Functional.hpp:619
CDPL::Math::Scalar3VectorBooleanTernaryFunctor::ValueType
CommonType< typename V1::ValueType, typename V2::ValueType >::Type ValueType
The element value type (common type of the two vector element types).
Definition: Functional.hpp:629
CDPL::Math::Scalar3VectorBooleanTernaryFunctor::SizeType
CommonType< typename V1::SizeType, typename V2::SizeType >::Type SizeType
The unsigned size type (common type of the two vector size types).
Definition: Functional.hpp:624
CDPL::Math::ScalarAdditionAssignment
Scalar in-place addition functor: apply(t1, t2) performs t1 += t2.
Definition: Functional.hpp:108
CDPL::Math::ScalarAdditionAssignment::apply
static void apply(Argument1Type t1, Argument2Type t2)
Performs t1 += t2.
Definition: Functional.hpp:118
CDPL::Math::ScalarAdditionAssignment::Argument2Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:111
CDPL::Math::ScalarAdditionAssignment::Argument1Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:110
CDPL::Math::ScalarAddition
Scalar binary addition functor: apply(t1, t2) returns t1 + t2.
Definition: Functional.hpp:373
CDPL::Math::ScalarAddition::Argument1Type
ScalarBinaryFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:375
CDPL::Math::ScalarAddition::apply
static ResultType apply(Argument1Type t1, Argument2Type t2)
Returns t1 + t2.
Definition: Functional.hpp:385
CDPL::Math::ScalarAddition::Argument2Type
ScalarBinaryFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:376
CDPL::Math::ScalarAddition::ResultType
ScalarBinaryFunctor< T1, T2 >::ResultType ResultType
Definition: Functional.hpp:377
CDPL::Math::ScalarAssignment
Scalar plain-assignment functor: apply(t1, t2) performs t1 = t2.
Definition: Functional.hpp:85
CDPL::Math::ScalarAssignment::Argument2Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:88
CDPL::Math::ScalarAssignment::Argument1Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:87
CDPL::Math::ScalarAssignment::apply
static void apply(Argument1Type t1, Argument2Type t2)
Performs t1 = t2.
Definition: Functional.hpp:95
CDPL::Math::ScalarBinaryAssignmentFunctor
Base class for binary in-place assignment functors of the form F::apply(T1, const T2&).
Definition: Functional.hpp:65
CDPL::Math::ScalarBinaryAssignmentFunctor::Argument2Type
const T2 & Argument2Type
The second (source) argument type.
Definition: Functional.hpp:75
CDPL::Math::ScalarBinaryAssignmentFunctor::Argument1Type
T1 Argument1Type
The (modifiable) first argument type.
Definition: Functional.hpp:70
CDPL::Math::ScalarBinaryFunctor
Base class for binary scalar functors of the form F::apply(const T1&, const T2&) returning a Math::Co...
Definition: Functional.hpp:348
CDPL::Math::ScalarBinaryFunctor::Argument2Type
const T2 & Argument2Type
The second argument type.
Definition: Functional.hpp:358
CDPL::Math::ScalarBinaryFunctor::Argument1Type
const T1 & Argument1Type
The first argument type.
Definition: Functional.hpp:353
CDPL::Math::ScalarBinaryFunctor::ResultType
CommonType< T1, T2 >::Type ResultType
The result type (common type of T1 and T2).
Definition: Functional.hpp:363
CDPL::Math::ScalarConjugation
Scalar complex-conjugation functor: apply(v) returns (identity for real types).
Definition: Functional.hpp:250
CDPL::Math::ScalarConjugation::ArgumentType
ScalarUnaryFunctor< T >::ArgumentType ArgumentType
Definition: Functional.hpp:253
CDPL::Math::ScalarConjugation::apply
static ResultType apply(ArgumentType v)
Returns the complex conjugate of v.
Definition: Functional.hpp:261
CDPL::Math::ScalarConjugation::ResultType
ScalarUnaryFunctor< T >::ResultType ResultType
Definition: Functional.hpp:254
CDPL::Math::ScalarConjugation::ValueType
ScalarUnaryFunctor< T >::ValueType ValueType
Definition: Functional.hpp:252
CDPL::Math::ScalarDivisionAssignment
Scalar in-place division functor: apply(t1, t2) performs t1 /= t2.
Definition: Functional.hpp:177
CDPL::Math::ScalarDivisionAssignment::Argument1Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:179
CDPL::Math::ScalarDivisionAssignment::apply
static void apply(Argument1Type t1, Argument2Type t2)
Performs t1 /= t2.
Definition: Functional.hpp:187
CDPL::Math::ScalarDivisionAssignment::Argument2Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:180
CDPL::Math::ScalarDivision
Scalar binary division functor: apply(t1, t2) returns t1 / t2.
Definition: Functional.hpp:448
CDPL::Math::ScalarDivision::Argument1Type
ScalarBinaryFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:450
CDPL::Math::ScalarDivision::apply
static ResultType apply(Argument1Type t1, Argument2Type t2)
Returns t1 / t2.
Definition: Functional.hpp:460
CDPL::Math::ScalarDivision::Argument2Type
ScalarBinaryFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:451
CDPL::Math::ScalarDivision::ResultType
ScalarBinaryFunctor< T1, T2 >::ResultType ResultType
Definition: Functional.hpp:452
CDPL::Math::ScalarImaginary
Scalar imaginary-part functor: apply(v) returns (zero for real types).
Definition: Functional.hpp:320
CDPL::Math::ScalarImaginary::ResultType
ScalarUnaryFunctor< T >::ResultType ResultType
Definition: Functional.hpp:324
CDPL::Math::ScalarImaginary::apply
static ResultType apply(ArgumentType v)
Returns the imaginary part of v.
Definition: Functional.hpp:331
CDPL::Math::ScalarImaginary::ValueType
ScalarUnaryFunctor< T >::ValueType ValueType
Definition: Functional.hpp:322
CDPL::Math::ScalarImaginary::ArgumentType
ScalarUnaryFunctor< T >::ArgumentType ArgumentType
Definition: Functional.hpp:323
CDPL::Math::ScalarMultiplicationAssignment
Scalar in-place multiplication functor: apply(t1, t2) performs t1 *= t2.
Definition: Functional.hpp:154
CDPL::Math::ScalarMultiplicationAssignment::Argument1Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:156
CDPL::Math::ScalarMultiplicationAssignment::Argument2Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:157
CDPL::Math::ScalarMultiplicationAssignment::apply
static void apply(Argument1Type t1, Argument2Type t2)
Performs t1 *= t2.
Definition: Functional.hpp:164
CDPL::Math::ScalarMultiplication
Scalar binary multiplication functor: apply(t1, t2) returns t1 * t2.
Definition: Functional.hpp:423
CDPL::Math::ScalarMultiplication::Argument2Type
ScalarBinaryFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:426
CDPL::Math::ScalarMultiplication::Argument1Type
ScalarBinaryFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:425
CDPL::Math::ScalarMultiplication::apply
static ResultType apply(Argument1Type t1, Argument2Type t2)
Returns t1 * t2.
Definition: Functional.hpp:435
CDPL::Math::ScalarMultiplication::ResultType
ScalarBinaryFunctor< T1, T2 >::ResultType ResultType
Definition: Functional.hpp:427
CDPL::Math::ScalarNegation
Scalar negation functor: apply(v) returns -v.
Definition: Functional.hpp:227
CDPL::Math::ScalarNegation::ValueType
ScalarUnaryFunctor< T >::ValueType ValueType
Definition: Functional.hpp:229
CDPL::Math::ScalarNegation::ResultType
ScalarUnaryFunctor< T >::ResultType ResultType
Definition: Functional.hpp:231
CDPL::Math::ScalarNegation::apply
static ResultType apply(ArgumentType v)
Returns -v.
Definition: Functional.hpp:238
CDPL::Math::ScalarNegation::ArgumentType
ScalarUnaryFunctor< T >::ArgumentType ArgumentType
Definition: Functional.hpp:230
CDPL::Math::ScalarQuaternionDivision
Per-component functor returning the scalar/quaternion division (n2 is the precomputed squared norm o...
Definition: Functional.hpp:2512
CDPL::Math::ScalarQuaternionDivision::applyC1
static ResultType applyC1(Argument1Type t, const QuaternionExpression< E > &e, Argument3Type n2)
Returns the C1 component of using the precomputed squared norm n2 of e.
Definition: Functional.hpp:2527
CDPL::Math::ScalarQuaternionDivision::applyC4
static ResultType applyC4(Argument1Type t, const QuaternionExpression< E > &e, Argument3Type n2)
Returns the C4 component of using the precomputed squared norm n2 of e.
Definition: Functional.hpp:2569
CDPL::Math::ScalarQuaternionDivision::applyC2
static ResultType applyC2(Argument1Type t, const QuaternionExpression< E > &e, Argument3Type n2)
Returns the C2 component of using the precomputed squared norm n2 of e.
Definition: Functional.hpp:2541
CDPL::Math::ScalarQuaternionDivision::Argument1Type
Scalar13QuaternionTernaryFunctor< T1, Q, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:2514
CDPL::Math::ScalarQuaternionDivision::ResultType
Scalar13QuaternionTernaryFunctor< T1, Q, T2 >::ResultType ResultType
Definition: Functional.hpp:2516
CDPL::Math::ScalarQuaternionDivision::applyC3
static ResultType applyC3(Argument1Type t, const QuaternionExpression< E > &e, Argument3Type n2)
Returns the C3 component of using the precomputed squared norm n2 of e.
Definition: Functional.hpp:2555
CDPL::Math::ScalarQuaternionDivision::Argument3Type
Scalar13QuaternionTernaryFunctor< T1, Q, T2 >::Argument3Type Argument3Type
Definition: Functional.hpp:2515
CDPL::Math::ScalarRealUnaryFunctor
Base class for unary scalar functors that return the real part of T (Math::ScalarReal,...
Definition: Functional.hpp:273
CDPL::Math::ScalarRealUnaryFunctor::ResultType
TypeTraits< T >::RealType ResultType
The real-valued result type derived from ValueType via Math::TypeTraits.
Definition: Functional.hpp:288
CDPL::Math::ScalarRealUnaryFunctor::ArgumentType
const T & ArgumentType
The argument type (a const reference to ValueType).
Definition: Functional.hpp:283
CDPL::Math::ScalarRealUnaryFunctor::ValueType
T ValueType
The scalar value type.
Definition: Functional.hpp:278
CDPL::Math::ScalarReal
Scalar real-part functor: apply(v) returns (identity for real types).
Definition: Functional.hpp:297
CDPL::Math::ScalarReal::ArgumentType
ScalarUnaryFunctor< T >::ArgumentType ArgumentType
Definition: Functional.hpp:300
CDPL::Math::ScalarReal::ValueType
ScalarUnaryFunctor< T >::ValueType ValueType
Definition: Functional.hpp:299
CDPL::Math::ScalarReal::apply
static ResultType apply(ArgumentType v)
Returns the real part of v.
Definition: Functional.hpp:308
CDPL::Math::ScalarReal::ResultType
ScalarUnaryFunctor< T >::ResultType ResultType
Definition: Functional.hpp:301
CDPL::Math::ScalarSubtractionAssignment
Scalar in-place subtraction functor: apply(t1, t2) performs t1 -= t2.
Definition: Functional.hpp:131
CDPL::Math::ScalarSubtractionAssignment::Argument2Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:134
CDPL::Math::ScalarSubtractionAssignment::apply
static void apply(Argument1Type t1, Argument2Type t2)
Performs t1 -= t2.
Definition: Functional.hpp:141
CDPL::Math::ScalarSubtractionAssignment::Argument1Type
ScalarBinaryAssignmentFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:133
CDPL::Math::ScalarSubtraction
Scalar binary subtraction functor: apply(t1, t2) returns t1 - t2.
Definition: Functional.hpp:398
CDPL::Math::ScalarSubtraction::ResultType
ScalarBinaryFunctor< T1, T2 >::ResultType ResultType
Definition: Functional.hpp:402
CDPL::Math::ScalarSubtraction::Argument2Type
ScalarBinaryFunctor< T1, T2 >::Argument2Type Argument2Type
Definition: Functional.hpp:401
CDPL::Math::ScalarSubtraction::Argument1Type
ScalarBinaryFunctor< T1, T2 >::Argument1Type Argument1Type
Definition: Functional.hpp:400
CDPL::Math::ScalarSubtraction::apply
static ResultType apply(Argument1Type t1, Argument2Type t2)
Returns t1 - t2.
Definition: Functional.hpp:410
CDPL::Math::ScalarTraits::real
static RealType real(ConstReference t)
Returns the real part of t (identical to t for non-complex scalars).
Definition: TypeTraits.hpp:113
CDPL::Math::ScalarTraits::conj
static RealType conj(ConstReference t)
Returns the complex conjugate of t (identical to t for non-complex scalars).
Definition: TypeTraits.hpp:132
CDPL::Math::ScalarTraits::normInf
static RealType normInf(ConstReference t)
Returns the L∞ norm of t (identical to the absolute value for scalar values).
Definition: TypeTraits.hpp:182
CDPL::Math::ScalarTraits::imag
static RealType imag(ConstReference)
Returns the imaginary part (always zero for non-complex scalars).
Definition: TypeTraits.hpp:122
CDPL::Math::ScalarTraits::sqrt
static ValueType sqrt(ConstReference t)
Returns the square root of t.
Definition: TypeTraits.hpp:152
CDPL::Math::ScalarTraits::norm2
static RealType norm2(ConstReference t)
Returns the L2 (Euclidean) norm of t (identical to the absolute value for scalar values).
Definition: TypeTraits.hpp:172
CDPL::Math::ScalarTraits::RealType
T RealType
The real-valued type (identical to ValueType for scalar traits).
Definition: TypeTraits.hpp:96
CDPL::Math::ScalarUnaryFunctor
Base class for unary scalar functors of the form F::apply(const T&) returning a T result.
Definition: Functional.hpp:203
CDPL::Math::ScalarUnaryFunctor::ValueType
T ValueType
The scalar value type.
Definition: Functional.hpp:208
CDPL::Math::ScalarUnaryFunctor::ArgumentType
const T & ArgumentType
The argument type (a const reference to ValueType).
Definition: Functional.hpp:213
CDPL::Math::ScalarUnaryFunctor::ResultType
ValueType ResultType
The result type of apply().
Definition: Functional.hpp:218
CDPL::Math::TypeTraits
Primary traits template for scalar arithmetic value types.
Definition: TypeTraits.hpp:307
CDPL::Math::VectorAngleCosine
Functor returning the cosine of the angle between two vectors (optionally clamped to [-1,...
Definition: Functional.hpp:521
CDPL::Math::VectorAngleCosine::apply
static ResultType apply(const VectorExpression< V1 > &e1, const VectorExpression< V2 > &e2, const T &sd, bool clamp)
Returns the cosine of the angle between e1 and e2.
Definition: Functional.hpp:533
CDPL::Math::VectorAngleCosine::ResultType
CommonType< typename VectorInnerProduct< V1, V2 >::ResultType, T >::Type ResultType
Definition: Functional.hpp:523
CDPL::Math::VectorBinaryFunctor
Base class for binary functors that take two vectors and return a vector (Math::VectorCrossProduct).
Definition: Functional.hpp:678
CDPL::Math::VectorBinaryFunctor::ResultType
CommonType< typename V1::ValueType, typename V2::ValueType >::Type ResultType
The element result type (common type of the two vector element types).
Definition: Functional.hpp:683
CDPL::Math::VectorBooleanBinaryFunctor
Base class for binary functors that take two vectors and return a boolean (Math::VectorEquality and s...
Definition: Functional.hpp:551
CDPL::Math::VectorBooleanBinaryFunctor::ValueType
CommonType< typename V1::ValueType, typename V2::ValueType >::Type ValueType
The element value type (common type of the two vector element types).
Definition: Functional.hpp:566
CDPL::Math::VectorBooleanBinaryFunctor::ResultType
bool ResultType
The boolean result type.
Definition: Functional.hpp:556
CDPL::Math::VectorBooleanBinaryFunctor::SizeType
CommonType< typename V1::SizeType, typename V2::SizeType >::Type SizeType
The unsigned size type (common type of the two vector size types).
Definition: Functional.hpp:561
CDPL::Math::VectorCrossProduct
Vector cross-product functor: apply(e1, e2, i) returns the i-th component of the 3D vector cross prod...
Definition: Functional.hpp:693
CDPL::Math::VectorCrossProduct::apply
static ResultType apply(const VectorExpression< E1 > &e1, const VectorExpression< E2 > &e2, SizeType i)
Returns the i-th component of the cross product .
Definition: Functional.hpp:709
CDPL::Math::VectorCrossProduct::ResultType
VectorScalarBinaryFunctor< V1, V2 >::ResultType ResultType
Definition: Functional.hpp:695
CDPL::Math::VectorElementSum
Functor returning the sum of all elements of a vector expression.
Definition: Functional.hpp:756
CDPL::Math::VectorElementSum::ResultType
VectorScalarUnaryFunctor< V >::ResultType ResultType
Definition: Functional.hpp:758
CDPL::Math::VectorElementSum::apply
static ResultType apply(const VectorExpression< V > &e)
Returns the sum of all elements of e.
Definition: Functional.hpp:765
CDPL::Math::VectorEquality
Vector equality functor: apply(e1, e2) tests element-wise equality of two vector expressions.
Definition: Functional.hpp:576
CDPL::Math::VectorEquality::ValueType
VectorBooleanBinaryFunctor< V1, V2 >::ValueType ValueType
Definition: Functional.hpp:579
CDPL::Math::VectorEquality::SizeType
VectorBooleanBinaryFunctor< V1, V2 >::SizeType SizeType
Definition: Functional.hpp:578
CDPL::Math::VectorEquality::ResultType
VectorBooleanBinaryFunctor< V1, V2 >::ResultType ResultType
Definition: Functional.hpp:580
CDPL::Math::VectorEquality::apply
static ResultType apply(const VectorExpression< V1 > &e1, const VectorExpression< V2 > &e2)
Tells whether the vector expressions e1 and e2 are element-wise equal.
Definition: Functional.hpp:588
CDPL::Math::VectorInnerProduct
Vector inner-product functor: apply(e1, e2) returns .
Definition: Functional.hpp:488
CDPL::Math::VectorInnerProduct::ResultType
VectorScalarBinaryFunctor< V1, V2 >::ResultType ResultType
Definition: Functional.hpp:490
CDPL::Math::VectorInnerProduct::apply
static ResultType apply(const VectorExpression< V1 > &e1, const VectorExpression< V2 > &e2)
Returns the inner product of e1 and e2.
Definition: Functional.hpp:499
CDPL::Math::VectorMatrixProduct
Functor returning element i of the vector-matrix product .
Definition: Functional.hpp:1500
CDPL::Math::VectorMatrixProduct::ResultType
MatrixVectorBinaryFunctor< M, V >::ResultType ResultType
Definition: Functional.hpp:1504
CDPL::Math::VectorMatrixProduct::SizeType
MatrixVectorBinaryFunctor< M, V >::SizeType SizeType
Definition: Functional.hpp:1503
CDPL::Math::VectorMatrixProduct::apply
static ResultType apply(const VectorExpression< E1 > &e1, const MatrixExpression< E2 > &e2, SizeType i)
Returns element i of the vector-matrix product .
Definition: Functional.hpp:1517
CDPL::Math::VectorMatrixProduct::ValueType
MatrixVectorBinaryFunctor< M, V >::ValueType ValueType
Definition: Functional.hpp:1502
CDPL::Math::VectorMatrixUnaryFunctor
Base class for unary functors that produce a matrix element from a vector expression and (i,...
Definition: Functional.hpp:1315
CDPL::Math::VectorMatrixUnaryFunctor::ResultType
V::ValueType ResultType
The matrix element result type (the vector's element value type).
Definition: Functional.hpp:1320
CDPL::Math::VectorMatrixUnaryFunctor::SizeType
V::SizeType SizeType
The unsigned size type used by the vector.
Definition: Functional.hpp:1325
CDPL::Math::VectorNorm1
Functor returning the L1 norm of a vector expression.
Definition: Functional.hpp:808
CDPL::Math::VectorNorm1::apply
static ResultType apply(const VectorExpression< V > &e)
Returns the L1 norm of e.
Definition: Functional.hpp:819
CDPL::Math::VectorNorm1::RealType
VectorScalarRealUnaryFunctor< V >::RealType RealType
Definition: Functional.hpp:811
CDPL::Math::VectorNorm1::ValueType
VectorScalarRealUnaryFunctor< V >::ValueType ValueType
Definition: Functional.hpp:810
CDPL::Math::VectorNorm1::ResultType
VectorScalarRealUnaryFunctor< V >::ResultType ResultType
Definition: Functional.hpp:812
CDPL::Math::VectorNorm2
Functor returning the L2 (Euclidean) norm of a vector expression.
Definition: Functional.hpp:838
CDPL::Math::VectorNorm2::ResultType
VectorScalarRealUnaryFunctor< V >::ResultType ResultType
Definition: Functional.hpp:842
CDPL::Math::VectorNorm2::RealType
VectorScalarRealUnaryFunctor< V >::RealType RealType
Definition: Functional.hpp:841
CDPL::Math::VectorNorm2::apply
static ResultType apply(const VectorExpression< V > &e)
Returns the L2 norm of e.
Definition: Functional.hpp:849
CDPL::Math::VectorNorm2::ValueType
VectorScalarRealUnaryFunctor< V >::ValueType ValueType
Definition: Functional.hpp:840
CDPL::Math::VectorNormInfinityIndex
Functor returning the index of the vector element with the largest L∞ norm.
Definition: Functional.hpp:929
CDPL::Math::VectorNormInfinityIndex::ResultType
VectorScalarIndexUnaryFunctor< V >::ResultType ResultType
Definition: Functional.hpp:933
CDPL::Math::VectorNormInfinityIndex::ValueType
VectorScalarIndexUnaryFunctor< V >::ValueType ValueType
Definition: Functional.hpp:931
CDPL::Math::VectorNormInfinityIndex::RealType
VectorScalarIndexUnaryFunctor< V >::RealType RealType
Definition: Functional.hpp:932
CDPL::Math::VectorNormInfinityIndex::apply
static ResultType apply(const VectorExpression< V > &e)
Returns the index of the element of e with the largest L∞ norm.
Definition: Functional.hpp:940
CDPL::Math::VectorNormInfinity
Functor returning the L∞ (maximum-magnitude) norm of a vector expression.
Definition: Functional.hpp:871
CDPL::Math::VectorNormInfinity::apply
static ResultType apply(const VectorExpression< V > &e)
Returns the L∞ norm of e.
Definition: Functional.hpp:882
CDPL::Math::VectorNormInfinity::ValueType
VectorScalarRealUnaryFunctor< V >::ValueType ValueType
Definition: Functional.hpp:873
CDPL::Math::VectorNormInfinity::RealType
VectorScalarRealUnaryFunctor< V >::RealType RealType
Definition: Functional.hpp:874
CDPL::Math::VectorNormInfinity::ResultType
VectorScalarRealUnaryFunctor< V >::ResultType ResultType
Definition: Functional.hpp:875
CDPL::Math::VectorScalarBinaryFunctor
Base class for binary functors that take two vectors and return a scalar (Math::VectorInnerProduct,...
Definition: Functional.hpp:473
CDPL::Math::VectorScalarBinaryFunctor::ResultType
CommonType< typename V1::ValueType, typename V2::ValueType >::Type ResultType
The scalar result type (common type of the two vector element types).
Definition: Functional.hpp:478
CDPL::Math::VectorScalarIndexUnaryFunctor
Base class for unary functors that take a vector and return a vector-element index (Math::VectorNormI...
Definition: Functional.hpp:905
CDPL::Math::VectorScalarIndexUnaryFunctor::RealType
TypeTraits< ValueType >::RealType RealType
The real-valued type derived from ValueType via Math::TypeTraits.
Definition: Functional.hpp:915
CDPL::Math::VectorScalarIndexUnaryFunctor::ValueType
V::ValueType ValueType
The vector's element value type.
Definition: Functional.hpp:910
CDPL::Math::VectorScalarIndexUnaryFunctor::ResultType
V::SizeType ResultType
The result type (the vector's size type, used for element indices).
Definition: Functional.hpp:920
CDPL::Math::VectorScalarRealUnaryFunctor
Base class for unary functors that take a vector and return a real-valued scalar (Math::VectorNorm1,...
Definition: Functional.hpp:784
CDPL::Math::VectorScalarRealUnaryFunctor::ResultType
RealType ResultType
The real-valued result type.
Definition: Functional.hpp:799
CDPL::Math::VectorScalarRealUnaryFunctor::RealType
TypeTraits< ValueType >::RealType RealType
The real-valued type derived from ValueType via Math::TypeTraits.
Definition: Functional.hpp:794
CDPL::Math::VectorScalarRealUnaryFunctor::ValueType
V::ValueType ValueType
The vector's element value type.
Definition: Functional.hpp:789
CDPL::Math::VectorScalarUnaryFunctor
Base class for unary functors that take a vector and return a scalar (Math::VectorElementSum).
Definition: Functional.hpp:737
CDPL::Math::VectorScalarUnaryFunctor::ResultType
V::ValueType ResultType
The scalar result type (the vector's element value type).
Definition: Functional.hpp:742
CDPL::Math::VectorScalarUnaryFunctor::SizeType
V::SizeType SizeType
The unsigned size type used by the vector.
Definition: Functional.hpp:747
CDPL::Math::VectorToleranceEquality
Vector tolerance-equality functor: apply(e1, e2, eps) tests element-wise equality within an absolute ...
Definition: Functional.hpp:640
CDPL::Math::VectorToleranceEquality::ValueType
Scalar3VectorBooleanTernaryFunctor< V1, V2, T >::ValueType ValueType
Definition: Functional.hpp:643
CDPL::Math::VectorToleranceEquality::SizeType
Scalar3VectorBooleanTernaryFunctor< V1, V2, T >::SizeType SizeType
Definition: Functional.hpp:642
CDPL::Math::VectorToleranceEquality::Argument3Type
Scalar3VectorBooleanTernaryFunctor< V1, V2, T >::Argument3Type Argument3Type
Definition: Functional.hpp:645
CDPL::Math::VectorToleranceEquality::ResultType
Scalar3VectorBooleanTernaryFunctor< V1, V2, T >::ResultType ResultType
Definition: Functional.hpp:644
CDPL::Math::VectorToleranceEquality::apply
static ResultType apply(const VectorExpression< V1 > &e1, const VectorExpression< V2 > &e2, Argument3Type epsilon)
Tells whether the vector expressions e1 and e2 are element-wise equal within an absolute tolerance ep...
Definition: Functional.hpp:654
Generated by doxygen 1.9.1