--- /dev/null
+/* -*- C++ -*- ------------------------------------------------------------
+
+Copyright (c) 2007 Jesse Anders and Demian Nave http://cmldev.net/
+
+The Configurable Math Library (CML) is distributed under the terms of the
+Boost Software License, v1.0 (see cml/LICENSE for details).
+
+ *-----------------------------------------------------------------------*/
+/** @file
+ * @brief Defines the various combinations of matrix expressions.
+ *
+ * Create unary and binary operators with macros. The available combinations
+ * are:
+ *
+ * Unary expressions:
+ *
+ * op Matrix -> Matrix
+ * op MatXpr -> Matrix
+ *
+ * Binary expressions:
+ *
+ * Matrix op Matrix -> Matrix
+ * MatXpr op Matrix -> MatXpr
+ * Matrix op MatXpr -> MatXpr
+ * MatXpr op MatXpr -> MatXpr
+ *
+ * Matrix op Scalar -> Matrix
+ * Scalar op Matrix -> Matrix
+ * MatXpr op Scalar -> MatXpr
+ * Scalar op MatXpr -> MatXpr
+ *
+ * All of the generator functions compress the expression tree by hoisting
+ * subexpressions into the containing expression. This has the effect of
+ * forcing only the root node of the expression tree to be a MatrixXpr.
+ * Every other node is a Unary or BinaryMatrixOp.
+ */
+#ifndef matop_macros_h
+#define matop_macros_h
+
+/** Declare a unary operator taking a matrix operand. */
+#define CML_MAT_UNIOP(_op_, _OpT_) \
+template<typename E, class AT, typename BO, typename L> \
+inline et::MatrixXpr< \
+ et::UnaryMatrixOp< matrix<E,AT,BO,L>, _OpT_ <E> > \
+> \
+ \
+_op_ (const matrix<E,AT,BO,L>& arg) \
+{ \
+ typedef et::UnaryMatrixOp< \
+ matrix<E,AT,BO,L>, _OpT_ <E> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(arg)); \
+}
+
+/** Declare a unary operator taking a et::MatrixXpr operand. */
+#define CML_MATXPR_UNIOP(_op_, _OpT_) \
+template<class XprT> \
+inline et::MatrixXpr< \
+ et::UnaryMatrixOp<XprT, _OpT_<typename XprT::value_type> > \
+> \
+ \
+_op_ (MATXPR_ARG_TYPE arg) \
+{ \
+ typedef et::UnaryMatrixOp< \
+ XprT, _OpT_<typename XprT::value_type> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(arg.expression())); \
+}
+
+/** Declare an operator taking two matrix operands. */
+#define CML_MAT_MAT_BINOP(_op_, _OpT_) \
+template<typename E1, class AT1, typename L1, \
+ typename E2, class AT2, typename L2, typename BO> \
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ matrix<E1,AT1,BO,L2>, matrix<E2,AT2,BO,L2>, _OpT_<E1,E2> > \
+> \
+ \
+_op_ ( \
+ const matrix<E1,AT1,BO,L1>& left, \
+ const matrix<E2,AT2,BO,L2>& right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ matrix<E1,AT1,BO,L1>, matrix<E2,AT2,BO,L2>, _OpT_<E1,E2> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(left,right)); \
+}
+
+/** Declare an operator taking a matrix and a et::MatrixXpr. */
+#define CML_MAT_MATXPR_BINOP(_op_, _OpT_) \
+template<typename E, class AT, typename BO, typename L, class XprT> \
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ matrix<E,AT,BO,L>, XprT, _OpT_ <E, typename XprT::value_type> \
+ > \
+> \
+ \
+_op_ ( \
+ const matrix<E,AT,BO,L>& left, \
+ MATXPR_ARG_TYPE right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ matrix<E,AT,BO,L>, XprT, \
+ _OpT_ <E, typename XprT::value_type> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(left,right.expression())); \
+}
+
+/** Declare an operator taking a et::MatrixXpr and a matrix. */
+#define CML_MATXPR_MAT_BINOP(_op_, _OpT_) \
+template<class XprT, typename E, class AT, typename BO, typename L> \
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ XprT, matrix<E,AT,BO,L>, _OpT_ <typename XprT::value_type, E> \
+ > \
+> \
+ \
+_op_ ( \
+ MATXPR_ARG_TYPE left, \
+ const matrix<E,AT,BO,L>& right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ XprT, matrix<E,AT,BO,L>, \
+ _OpT_ <typename XprT::value_type, E> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(left.expression(),right)); \
+}
+
+/** Declare an operator taking two et::MatrixXpr operands. */
+#define CML_MATXPR_MATXPR_BINOP(_op_, _OpT_) \
+template<class XprT1, class XprT2> \
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ XprT1, XprT2, \
+ _OpT_ < \
+ typename XprT1::value_type, \
+ typename XprT2::value_type \
+ > \
+ > \
+> \
+ \
+_op_ ( \
+ MATXPR_ARG_TYPE_N(1) left, \
+ MATXPR_ARG_TYPE_N(2) right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ XprT1, XprT2, \
+ _OpT_ < \
+ typename XprT1::value_type, \
+ typename XprT2::value_type> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>( \
+ ExprT(left.expression(),right.expression())); \
+}
+
+
+/** Declare an operator taking a matrix and a scalar. */
+#define CML_MAT_SCALAR_BINOP(_op_, _OpT_) \
+template<typename E, class AT, typename BO, typename L, typename ScalarT>\
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ matrix<E,AT,BO,L>, ScalarT, _OpT_ <E,ScalarT> \
+ > \
+> \
+ \
+_op_ ( \
+ const matrix<E,AT,BO,L>& left, \
+ SCALAR_ARG_TYPE right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ matrix<E,AT,BO,L>, ScalarT, _OpT_ <E,ScalarT > \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(left,right)); \
+}
+
+/** Declare an operator taking a scalar and a matrix. */
+#define CML_SCALAR_MAT_BINOP(_op_, _OpT_) \
+template<typename ScalarT, typename E, class AT, typename BO, typename L>\
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ ScalarT, matrix<E,AT,BO,L>, _OpT_ <ScalarT,E> \
+ > \
+> \
+ \
+_op_ ( \
+ SCALAR_ARG_TYPE left, \
+ const matrix<E,AT,BO,L>& right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ ScalarT, matrix<E,AT,BO,L>, _OpT_<ScalarT,E> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(left,right)); \
+}
+
+/** Declare an operator taking a et::MatrixXpr and a scalar. */
+#define CML_MATXPR_SCALAR_BINOP(_op_, _OpT_) \
+template<class XprT, typename ScalarT> \
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ XprT, ScalarT, _OpT_ <typename XprT::value_type, ScalarT> \
+ > \
+> \
+ \
+_op_ ( \
+ MATXPR_ARG_TYPE left, \
+ SCALAR_ARG_TYPE right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ XprT, ScalarT, _OpT_ <typename XprT::value_type,ScalarT> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(left.expression(),right)); \
+}
+
+/** Declare an operator taking a scalar and a et::MatrixXpr. */
+#define CML_SCALAR_MATXPR_BINOP(_op_, _OpT_) \
+template<typename ScalarT, class XprT> \
+inline et::MatrixXpr< \
+ et::BinaryMatrixOp< \
+ ScalarT, XprT, _OpT_ <ScalarT, typename XprT::value_type> \
+ > \
+> \
+ \
+_op_ ( \
+ SCALAR_ARG_TYPE left, \
+ MATXPR_ARG_TYPE right) \
+{ \
+ typedef et::BinaryMatrixOp< \
+ ScalarT, XprT, _OpT_ <ScalarT, typename XprT::value_type> \
+ > ExprT; \
+ return et::MatrixXpr<ExprT>(ExprT(left,right.expression())); \
+}
+
+#endif
+
+// -------------------------------------------------------------------------
+// vim:ft=cpp
projects / chaz / yoink / blobdiff