LSSTApplications  10.0-2-g4f67435,11.0.rc2+1,11.0.rc2+12,11.0.rc2+3,11.0.rc2+4,11.0.rc2+5,11.0.rc2+6,11.0.rc2+7,11.0.rc2+8
LSSTDataManagementBasePackage
Functions
Operators

Functions

template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator+ (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator+ (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator+ (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator- (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator- (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator- (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator* (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator* (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator* (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator/ (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator/ (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator/ (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator% (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator% (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator% (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator^ (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator^ (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator^ (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator| (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator| (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator| (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator& (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator& (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator& (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator<< (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator<< (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator<< (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator>> (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::operator>> (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::operator>> (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::not_equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::not_equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::not_equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::less (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::less (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::less (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::greater (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::greater (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::greater (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::less_equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::less_equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::less_equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::great_equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::great_equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::great_equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::logical_and (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::logical_and (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::logical_and (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::logical_or (ExpressionBase< Operand > const &operand, Scalar const &scalar)
 
template<typename Operand , typename Scalar >
< unspecified-expression-type > ndarray::logical_or (Scalar const &scalar, ExpressionBase< Operand > const &operand)
 
template<typename Operand1 , typename Operand2 >
< unspecified-expression-type > ndarray::logical_or (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)
 
template<typename Operand >
< unspecified-expression-type > ndarray::operator- (ExpressionBase< Operand > const &operand)
 
template<typename Operand >
< unspecified-expression-type > ndarray::logical_not (ExpressionBase< Operand > const &operand)
 
template<typename Operand >
< unspecified-expression-type > ndarray::operator~ (ExpressionBase< Operand > const &operand)
 

Detailed Description

Function Documentation

template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::equal ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 796 of file operators.h.

796  {
797  return vectorize(detail::EqualToTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
798  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::equal ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 809 of file operators.h.

809  {
810  return vectorize(detail::EqualToTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
811  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::equal ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 822 of file operators.h.

822  {
823  return vectorize(
824  typename detail::EqualToTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
825  operand1,
826  operand2
827  );
828  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::great_equal ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 1011 of file operators.h.

1011  {
1012  return vectorize(detail::GreaterEqualTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
1013  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::great_equal ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 1024 of file operators.h.

1024  {
1025  return vectorize(detail::GreaterEqualTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
1026  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::great_equal ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 1037 of file operators.h.

1037  {
1038  return vectorize(
1039  typename detail::GreaterEqualTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
1040  operand1,
1041  operand2
1042  );
1043  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::greater ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 925 of file operators.h.

925  {
926  return vectorize(detail::GreaterTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
927  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::greater ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 938 of file operators.h.

938  {
939  return vectorize(detail::GreaterTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
940  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::greater ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 951 of file operators.h.

951  {
952  return vectorize(
953  typename detail::GreaterTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
954  operand1,
955  operand2
956  );
957  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::less ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 882 of file operators.h.

882  {
883  return vectorize(detail::LessTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
884  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::less ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 895 of file operators.h.

895  {
896  return vectorize(detail::LessTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
897  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::less ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 908 of file operators.h.

908  {
909  return vectorize(
910  typename detail::LessTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
911  operand1,
912  operand2
913  );
914  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::less_equal ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 968 of file operators.h.

968  {
969  return vectorize(detail::LessEqualTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
970  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::less_equal ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 981 of file operators.h.

981  {
982  return vectorize(detail::LessEqualTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
983  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::less_equal ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 994 of file operators.h.

994  {
995  return vectorize(
996  typename detail::LessEqualTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
997  operand1,
998  operand2
999  );
1000  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::logical_and ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 1054 of file operators.h.

1054  {
1055  return vectorize(detail::LogicalAnd::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
1056  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::logical_and ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 1067 of file operators.h.

1067  {
1068  return vectorize(detail::LogicalAnd::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
1069  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::logical_and ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 1080 of file operators.h.

1080  {
1081  return vectorize(
1082  typename detail::LogicalAnd::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
1083  operand1,
1084  operand2
1085  );
1086  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand >
<unspecified-expression-type> ndarray::logical_not ( ExpressionBase< Operand > const &  operand)

Definition at line 1148 of file operators.h.

1148  {
1149  return vectorize(std::logical_not<typename ExpressionTraits<Operand>::Element>(),operand);
1150  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
ndarray::logical_not
< unspecified-expression-type > logical_not(ExpressionBase< Operand > const &operand)
Definition: operators.h:1148
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::logical_or ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 1097 of file operators.h.

1097  {
1098  return vectorize(detail::LogicalOr::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
1099  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::logical_or ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 1110 of file operators.h.

1110  {
1111  return vectorize(detail::LogicalOr::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
1112  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::logical_or ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 1123 of file operators.h.

1123  {
1124  return vectorize(
1125  typename detail::LogicalOr::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
1126  operand1,
1127  operand2
1128  );
1129  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::not_equal ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 839 of file operators.h.

839  {
840  return vectorize(detail::NotEqualToTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
841  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::not_equal ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 852 of file operators.h.

852  {
853  return vectorize(detail::NotEqualToTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
854  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::not_equal ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 865 of file operators.h.

865  {
866  return vectorize(
867  typename detail::NotEqualToTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
868  operand1,
869  operand2
870  );
871  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator% ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 537 of file operators.h.

537  {
538  return vectorize(detail::ModulusTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
539  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator% ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 550 of file operators.h.

550  {
551  return vectorize(detail::ModulusTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
552  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator% ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 563 of file operators.h.

563  {
564  return vectorize(
565  typename detail::ModulusTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
566  operand1,
567  operand2
568  );
569  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator& ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 666 of file operators.h.

666  {
667  return vectorize(detail::BitwiseAndTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
668  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator& ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 679 of file operators.h.

679  {
680  return vectorize(detail::BitwiseAndTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
681  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator& ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 692 of file operators.h.

692  {
693  return vectorize(
694  typename detail::BitwiseAndTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
695  operand1,
696  operand2
697  );
698  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator* ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 451 of file operators.h.

451  {
452  return vectorize(detail::MultipliesTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
453  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator* ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 464 of file operators.h.

464  {
465  return vectorize(detail::MultipliesTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
466  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator* ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 477 of file operators.h.

477  {
478  return vectorize(
479  typename detail::MultipliesTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
480  operand1,
481  operand2
482  );
483  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator+ ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 365 of file operators.h.

365  {
366  return vectorize(detail::PlusTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
367  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator+ ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 378 of file operators.h.

378  {
379  return vectorize(detail::PlusTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
380  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator+ ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 391 of file operators.h.

391  {
392  return vectorize(
393  typename detail::PlusTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
394  operand1,
395  operand2
396  );
397  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator- ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 408 of file operators.h.

408  {
409  return vectorize(detail::MinusTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
410  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator- ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 421 of file operators.h.

421  {
422  return vectorize(detail::MinusTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
423  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator- ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 434 of file operators.h.

434  {
435  return vectorize(
436  typename detail::MinusTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
437  operand1,
438  operand2
439  );
440  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand >
<unspecified-expression-type> ndarray::operator- ( ExpressionBase< Operand > const &  operand)

Definition at line 1138 of file operators.h.

1138  {
1139  return vectorize(std::negate<typename ExpressionTraits<Operand>::Element>(),operand);
1140  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator/ ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 494 of file operators.h.

494  {
495  return vectorize(detail::DividesTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
496  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator/ ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 507 of file operators.h.

507  {
508  return vectorize(detail::DividesTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
509  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator/ ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 520 of file operators.h.

520  {
521  return vectorize(
522  typename detail::DividesTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
523  operand1,
524  operand2
525  );
526  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator<< ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 709 of file operators.h.

709  {
710  return vectorize(detail::BitwiseLeftShiftTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
711  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator<< ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 722 of file operators.h.

722  {
723  return vectorize(detail::BitwiseLeftShiftTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
724  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator<< ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 735 of file operators.h.

735  {
736  return vectorize(
737  typename detail::BitwiseLeftShiftTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
738  operand1,
739  operand2
740  );
741  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator>> ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 752 of file operators.h.

752  {
753  return vectorize(detail::BitwiseRightShiftTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
754  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator>> ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 765 of file operators.h.

765  {
766  return vectorize(detail::BitwiseRightShiftTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
767  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator>> ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 778 of file operators.h.

778  {
779  return vectorize(
780  typename detail::BitwiseRightShiftTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
781  operand1,
782  operand2
783  );
784  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator^ ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 580 of file operators.h.

580  {
581  return vectorize(detail::BitwiseXorTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
582  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator^ ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 593 of file operators.h.

593  {
594  return vectorize(detail::BitwiseXorTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
595  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator^ ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 606 of file operators.h.

606  {
607  return vectorize(
608  typename detail::BitwiseXorTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
609  operand1,
610  operand2
611  );
612  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator| ( ExpressionBase< Operand > const &  operand,
Scalar const &  scalar 
)

Definition at line 623 of file operators.h.

623  {
624  return vectorize(detail::BitwiseOrTag::template ExprScalar<Operand,Scalar>::bind(scalar),operand);
625  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand , typename Scalar >
<unspecified-expression-type> ndarray::operator| ( Scalar const &  scalar,
ExpressionBase< Operand > const &  operand 
)

Definition at line 636 of file operators.h.

636  {
637  return vectorize(detail::BitwiseOrTag::template ScalarExpr<Operand,Scalar>::bind(scalar),operand);
638  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand1 , typename Operand2 >
<unspecified-expression-type> ndarray::operator| ( ExpressionBase< Operand1 > const &  operand1,
ExpressionBase< Operand2 > const &  operand2 
)

Definition at line 649 of file operators.h.

649  {
650  return vectorize(
651  typename detail::BitwiseOrTag::template ExprExpr<Operand1,Operand2>::BinaryFunction(),
652  operand1,
653  operand2
654  );
655  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
template<typename Operand >
<unspecified-expression-type> ndarray::operator~ ( ExpressionBase< Operand > const &  operand)

Definition at line 1158 of file operators.h.

1158  {
1159  return vectorize(detail::BitwiseNot<typename ExpressionTraits<Operand>::Element>(),operand);
1160  }
ndarray::vectorize
UnaryFunction::result_type vectorize(UnaryFunction const &functor, Scalar const &scalar)
Apply a non-mutating unary function object to a scalar.
Definition: vectorize.h:85
Generated on Wed Sep 16 2015 13:35:37 for LSSTApplications by   doxygen 1.8.5