![]() |
Header file for the Proxy class. More...
#include <blaze/math/Aliases.h>
#include <blaze/math/Exception.h>
#include <blaze/math/InversionFlag.h>
#include <blaze/math/proxy/ComplexProxy.h>
#include <blaze/math/proxy/DefaultProxy.h>
#include <blaze/math/proxy/DenseMatrixProxy.h>
#include <blaze/math/proxy/DenseVectorProxy.h>
#include <blaze/math/proxy/SparseMatrixProxy.h>
#include <blaze/math/proxy/SparseVectorProxy.h>
#include <blaze/math/shims/Abs.h>
#include <blaze/math/shims/Acos.h>
#include <blaze/math/shims/Acosh.h>
#include <blaze/math/shims/Asin.h>
#include <blaze/math/shims/Asinh.h>
#include <blaze/math/shims/Atan.h>
#include <blaze/math/shims/Atanh.h>
#include <blaze/math/shims/Cbrt.h>
#include <blaze/math/shims/Ceil.h>
#include <blaze/math/shims/Conjugate.h>
#include <blaze/math/shims/Cos.h>
#include <blaze/math/shims/Cosh.h>
#include <blaze/math/shims/Erf.h>
#include <blaze/math/shims/Erfc.h>
#include <blaze/math/shims/Exp.h>
#include <blaze/math/shims/Floor.h>
#include <blaze/math/shims/Imaginary.h>
#include <blaze/math/shims/InvCbrt.h>
#include <blaze/math/shims/Invert.h>
#include <blaze/math/shims/InvSqrt.h>
#include <blaze/math/shims/IsNaN.h>
#include <blaze/math/shims/IsOne.h>
#include <blaze/math/shims/IsReal.h>
#include <blaze/math/shims/IsZero.h>
#include <blaze/math/shims/Pow.h>
#include <blaze/math/shims/Real.h>
#include <blaze/math/shims/Sin.h>
#include <blaze/math/shims/Sinh.h>
#include <blaze/math/shims/Sqrt.h>
#include <blaze/math/shims/Tan.h>
#include <blaze/math/shims/Tanh.h>
#include <blaze/math/traits/AddExprTrait.h>
#include <blaze/math/traits/DivExprTrait.h>
#include <blaze/math/traits/MultExprTrait.h>
#include <blaze/math/traits/SubExprTrait.h>
#include <blaze/math/typetraits/IsDenseMatrix.h>
#include <blaze/math/typetraits/IsDenseVector.h>
#include <blaze/math/typetraits/IsMatrix.h>
#include <blaze/math/typetraits/IsProxy.h>
#include <blaze/math/typetraits/IsVector.h>
#include <blaze/util/DisableIf.h>
#include <blaze/util/mpl/If.h>
#include <blaze/util/typetraits/IsComplex.h>
Go to the source code of this file.
Classes | |
class | blaze::Proxy< PT, RT > |
Proxy base class.The Proxy class is a base class for all proxy classes within the Blaze library that may represent non-numeric data types (vectors, matrices, ...). It augments the interface of the deriving proxy class depending on the data type represented by the proxy. In addition, it provides an abstraction from the actual type of the proxy, but enables a type-safe conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More... | |
Namespaces | |
blaze | |
Namespace of the Blaze C++ math library. | |
Functions | |
template<typename PT , typename RT > | |
auto | blaze::erf (const Proxy< PT, RT > &proxy) -> decltype(erf(std::declval< RepresentedType_< PT > >())) |
Computing the error function of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::erfc (const Proxy< PT, RT > &proxy) -> decltype(erfc(std::declval< RepresentedType_< PT > >())) |
Computing the complementary error function of the represented element. More... | |
Proxy operators | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
AddExprTrait_< RT1, RT2 > | blaze::operator+ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Addition between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, AddExprTrait_< RT, T > > | blaze::operator+ (const Proxy< PT, RT > &lhs, const T &rhs) |
Addition between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, AddExprTrait_< T, RT > > | blaze::operator+ (const T &lhs, const Proxy< PT, RT > &rhs) |
Addition between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
SubExprTrait_< RT1, RT2 > | blaze::operator- (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Subtraction between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, SubExprTrait_< RT, T > > | blaze::operator- (const Proxy< PT, RT > &lhs, const T &rhs) |
Subtraction between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, SubExprTrait_< T, RT > > | blaze::operator- (const T &lhs, const Proxy< PT, RT > &rhs) |
Subtraction between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
MultExprTrait_< RT1, RT2 > | blaze::operator* (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Multiplication between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, MultExprTrait_< RT, T > > | blaze::operator* (const Proxy< PT, RT > &lhs, const T &rhs) |
Multiplication between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, MultExprTrait_< T, RT > > | blaze::operator* (const T &lhs, const Proxy< PT, RT > &rhs) |
Multiplication between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
DivExprTrait_< RT1, RT2 > | blaze::operator/ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Division between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, DivExprTrait_< RT, T > > | blaze::operator/ (const Proxy< PT, RT > &lhs, const T &rhs) |
Division between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, DivExprTrait_< T, RT > > | blaze::operator/ (const T &lhs, const Proxy< PT, RT > &rhs) |
Division between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator== (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Equality comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator== (const Proxy< PT, RT > &lhs, const T &rhs) |
Equality comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator== (const T &lhs, const Proxy< PT, RT > &rhs) |
Equality comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator!= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Inequality comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator!= (const Proxy< PT, RT > &lhs, const T &rhs) |
Inequality comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator!= (const T &lhs, const Proxy< PT, RT > &rhs) |
Inquality comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator< (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Less-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator< (const Proxy< PT, RT > &lhs, const T &rhs) |
Less-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator< (const T &lhs, const Proxy< PT, RT > &rhs) |
Less-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator> (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Greater-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator> (const Proxy< PT, RT > &lhs, const T &rhs) |
Greater-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator> (const T &lhs, const Proxy< PT, RT > &rhs) |
Greater-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator<= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Less-or-equal-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator<= (const Proxy< PT, RT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator<= (const T &lhs, const Proxy< PT, RT > &rhs) |
Less-or-equal-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator>= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Greater-or-equal-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator>= (const Proxy< PT, RT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT > | |
DisableIf_< IsProxy< T >, bool > | blaze::operator>= (const T &lhs, const Proxy< PT, RT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT , typename RT > | |
std::ostream & | blaze::operator<< (std::ostream &os, const Proxy< PT, RT > &proxy) |
Global output operator for the Proxy class template. More... | |
Proxy global functions | |
template<typename PT , typename RT > | |
auto | blaze::trans (const Proxy< PT, RT > &proxy) -> decltype(trans(std::declval< RepresentedType_< PT > >())) |
Computing the transpose of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::ctrans (const Proxy< PT, RT > &proxy) -> decltype(ctrans(std::declval< RepresentedType_< PT > >())) |
Computing the conjugate transpose of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::abs (const Proxy< PT, RT > &proxy) -> decltype(abs(std::declval< RepresentedType_< PT > >())) |
Computing the absolute value of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::conj (const Proxy< PT, RT > &proxy) -> decltype(conj(std::declval< RepresentedType_< PT > >())) |
Computing the complex conjugate of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::real (const Proxy< PT, RT > &proxy) -> decltype(real(std::declval< RepresentedType_< PT > >())) |
Computing the real part of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::imag (const Proxy< PT, RT > &proxy) -> decltype(imag(std::declval< RepresentedType_< PT > >())) |
Computing the imaginary part of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::sqrt (const Proxy< PT, RT > &proxy) -> decltype(sqrt(std::declval< RepresentedType_< PT > >())) |
Computing the square root of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::invsqrt (const Proxy< PT, RT > &proxy) -> decltype(invsqrt(std::declval< RepresentedType_< PT > >())) |
Computing the inverse square root of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::cbrt (const Proxy< PT, RT > &proxy) -> decltype(cbrt(std::declval< RepresentedType_< PT > >())) |
Computing the cubic root of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::invcbrt (const Proxy< PT, RT > &proxy) -> decltype(invcbrt(std::declval< RepresentedType_< PT > >())) |
Computing the inverse cubic root of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::floor (const Proxy< PT, RT > &proxy) -> decltype(floor(std::declval< RepresentedType_< PT > >())) |
Computes the largest integral value that is not greater than the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::ceil (const Proxy< PT, RT > &proxy) -> decltype(ceil(std::declval< RepresentedType_< PT > >())) |
Computes the smallest integral value that is not less than the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
auto | blaze::pow (const Proxy< PT, RT > &proxy, const ET &exp) -> decltype(pow(std::declval< RepresentedType_< PT > >(), exp)) |
Computing the exponential value of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::exp (const Proxy< PT, RT > &proxy) -> decltype(exp(std::declval< RepresentedType_< PT > >())) |
Computing the base-e exponential of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::sin (const Proxy< PT, RT > &proxy) -> decltype(sin(std::declval< RepresentedType_< PT > >())) |
Computing the sine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::asin (const Proxy< PT, RT > &proxy) -> decltype(asin(std::declval< RepresentedType_< PT > >())) |
Computing the inverse sine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::sinh (const Proxy< PT, RT > &proxy) -> decltype(sinh(std::declval< RepresentedType_< PT > >())) |
Computing the hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::asinh (const Proxy< PT, RT > &proxy) -> decltype(asinh(std::declval< RepresentedType_< PT > >())) |
Computing the inverse hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::cos (const Proxy< PT, RT > &proxy) -> decltype(cos(std::declval< RepresentedType_< PT > >())) |
Computing the cosine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::acos (const Proxy< PT, RT > &proxy) -> decltype(acos(std::declval< RepresentedType_< PT > >())) |
Computing the inverse cosine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::cosh (const Proxy< PT, RT > &proxy) -> decltype(cosh(std::declval< RepresentedType_< PT > >())) |
Computing the hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::acosh (const Proxy< PT, RT > &proxy) -> decltype(acosh(std::declval< RepresentedType_< PT > >())) |
Computing the inverse hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::tan (const Proxy< PT, RT > &proxy) -> decltype(tan(std::declval< RepresentedType_< PT > >())) |
Computing the tangent of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::atan (const Proxy< PT, RT > &proxy) -> decltype(atan(std::declval< RepresentedType_< PT > >())) |
Computing the inverse tangent of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::tanh (const Proxy< PT, RT > &proxy) -> decltype(tanh(std::declval< RepresentedType_< PT > >())) |
Computing the hyperbolic tangent of the represented element. More... | |
template<typename PT , typename RT > | |
auto | blaze::atanh (const Proxy< PT, RT > &proxy) -> decltype(atanh(std::declval< RepresentedType_< PT > >())) |
Computing the inverse hyperbolic tangent of the represented element. More... | |
template<typename PT , typename RT > | |
void | blaze::transpose (const Proxy< PT, RT > &proxy) |
In-place transpose of the represented matrix element. More... | |
template<typename PT , typename RT > | |
void | blaze::ctranspose (const Proxy< PT, RT > &proxy) |
In-place conjugate transpose of the represented matrix element. More... | |
template<typename PT , typename RT > | |
void | blaze::invert (const Proxy< PT, RT > &proxy) |
In-place inversion of the represented element. More... | |
template<InversionFlag IF, typename PT , typename RT > | |
void | blaze::invert (const Proxy< PT, RT > &proxy) |
In-place inversion of the represented element. More... | |
template<typename PT , typename RT > | |
bool | blaze::isReal (const Proxy< PT, RT > &proxy) |
Returns whether the element represents a real number. More... | |
template<typename PT , typename RT > | |
bool | blaze::isZero (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 0. More... | |
template<typename PT , typename RT > | |
bool | blaze::isOne (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename PT , typename RT > | |
bool | blaze::isnan (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is not a number. More... | |
Header file for the Proxy class.
Copyright (C) 2013 Klaus Iglberger - All Rights Reserved
This file is part of the Blaze library. You can redistribute it and/or modify it under the terms of the New (Revised) BSD License. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.