Proxy.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_PROXY_PROXY_H_
36 #define _BLAZE_MATH_PROXY_PROXY_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
44 #include <blaze/math/Exception.h>
52 #include <blaze/math/shims/Abs.h>
53 #include <blaze/math/shims/Acos.h>
54 #include <blaze/math/shims/Acosh.h>
55 #include <blaze/math/shims/Asin.h>
56 #include <blaze/math/shims/Asinh.h>
57 #include <blaze/math/shims/Atan.h>
58 #include <blaze/math/shims/Atanh.h>
59 #include <blaze/math/shims/Cbrt.h>
60 #include <blaze/math/shims/Ceil.h>
62 #include <blaze/math/shims/Cos.h>
63 #include <blaze/math/shims/Cosh.h>
64 #include <blaze/math/shims/Erf.h>
65 #include <blaze/math/shims/Erfc.h>
66 #include <blaze/math/shims/Exp.h>
67 #include <blaze/math/shims/Floor.h>
72 #include <blaze/math/shims/IsNaN.h>
73 #include <blaze/math/shims/IsOne.h>
76 #include <blaze/math/shims/Pow.h>
77 #include <blaze/math/shims/Real.h>
78 #include <blaze/math/shims/Sin.h>
79 #include <blaze/math/shims/Sinh.h>
80 #include <blaze/math/shims/Sqrt.h>
81 #include <blaze/math/shims/Tan.h>
82 #include <blaze/math/shims/Tanh.h>
92 #include <blaze/util/DisableIf.h>
93 #include <blaze/util/mpl/If.h>
95 
96 
97 namespace blaze {
98 
99 //=================================================================================================
100 //
101 // CLASS DEFINITION
102 //
103 //=================================================================================================
104 
105 //*************************************************************************************************
137 template< typename PT // Type of the proxy
138  , typename RT = int > // Type of the represented element
139 class Proxy : public If_< IsVector<RT>
140  , If_< IsDenseVector<RT>
141  , DenseVectorProxy<PT,RT>
142  , SparseVectorProxy<PT,RT> >
143  , If_< IsMatrix<RT>
144  , If_< IsDenseMatrix<RT>
145  , DenseMatrixProxy<PT,RT>
146  , SparseMatrixProxy<PT,RT> >
147  , If_< IsComplex<RT>
148  , ComplexProxy<PT,RT>
149  , DefaultProxy<PT,RT> > > >
150 {};
151 //*************************************************************************************************
152 
153 
154 
155 
156 //=================================================================================================
157 //
158 // GLOBAL OPERATORS
159 //
160 //=================================================================================================
161 
162 //*************************************************************************************************
165 template< typename PT1, typename RT1, typename PT2, typename RT2 >
166 inline AddExprTrait_<RT1,RT2>
167  operator+( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
168 
169 template< typename PT, typename RT, typename T >
170 inline DisableIf_< IsProxy<T>, AddExprTrait_<RT,T> >
171  operator+( const Proxy<PT,RT>& lhs, const T& rhs );
172 
173 template< typename T, typename PT, typename RT >
174 inline DisableIf_< IsProxy<T>, AddExprTrait_<T,RT> >
175  operator+( const T& lhs, const Proxy<PT,RT>& rhs );
176 
177 template< typename PT1, typename RT1, typename PT2, typename RT2 >
178 inline SubExprTrait_<RT1,RT2>
179  operator-( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
180 
181 template< typename PT, typename RT, typename T >
182 inline DisableIf_< IsProxy<T>, SubExprTrait_<RT,T> >
183  operator-( const Proxy<PT,RT>& lhs, const T& rhs );
184 
185 template< typename T, typename PT, typename RT >
186 inline DisableIf_< IsProxy<T>, SubExprTrait_<T,RT> >
187  operator-( const T& lhs, const Proxy<PT,RT>& rhs );
188 
189 template< typename PT1, typename RT1, typename PT2, typename RT2 >
190 inline MultExprTrait_<RT1,RT2>
191  operator*( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
192 
193 template< typename PT, typename RT, typename T >
194 inline DisableIf_< IsProxy<T>, MultExprTrait_<RT,T> >
195  operator*( const Proxy<PT,RT>& lhs, const T& rhs );
196 
197 template< typename T, typename PT, typename RT >
198 inline DisableIf_< IsProxy<T>, MultExprTrait_<T,RT> >
199  operator*( const T& lhs, const Proxy<PT,RT>& rhs );
200 
201 template< typename PT1, typename RT1, typename PT2, typename RT2 >
202 inline DivExprTrait_<RT1,RT2>
203  operator/( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
204 
205 template< typename PT, typename RT, typename T >
206 inline DisableIf_< IsProxy<T>, DivExprTrait_<RT,T> >
207  operator/( const Proxy<PT,RT>& lhs, const T& rhs );
208 
209 template< typename T, typename PT, typename RT >
210 inline DisableIf_< IsProxy<T>, DivExprTrait_<T,RT> >
211  operator/( const T& lhs, const Proxy<PT,RT>& rhs );
212 
213 template< typename PT1, typename RT1, typename PT2, typename RT2 >
214 inline bool operator==( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
215 
216 template< typename PT, typename RT, typename T >
217 inline DisableIf_< IsProxy<T>, bool >
218  operator==( const Proxy<PT,RT>& lhs, const T& rhs );
219 
220 template< typename T, typename PT, typename RT >
221 inline DisableIf_< IsProxy<T>, bool >
222  operator==( const T& lhs, const Proxy<PT,RT>& rhs );
223 
224 template< typename PT1, typename RT1, typename PT2, typename RT2 >
225 inline bool operator!=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
226 
227 template< typename PT, typename RT, typename T >
228 inline DisableIf_< IsProxy<T>, bool >
229  operator!=( const Proxy<PT,RT>& lhs, const T& rhs );
230 
231 template< typename T, typename PT, typename RT >
232 inline DisableIf_< IsProxy<T>, bool >
233  operator!=( const T& lhs, const Proxy<PT,RT>& rhs );
234 
235 template< typename PT1, typename RT1, typename PT2, typename RT2 >
236 inline bool operator<( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
237 
238 template< typename PT, typename RT, typename T >
239 inline DisableIf_< IsProxy<T>, bool >
240  operator<( const Proxy<PT,RT>& lhs, const T& rhs );
241 
242 template< typename T, typename PT, typename RT >
243 inline DisableIf_< IsProxy<T>, bool >
244  operator<( const T& lhs, const Proxy<PT,RT>& rhs );
245 
246 template< typename PT1, typename RT1, typename PT2, typename RT2 >
247 inline bool operator>( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
248 
249 template< typename PT, typename RT, typename T >
250 inline DisableIf_< IsProxy<T>, bool >
251  operator>( const Proxy<PT,RT>& lhs, const T& rhs );
252 
253 template< typename T, typename PT, typename RT >
254 inline DisableIf_< IsProxy<T>, bool >
255  operator>( const T& lhs, const Proxy<PT,RT>& rhs );
256 
257 template< typename PT1, typename RT1, typename PT2, typename RT2 >
258 inline bool operator<=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
259 
260 template< typename PT, typename RT, typename T >
261 inline DisableIf_< IsProxy<T>, bool >
262  operator<=( const Proxy<PT,RT>& lhs, const T& rhs );
263 
264 template< typename T, typename PT, typename RT >
265 inline DisableIf_< IsProxy<T>, bool >
266  operator<=( const T& lhs, const Proxy<PT,RT>& rhs );
267 
268 template< typename PT1, typename RT1, typename PT2, typename RT2 >
269 inline bool operator>=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
270 
271 template< typename PT, typename RT, typename T >
272 inline DisableIf_< IsProxy<T>, bool >
273  operator>=( const Proxy<PT,RT>& lhs, const T& rhs );
274 
275 template< typename T, typename PT, typename RT >
276 inline DisableIf_< IsProxy<T>, bool >
277  operator>=( const T& lhs, const Proxy<PT,RT>& rhs );
278 
279 template< typename PT, typename RT >
280 inline std::ostream& operator<<( std::ostream& os, const Proxy<PT,RT>& proxy );
282 //*************************************************************************************************
283 
284 
285 //*************************************************************************************************
293 template< typename PT1, typename RT1, typename PT2, typename RT2 >
294 inline AddExprTrait_<RT1,RT2>
295  operator+( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
296 {
297  return (~lhs).get() + (~rhs).get();
298 }
299 //*************************************************************************************************
300 
301 
302 //*************************************************************************************************
310 template< typename PT, typename RT, typename T >
311 inline DisableIf_< IsProxy<T>, AddExprTrait_<RT,T> >
312  operator+( const Proxy<PT,RT>& lhs, const T& rhs )
313 {
314  return (~lhs).get() + rhs;
315 }
316 //*************************************************************************************************
317 
318 
319 //*************************************************************************************************
327 template< typename T, typename PT, typename RT >
328 inline DisableIf_< IsProxy<T>, AddExprTrait_<T,RT> >
329  operator+( const T& lhs, const Proxy<PT,RT>& rhs )
330 {
331  return lhs + (~rhs).get();
332 }
333 //*************************************************************************************************
334 
335 
336 //*************************************************************************************************
344 template< typename PT1, typename RT1, typename PT2, typename RT2 >
345 inline SubExprTrait_<RT1,RT2>
346  operator-( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
347 {
348  return (~lhs).get() - (~rhs).get();
349 }
350 //*************************************************************************************************
351 
352 
353 //*************************************************************************************************
361 template< typename PT, typename RT, typename T >
362 inline DisableIf_< IsProxy<T>, SubExprTrait_<RT,T> >
363  operator-( const Proxy<PT,RT>& lhs, const T& rhs )
364 {
365  return (~lhs).get() - rhs;
366 }
367 //*************************************************************************************************
368 
369 
370 //*************************************************************************************************
378 template< typename T, typename PT, typename RT >
379 inline DisableIf_< IsProxy<T>, SubExprTrait_<T,RT> >
380  operator-( const T& lhs, const Proxy<PT,RT>& rhs )
381 {
382  return lhs - (~rhs).get();
383 }
384 //*************************************************************************************************
385 
386 
387 //*************************************************************************************************
395 template< typename PT1, typename RT1, typename PT2, typename RT2 >
396 inline MultExprTrait_<RT1,RT2>
397  operator*( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
398 {
399  return (~lhs).get() * (~rhs).get();
400 }
401 //*************************************************************************************************
402 
403 
404 //*************************************************************************************************
412 template< typename PT, typename RT, typename T >
413 inline DisableIf_< IsProxy<T>, MultExprTrait_<RT,T> >
414  operator*( const Proxy<PT,RT>& lhs, const T& rhs )
415 {
416  return (~lhs).get() * rhs;
417 }
418 //*************************************************************************************************
419 
420 
421 //*************************************************************************************************
429 template< typename T, typename PT, typename RT >
430 inline DisableIf_< IsProxy<T>, MultExprTrait_<T,RT> >
431  operator*( const T& lhs, const Proxy<PT,RT>& rhs )
432 {
433  return lhs * (~rhs).get();
434 }
435 //*************************************************************************************************
436 
437 
438 //*************************************************************************************************
446 template< typename PT1, typename RT1, typename PT2, typename RT2 >
447 inline DivExprTrait_<RT1,RT2>
448  operator/( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
449 {
450  return (~lhs).get() / (~rhs).get();
451 }
452 //*************************************************************************************************
453 
454 
455 //*************************************************************************************************
463 template< typename PT, typename RT, typename T >
464 inline DisableIf_< IsProxy<T>, DivExprTrait_<RT,T> >
465  operator/( const Proxy<PT,RT>& lhs, const T& rhs )
466 {
467  return (~lhs).get() / rhs;
468 }
469 //*************************************************************************************************
470 
471 
472 //*************************************************************************************************
480 template< typename T, typename PT, typename RT >
481 inline DisableIf_< IsProxy<T>, DivExprTrait_<T,RT> >
482  operator/( const T& lhs, const Proxy<PT,RT>& rhs )
483 {
484  return lhs / (~rhs).get();
485 }
486 //*************************************************************************************************
487 
488 
489 //*************************************************************************************************
497 template< typename PT1, typename RT1, typename PT2, typename RT2 >
498 inline bool operator==( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
499 {
500  return ( (~lhs).get() == (~rhs).get() );
501 }
502 //*************************************************************************************************
503 
504 
505 //*************************************************************************************************
513 template< typename PT, typename RT, typename T >
514 inline DisableIf_< IsProxy<T>, bool >
515  operator==( const Proxy<PT,RT>& lhs, const T& rhs )
516 {
517  return ( (~lhs).get() == rhs );
518 }
519 //*************************************************************************************************
520 
521 
522 //*************************************************************************************************
530 template< typename T, typename PT, typename RT >
531 inline DisableIf_< IsProxy<T>, bool >
532  operator==( const T& lhs, const Proxy<PT,RT>& rhs )
533 {
534  return ( lhs == (~rhs).get() );
535 }
536 //*************************************************************************************************
537 
538 
539 //*************************************************************************************************
547 template< typename PT1, typename RT1, typename PT2, typename RT2 >
548 inline bool operator!=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
549 {
550  return ( (~lhs).get() != (~rhs).get() );
551 }
552 //*************************************************************************************************
553 
554 
555 //*************************************************************************************************
563 template< typename PT, typename RT, typename T >
564 inline DisableIf_< IsProxy<T>, bool >
565  operator!=( const Proxy<PT,RT>& lhs, const T& rhs )
566 {
567  return ( (~lhs).get() != rhs );
568 }
569 //*************************************************************************************************
570 
571 
572 //*************************************************************************************************
580 template< typename T, typename PT, typename RT >
581 inline DisableIf_< IsProxy<T>, bool >
582  operator!=( const T& lhs, const Proxy<PT,RT>& rhs )
583 {
584  return ( lhs != (~rhs).get() );
585 }
586 //*************************************************************************************************
587 
588 
589 //*************************************************************************************************
597 template< typename PT1, typename RT1, typename PT2, typename RT2 >
598 inline bool operator<( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
599 {
600  return ( (~lhs).get() < (~rhs).get() );
601 }
602 //*************************************************************************************************
603 
604 
605 //*************************************************************************************************
613 template< typename PT, typename RT, typename T >
614 inline DisableIf_< IsProxy<T>, bool >
615  operator<( const Proxy<PT,RT>& lhs, const T& rhs )
616 {
617  return ( (~lhs).get() < rhs );
618 }
619 //*************************************************************************************************
620 
621 
622 //*************************************************************************************************
630 template< typename T, typename PT, typename RT >
631 inline DisableIf_< IsProxy<T>, bool >
632  operator<( const T& lhs, const Proxy<PT,RT>& rhs )
633 {
634  return ( lhs < rhs.get() );
635 }
636 //*************************************************************************************************
637 
638 
639 //*************************************************************************************************
647 template< typename PT1, typename RT1, typename PT2, typename RT2 >
648 inline bool operator>( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
649 {
650  return ( (~lhs).get() > (~rhs).get() );
651 }
652 //*************************************************************************************************
653 
654 
655 //*************************************************************************************************
663 template< typename PT, typename RT, typename T >
664 inline DisableIf_< IsProxy<T>, bool >
665  operator>( const Proxy<PT,RT>& lhs, const T& rhs )
666 {
667  return ( (~lhs).get() > rhs );
668 }
669 //*************************************************************************************************
670 
671 
672 //*************************************************************************************************
680 template< typename T, typename PT, typename RT >
681 inline DisableIf_< IsProxy<T>, bool >
682  operator>( const T& lhs, const Proxy<PT,RT>& rhs )
683 {
684  return ( lhs > (~rhs).get() );
685 }
686 //*************************************************************************************************
687 
688 
689 //*************************************************************************************************
697 template< typename PT1, typename RT1, typename PT2, typename RT2 >
698 inline bool operator<=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
699 {
700  return ( (~lhs).get() <= (~rhs).get() );
701 }
702 //*************************************************************************************************
703 
704 
705 //*************************************************************************************************
713 template< typename PT, typename RT, typename T >
714 inline DisableIf_< IsProxy<T>, bool >
715  operator<=( const Proxy<PT,RT>& lhs, const T& rhs )
716 {
717  return ( (~lhs).get() <= rhs );
718 }
719 //*************************************************************************************************
720 
721 
722 //*************************************************************************************************
730 template< typename T, typename PT, typename RT >
731 inline DisableIf_< IsProxy<T>, bool >
732  operator<=( const T& lhs, const Proxy<PT,RT>& rhs )
733 {
734  return ( lhs <= (~rhs).get() );
735 }
736 //*************************************************************************************************
737 
738 
739 //*************************************************************************************************
747 template< typename PT1, typename RT1, typename PT2, typename RT2 >
748 inline bool operator>=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
749 {
750  return ( (~lhs).get() >= (~rhs).get() );
751 }
752 //*************************************************************************************************
753 
754 
755 //*************************************************************************************************
763 template< typename PT, typename RT, typename T >
764 inline DisableIf_< IsProxy<T>, bool >
765  operator>=( const Proxy<PT,RT>& lhs, const T& rhs )
766 {
767  return ( (~lhs).get() >= rhs );
768 }
769 //*************************************************************************************************
770 
771 
772 //*************************************************************************************************
780 template< typename T, typename PT, typename RT >
781 inline DisableIf_< IsProxy<T>, bool >
782  operator>=( const T& lhs, const Proxy<PT,RT>& rhs )
783 {
784  return ( lhs >= (~rhs).get() );
785 }
786 //*************************************************************************************************
787 
788 
789 //*************************************************************************************************
797 template< typename PT, typename RT >
798 inline std::ostream& operator<<( std::ostream& os, const Proxy<PT,RT>& proxy )
799 {
800  return os << (~proxy).get();
801 }
802 //*************************************************************************************************
803 
804 
805 
806 
807 //=================================================================================================
808 //
809 // GLOBAL FUNCTIONS
810 //
811 //=================================================================================================
812 
813 //*************************************************************************************************
816 template< typename PT, typename RT >
817 inline auto trans( const Proxy<PT,RT>& proxy )
818  -> decltype( trans( std::declval< RepresentedType_<PT> >() ) );
819 
820 template< typename PT, typename RT >
821 inline auto ctrans( const Proxy<PT,RT>& proxy )
822  -> decltype( ctrans( std::declval< RepresentedType_<PT> >() ) );
823 
824 template< typename PT, typename RT >
825 inline auto abs( const Proxy<PT,RT>& proxy )
826  -> decltype( abs( std::declval< RepresentedType_<PT> >() ) );
827 
828 template< typename PT, typename RT >
829 inline auto conj( const Proxy<PT,RT>& proxy )
830  -> decltype( conj( std::declval< RepresentedType_<PT> >() ) );
831 
832 template< typename PT, typename RT >
833 inline auto real( const Proxy<PT,RT>& proxy )
834  -> decltype( real( std::declval< RepresentedType_<PT> >() ) );
835 
836 template< typename PT, typename RT >
837 inline auto imag( const Proxy<PT,RT>& proxy )
838  -> decltype( imag( std::declval< RepresentedType_<PT> >() ) );
839 
840 template< typename PT, typename RT >
841 inline auto sqrt( const Proxy<PT,RT>& proxy )
842  -> decltype( sqrt( std::declval< RepresentedType_<PT> >() ) );
843 
844 template< typename PT, typename RT >
845 inline auto invsqrt( const Proxy<PT,RT>& proxy )
846  -> decltype( invsqrt( std::declval< RepresentedType_<PT> >() ) );
847 
848 template< typename PT, typename RT >
849 inline auto cbrt( const Proxy<PT,RT>& proxy )
850  -> decltype( cbrt( std::declval< RepresentedType_<PT> >() ) );
851 
852 template< typename PT, typename RT >
853 inline auto invcbrt( const Proxy<PT,RT>& proxy )
854  -> decltype( invcbrt( std::declval< RepresentedType_<PT> >() ) );
855 
856 template< typename PT, typename RT >
857 inline auto floor( const Proxy<PT,RT>& proxy )
858  -> decltype( floor( std::declval< RepresentedType_<PT> >() ) );
859 
860 template< typename PT, typename RT >
861 inline auto ceil( const Proxy<PT,RT>& proxy )
862  -> decltype( ceil( std::declval< RepresentedType_<PT> >() ) );
863 
864 template< typename PT, typename RT, typename ET >
865 inline auto pow( const Proxy<PT,RT>& proxy, const ET& exp )
866  -> decltype( pow( std::declval< RepresentedType_<PT> >(), exp ) );
867 
868 template< typename PT, typename RT >
869 inline auto exp( const Proxy<PT,RT>& proxy )
870  -> decltype( exp( std::declval< RepresentedType_<PT> >() ) );
871 
872 template< typename PT, typename RT >
873 inline auto sin( const Proxy<PT,RT>& proxy )
874  -> decltype( sin( std::declval< RepresentedType_<PT> >() ) );
875 
876 template< typename PT, typename RT >
877 inline auto asin( const Proxy<PT,RT>& proxy )
878  -> decltype( asin( std::declval< RepresentedType_<PT> >() ) );
879 
880 template< typename PT, typename RT >
881 inline auto sinh( const Proxy<PT,RT>& proxy )
882  -> decltype( sinh( std::declval< RepresentedType_<PT> >() ) );
883 
884 template< typename PT, typename RT >
885 inline auto asinh( const Proxy<PT,RT>& proxy )
886  -> decltype( asinh( std::declval< RepresentedType_<PT> >() ) );
887 
888 template< typename PT, typename RT >
889 inline auto cos( const Proxy<PT,RT>& proxy )
890  -> decltype( cos( std::declval< RepresentedType_<PT> >() ) );
891 
892 template< typename PT, typename RT >
893 inline auto acos( const Proxy<PT,RT>& proxy )
894  -> decltype( acos( std::declval< RepresentedType_<PT> >() ) );
895 
896 template< typename PT, typename RT >
897 inline auto cosh( const Proxy<PT,RT>& proxy )
898  -> decltype( cosh( std::declval< RepresentedType_<PT> >() ) );
899 
900 template< typename PT, typename RT >
901 inline auto acosh( const Proxy<PT,RT>& proxy )
902  -> decltype( acosh( std::declval< RepresentedType_<PT> >() ) );
903 
904 template< typename PT, typename RT >
905 inline auto tan( const Proxy<PT,RT>& proxy )
906  -> decltype( tan( std::declval< RepresentedType_<PT> >() ) );
907 
908 template< typename PT, typename RT >
909 inline auto atan( const Proxy<PT,RT>& proxy )
910  -> decltype( atan( std::declval< RepresentedType_<PT> >() ) );
911 
912 template< typename PT, typename RT >
913 inline auto tanh( const Proxy<PT,RT>& proxy )
914  -> decltype( tanh( std::declval< RepresentedType_<PT> >() ) );
915 
916 template< typename PT, typename RT >
917 inline auto atanh( const Proxy<PT,RT>& proxy )
918  -> decltype( atanh( std::declval< RepresentedType_<PT> >() ) );
919 
920 template< typename PT, typename RT >
921 inline void transpose( const Proxy<PT,RT>& proxy );
922 
923 template< typename PT, typename RT >
924 inline void ctranspose( const Proxy<PT,RT>& proxy );
925 
926 template< typename PT, typename RT >
927 inline void invert( const Proxy<PT,RT>& proxy );
928 
929 template< InversionFlag IF, typename PT, typename RT >
930 inline void invert( const Proxy<PT,RT>& proxy );
931 
932 template< typename PT, typename RT >
933 inline bool isReal( const Proxy<PT,RT>& proxy );
934 
935 template< typename PT, typename RT >
936 inline bool isZero( const Proxy<PT,RT>& proxy );
937 
938 template< typename PT, typename RT >
939 inline bool isOne( const Proxy<PT,RT>& proxy );
940 
941 template< typename PT, typename RT >
942 inline bool isnan( const Proxy<PT,RT>& proxy );
944 //*************************************************************************************************
945 
946 
947 //*************************************************************************************************
957 template< typename PT, typename RT >
958 inline auto trans( const Proxy<PT,RT>& proxy )
959  -> decltype( trans( std::declval< RepresentedType_<PT> >() ) )
960 {
961  using blaze::trans;
962 
963  return trans( (~proxy).get() );
964 }
965 //*************************************************************************************************
966 
967 
968 //*************************************************************************************************
978 template< typename PT, typename RT >
979 inline auto ctrans( const Proxy<PT,RT>& proxy )
980  -> decltype( ctrans( std::declval< RepresentedType_<PT> >() ) )
981 {
982  using blaze::ctrans;
983 
984  return ctrans( (~proxy).get() );
985 }
986 //*************************************************************************************************
987 
988 
989 //*************************************************************************************************
1000 template< typename PT, typename RT >
1001 inline auto abs( const Proxy<PT,RT>& proxy )
1002  -> decltype( abs( std::declval< RepresentedType_<PT> >() ) )
1003 {
1004  using blaze::abs;
1005 
1006  return abs( (~proxy).get() );
1007 }
1008 //*************************************************************************************************
1009 
1010 
1011 //*************************************************************************************************
1022 template< typename PT, typename RT >
1023 inline auto conj( const Proxy<PT,RT>& proxy )
1024  -> decltype( conj( std::declval< RepresentedType_<PT> >() ) )
1025 {
1026  using blaze::conj;
1027 
1028  return conj( (~proxy).get() );
1029 }
1030 //*************************************************************************************************
1031 
1032 
1033 //*************************************************************************************************
1044 template< typename PT, typename RT >
1045 inline auto real( const Proxy<PT,RT>& proxy )
1046  -> decltype( real( std::declval< RepresentedType_<PT> >() ) )
1047 {
1048  using blaze::real;
1049 
1050  return real( (~proxy).get() );
1051 }
1052 //*************************************************************************************************
1053 
1054 
1055 //*************************************************************************************************
1066 template< typename PT, typename RT >
1067 inline auto imag( const Proxy<PT,RT>& proxy )
1068  -> decltype( imag( std::declval< RepresentedType_<PT> >() ) )
1069 {
1070  using blaze::imag;
1071 
1072  return imag( (~proxy).get() );
1073 }
1074 //*************************************************************************************************
1075 
1076 
1077 //*************************************************************************************************
1088 template< typename PT, typename RT >
1089 inline auto sqrt( const Proxy<PT,RT>& proxy )
1090  -> decltype( sqrt( std::declval< RepresentedType_<PT> >() ) )
1091 {
1092  using blaze::sqrt;
1093 
1094  return sqrt( (~proxy).get() );
1095 }
1096 //*************************************************************************************************
1097 
1098 
1099 //*************************************************************************************************
1110 template< typename PT, typename RT >
1111 inline auto invsqrt( const Proxy<PT,RT>& proxy )
1112  -> decltype( invsqrt( std::declval< RepresentedType_<PT> >() ) )
1113 {
1114  using blaze::invsqrt;
1115 
1116  return invsqrt( (~proxy).get() );
1117 }
1118 //*************************************************************************************************
1119 
1120 
1121 //*************************************************************************************************
1132 template< typename PT, typename RT >
1133 inline auto cbrt( const Proxy<PT,RT>& proxy )
1134  -> decltype( cbrt( std::declval< RepresentedType_<PT> >() ) )
1135 {
1136  using blaze::cbrt;
1137 
1138  return cbrt( (~proxy).get() );
1139 }
1140 //*************************************************************************************************
1141 
1142 
1143 //*************************************************************************************************
1154 template< typename PT, typename RT >
1155 inline auto invcbrt( const Proxy<PT,RT>& proxy )
1156  -> decltype( invcbrt( std::declval< RepresentedType_<PT> >() ) )
1157 {
1158  using blaze::invcbrt;
1159 
1160  return invcbrt( (~proxy).get() );
1161 }
1162 //*************************************************************************************************
1163 
1164 
1165 //*************************************************************************************************
1176 template< typename PT, typename RT >
1177 inline auto floor( const Proxy<PT,RT>& proxy )
1178  -> decltype( floor( std::declval< RepresentedType_<PT> >() ) )
1179 {
1180  using blaze::floor;
1181 
1182  return floor( (~proxy).get() );
1183 }
1184 //*************************************************************************************************
1185 
1186 
1187 //*************************************************************************************************
1198 template< typename PT, typename RT >
1199 inline auto ceil( const Proxy<PT,RT>& proxy )
1200  -> decltype( ceil( std::declval< RepresentedType_<PT> >() ) )
1201 {
1202  using blaze::ceil;
1203 
1204  return ceil( (~proxy).get() );
1205 }
1206 //*************************************************************************************************
1207 
1208 
1209 //*************************************************************************************************
1221 template< typename PT, typename RT, typename ET >
1222 inline auto pow( const Proxy<PT,RT>& proxy, const ET& exp )
1223  -> decltype( pow( std::declval< RepresentedType_<PT> >(), exp ) )
1224 {
1225  using blaze::pow;
1226 
1227  return pow( (~proxy).get(), exp );
1228 }
1229 //*************************************************************************************************
1230 
1231 
1232 //*************************************************************************************************
1243 template< typename PT, typename RT >
1244 inline auto exp( const Proxy<PT,RT>& proxy )
1245  -> decltype( exp( std::declval< RepresentedType_<PT> >() ) )
1246 {
1247  using blaze::exp;
1248 
1249  return exp( (~proxy).get() );
1250 }
1251 //*************************************************************************************************
1252 
1253 
1254 //*************************************************************************************************
1265 template< typename PT, typename RT >
1266 inline auto sin( const Proxy<PT,RT>& proxy )
1267  -> decltype( sin( std::declval< RepresentedType_<PT> >() ) )
1268 {
1269  using blaze::sin;
1270 
1271  return sin( (~proxy).get() );
1272 }
1273 //*************************************************************************************************
1274 
1275 
1276 //*************************************************************************************************
1287 template< typename PT, typename RT >
1288 inline auto asin( const Proxy<PT,RT>& proxy )
1289  -> decltype( asin( std::declval< RepresentedType_<PT> >() ) )
1290 {
1291  using blaze::asin;
1292 
1293  return asin( (~proxy).get() );
1294 }
1295 //*************************************************************************************************
1296 
1297 
1298 //*************************************************************************************************
1309 template< typename PT, typename RT >
1310 inline auto sinh( const Proxy<PT,RT>& proxy )
1311  -> decltype( sinh( std::declval< RepresentedType_<PT> >() ) )
1312 {
1313  using blaze::sinh;
1314 
1315  return sinh( (~proxy).get() );
1316 }
1317 //*************************************************************************************************
1318 
1319 
1320 //*************************************************************************************************
1331 template< typename PT, typename RT >
1332 inline auto asinh( const Proxy<PT,RT>& proxy )
1333  -> decltype( asinh( std::declval< RepresentedType_<PT> >() ) )
1334 {
1335  using blaze::asinh;
1336 
1337  return asinh( (~proxy).get() );
1338 }
1339 //*************************************************************************************************
1340 
1341 
1342 //*************************************************************************************************
1353 template< typename PT, typename RT >
1354 inline auto cos( const Proxy<PT,RT>& proxy )
1355  -> decltype( cos( std::declval< RepresentedType_<PT> >() ) )
1356 {
1357  using blaze::cos;
1358 
1359  return cos( (~proxy).get() );
1360 }
1361 //*************************************************************************************************
1362 
1363 
1364 //*************************************************************************************************
1375 template< typename PT, typename RT >
1376 inline auto acos( const Proxy<PT,RT>& proxy )
1377  -> decltype( acos( std::declval< RepresentedType_<PT> >() ) )
1378 {
1379  using blaze::acos;
1380 
1381  return acos( (~proxy).get() );
1382 }
1383 //*************************************************************************************************
1384 
1385 
1386 //*************************************************************************************************
1397 template< typename PT, typename RT >
1398 inline auto cosh( const Proxy<PT,RT>& proxy )
1399  -> decltype( cosh( std::declval< RepresentedType_<PT> >() ) )
1400 {
1401  using blaze::cosh;
1402 
1403  return cosh( (~proxy).get() );
1404 }
1405 //*************************************************************************************************
1406 
1407 
1408 //*************************************************************************************************
1419 template< typename PT, typename RT >
1420 inline auto acosh( const Proxy<PT,RT>& proxy )
1421  -> decltype( acosh( std::declval< RepresentedType_<PT> >() ) )
1422 {
1423  using blaze::acosh;
1424 
1425  return acosh( (~proxy).get() );
1426 }
1427 //*************************************************************************************************
1428 
1429 
1430 //*************************************************************************************************
1441 template< typename PT, typename RT >
1442 inline auto tan( const Proxy<PT,RT>& proxy )
1443  -> decltype( tan( std::declval< RepresentedType_<PT> >() ) )
1444 {
1445  using blaze::tan;
1446 
1447  return tan( (~proxy).get() );
1448 }
1449 //*************************************************************************************************
1450 
1451 
1452 //*************************************************************************************************
1463 template< typename PT, typename RT >
1464 inline auto atan( const Proxy<PT,RT>& proxy )
1465  -> decltype( atan( std::declval< RepresentedType_<PT> >() ) )
1466 {
1467  using blaze::atan;
1468 
1469  return atan( (~proxy).get() );
1470 }
1471 //*************************************************************************************************
1472 
1473 
1474 //*************************************************************************************************
1485 template< typename PT, typename RT >
1486 inline auto tanh( const Proxy<PT,RT>& proxy )
1487  -> decltype( tanh( std::declval< RepresentedType_<PT> >() ) )
1488 {
1489  using blaze::tanh;
1490 
1491  return tanh( (~proxy).get() );
1492 }
1493 //*************************************************************************************************
1494 
1495 
1496 //*************************************************************************************************
1507 template< typename PT, typename RT >
1508 inline auto atanh( const Proxy<PT,RT>& proxy )
1509  -> decltype( atanh( std::declval< RepresentedType_<PT> >() ) )
1510 {
1511  using blaze::atanh;
1512 
1513  return atanh( (~proxy).get() );
1514 }
1515 //*************************************************************************************************
1516 
1517 
1518 //*************************************************************************************************
1529 template< typename PT, typename RT >
1530 inline auto erf( const Proxy<PT,RT>& proxy )
1531  -> decltype( erf( std::declval< RepresentedType_<PT> >() ) )
1532 {
1533  using blaze::erf;
1534 
1535  return erf( (~proxy).get() );
1536 }
1537 //*************************************************************************************************
1538 
1539 
1540 //*************************************************************************************************
1552 template< typename PT, typename RT >
1553 inline auto erfc( const Proxy<PT,RT>& proxy )
1554  -> decltype( erfc( std::declval< RepresentedType_<PT> >() ) )
1555 {
1556  using blaze::erfc;
1557 
1558  return erfc( (~proxy).get() );
1559 }
1560 //*************************************************************************************************
1561 
1562 
1563 //*************************************************************************************************
1580 template< typename PT, typename RT >
1581 inline void transpose( const Proxy<PT,RT>& proxy )
1582 {
1583  if( (~proxy).isRestricted() ) {
1584  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
1585  }
1586 
1587  transpose( (~proxy).get() );
1588 }
1589 //*************************************************************************************************
1590 
1591 
1592 //*************************************************************************************************
1609 template< typename PT, typename RT >
1610 inline void ctranspose( const Proxy<PT,RT>& proxy )
1611 {
1612  if( (~proxy).isRestricted() ) {
1613  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
1614  }
1615 
1616  ctranspose( (~proxy).get() );
1617 }
1618 //*************************************************************************************************
1619 
1620 
1621 //*************************************************************************************************
1649 template< typename PT, typename RT >
1650 inline void invert( const Proxy<PT,RT>& proxy )
1651 {
1652  if( (~proxy).isRestricted() ) {
1653  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
1654  }
1655 
1656  invert( (~proxy).get() );
1657 }
1658 //*************************************************************************************************
1659 
1660 
1661 //*************************************************************************************************
1698 template< InversionFlag IF, typename PT, typename RT >
1699 inline void invert( const Proxy<PT,RT>& proxy )
1700 {
1701  if( (~proxy).isRestricted() ) {
1702  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
1703  }
1704 
1705  invert<IF>( (~proxy).get() );
1706 }
1707 //*************************************************************************************************
1708 
1709 
1710 //*************************************************************************************************
1722 template< typename PT, typename RT >
1723 inline bool isReal( const Proxy<PT,RT>& proxy )
1724 {
1725  using blaze::isReal;
1726 
1727  return isReal( (~proxy).get() );
1728 }
1729 //*************************************************************************************************
1730 
1731 
1732 //*************************************************************************************************
1742 template< typename PT, typename RT >
1743 inline bool isZero( const Proxy<PT,RT>& proxy )
1744 {
1745  using blaze::isZero;
1746 
1747  return isZero( (~proxy).get() );
1748 }
1749 //*************************************************************************************************
1750 
1751 
1752 //*************************************************************************************************
1762 template< typename PT, typename RT >
1763 inline bool isOne( const Proxy<PT,RT>& proxy )
1764 {
1765  using blaze::isOne;
1766 
1767  return isOne( (~proxy).get() );
1768 }
1769 //*************************************************************************************************
1770 
1771 
1772 //*************************************************************************************************
1782 template< typename PT, typename RT >
1783 inline bool isnan( const Proxy<PT,RT>& proxy )
1784 {
1785  using blaze::isnan;
1786 
1787  return isnan( (~proxy).get() );
1788 }
1789 //*************************************************************************************************
1790 
1791 } // namespace blaze
1792 
1793 #endif
Header file for the isnan shim.
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
bool isOne(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is 1.
Definition: DiagonalProxy.h:635
const DMatForEachExpr< MT, Conj, SO > conj(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the complex conjugate of each single element of dm.
Definition: DMatForEachExpr.h:1158
Header file for auxiliary alias declarations.
const DMatForEachExpr< MT, Sin, SO > sin(const DenseMatrix< MT, SO > &dm)
Computes the sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1557
Header file for the acos shim.
Header file for the asin shim.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:7800
Header file for the cosh shim.
Header file for the SparseVectorProxy class.
Header file for the imaginary shim.
Proxy base class.The Proxy class is a base class for all proxy classes within the Blaze library that ...
Definition: Forward.h:51
bool isReal(const DiagonalProxy< MT > &proxy)
Returns whether the matrix element represents a real number.
Definition: DiagonalProxy.h:595
const DMatForEachExpr< MT, Tanh, SO > tanh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic tangent for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1849
const CTransExprTrait_< MT > ctrans(const DenseMatrix< MT, SO > &dm)
Returns the conjugate transpose matrix of dm.
Definition: DMatForEachExpr.h:1195
Header file for the tan shim.
Header file for the dense matrix inversion flags.
Header file for the DefaultProxy class.
const DMatForEachExpr< MT, Cos, SO > cos(const DenseMatrix< MT, SO > &dm)
Computes the cosine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1672
const DMatForEachExpr< MT, Atan, SO > atan(const DenseMatrix< MT, SO > &dm)
Computes the inverse tangent for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1818
const DMatForEachExpr< MT, Imag, SO > imag(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the imaginary part of each single element of dm.
Definition: DMatForEachExpr.h:1251
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:699
Header file for the DenseMatrixProxy class.
bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:366
BLAZE_ALWAYS_INLINE void ctranspose(Matrix< MT, SO > &matrix)
In-place conjugate transpose of the given matrix.
Definition: Matrix.h:590
Header file for the abs shim.
Header file for the AddExprTrait class template.
bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:442
Header file for the pow shim.
Header file for the invert shim.
const DMatForEachExpr< MT, Sinh, SO > sinh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1616
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:731
Header file for the DenseVectorProxy class.
const DMatForEachExpr< MT, Exp, SO > exp(const DenseMatrix< MT, SO > &dm)
Computes for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1467
Header file for the IsMatrix type trait.
Header file for the DivExprTrait class template.
Header file for the MultExprTrait class template.
void invert(const HermitianProxy< MT > &proxy)
In-place inversion of the represented element.
Definition: HermitianProxy.h:741
Header file for the sqrt shim.
const DMatForEachExpr< MT, Acosh, SO > acosh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic cosine for each single element of the dense matrix dm...
Definition: DMatForEachExpr.h:1762
const EnableIf_< IsNumeric< T2 >, DivExprTrait_< T1, T2 > > operator/(const DenseMatrix< T1, SO > &mat, T2 scalar)
Division operator for the division of a dense matrix by a scalar value ( ).
Definition: DMatScalarDivExpr.h:966
Header file for the DisableIf class template.
Header file for the floor shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the cos shim.
Header file for the If class template.
const DMatForEachExpr< MT, Abs, SO > abs(const DenseMatrix< MT, SO > &dm)
Applies the abs() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1074
Header file for the ComplexProxy class.
Header file for the erf shim.
Header file for the isZero shim.
const DMatForEachExpr< MT, InvCbrt, SO > invcbrt(const DenseMatrix< MT, SO > &dm)
Computes the inverse cubic root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1375
const DMatForEachExpr< MT, Floor, SO > floor(const DenseMatrix< MT, SO > &dm)
Applies the floor() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1102
Header file for the sin shim.
Header file for the invsqrt shim.
const DMatForEachExpr< MT, Erf, SO > erf(const DenseMatrix< MT, SO > &dm)
Computes the error function for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1908
const DMatForEachExpr< MT, Tan, SO > tan(const DenseMatrix< MT, SO > &dm)
Computes the tangent for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1790
bool isnan(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is not a number.
Definition: DiagonalProxy.h:655
const DMatForEachExpr< MT, Pow< ET >, SO > pow(const DenseMatrix< MT, SO > &dm, ET exp)
Computes the exponential value for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1437
Header file for the SparseMatrixProxy class.
Header file for the exception macros of the math module.
Header file for the erfc shim.
Header file for the IsVector type trait.
Header file for the IsDenseMatrix type trait.
const DMatForEachExpr< MT, Cosh, SO > cosh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic cosine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1731
const DMatForEachExpr< MT, Sqrt, SO > sqrt(const DenseMatrix< MT, SO > &dm)
Computes the square root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1282
const DMatForEachExpr< MT, Real, SO > real(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the real part of each single element of dm.
Definition: DMatForEachExpr.h:1223
const DMatForEachExpr< MT, Atanh, SO > atanh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic tangent for each single element of the dense matrix dm...
Definition: DMatForEachExpr.h:1880
Header file for the isOne shim.
const DMatForEachExpr< MT, Acos, SO > acos(const DenseMatrix< MT, SO > &dm)
Computes the inverse cosine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1703
Header file for the conjugate shim.
const DMatForEachExpr< MT, InvSqrt, SO > invsqrt(const DenseMatrix< MT, SO > &dm)
Computes the inverse square root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1313
const DMatForEachExpr< MT, Cbrt, SO > cbrt(const DenseMatrix< MT, SO > &dm)
Computes the cubic root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1344
Header file for the acosh shim.
Header file for the cbrt shim.
const DMatForEachExpr< MT, Asin, SO > asin(const DenseMatrix< MT, SO > &dm)
Computes the inverse sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1588
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
Header file for the atanh shim.
Header file for the invcbrt shim.
Header file for the IsProxy type trait.
typename T::RepresentedType RepresentedType_
Alias declaration for nested RepresentedType type definitions.The RepresentedType_ alias declaration ...
Definition: Aliases.h:303
Header file for the asinh shim.
Header file for the tanh shim.
Header file for the IsDenseVector type trait.
const DMatForEachExpr< MT, Erfc, SO > erfc(const DenseMatrix< MT, SO > &dm)
Computes the complementary error function for each single element of the dense matrix dm...
Definition: DMatForEachExpr.h:1936
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:950
bool isZero(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is 0.
Definition: DiagonalProxy.h:615
const DMatForEachExpr< MT, Asinh, SO > asinh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1644
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
Header file for the IsComplex type trait.
Header file for the exp shim.
Header file for the real shim.
Header file for the sinh shim.
Header file for the SubExprTrait class template.
Header file for the isReal shim.
Header file for the atan shim.
const DMatForEachExpr< MT, Ceil, SO > ceil(const DenseMatrix< MT, SO > &dm)
Applies the ceil() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1130
Header file for the ceil shim.
BLAZE_ALWAYS_INLINE void transpose(Matrix< MT, SO > &matrix)
In-place transpose of the given matrix.
Definition: Matrix.h:564