Blaze 3.9
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 <iosfwd>
44#include <blaze/math/Aliases.h>
100#include <blaze/math/shims/Tan.h>
110#include <blaze/util/EnableIf.h>
111#include <blaze/util/mpl/If.h>
113
114
115namespace blaze {
116
117//=================================================================================================
118//
119// CLASS DEFINITION
120//
121//=================================================================================================
122
123//*************************************************************************************************
155template< typename PT // Type of the proxy
156 , typename RT = int > // Type of the represented element
157class Proxy
158 : public If_t< IsVector_v<RT>
159 , If_t< IsDenseVector_v<RT>
160 , DenseVectorProxy<PT,RT>
161 , SparseVectorProxy<PT,RT> >
162 , If_t< IsMatrix_v<RT>
163 , If_t< IsDenseMatrix_v<RT>
164 , DenseMatrixProxy<PT,RT>
165 , SparseMatrixProxy<PT,RT> >
166 , If_t< IsComplex_v<RT>
167 , ComplexProxy<PT,RT>
168 , DefaultProxy<PT,RT> > > >
169{
170 protected:
171 //**Special member functions********************************************************************
174 Proxy() = default;
175 Proxy( const Proxy& ) = default;
176 Proxy( Proxy&& ) = default;
177 ~Proxy() = default;
178 Proxy& operator=( const Proxy& ) = default;
179 Proxy& operator=( Proxy&& ) = default;
181 //**********************************************************************************************
182};
183//*************************************************************************************************
184
185
186
187
188//=================================================================================================
189//
190// GLOBAL OPERATORS
191//
192//=================================================================================================
193
194//*************************************************************************************************
197template< typename T, typename PT, typename RT >
198decltype(auto) operator+=( T& lhs, const Proxy<PT,RT>& rhs );
199
200template< typename T, typename PT, typename RT >
201decltype(auto) operator-=( T& lhs, const Proxy<PT,RT>& rhs );
202
203template< typename T, typename PT, typename RT >
204decltype(auto) operator/=( T& lhs, const Proxy<PT,RT>& rhs );
205
206template< typename T, typename PT, typename RT >
207decltype(auto) operator*=( T& lhs, const Proxy<PT,RT>& rhs );
208
209template< typename PT1, typename RT1, typename PT2, typename RT2 >
210decltype(auto) operator+( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
211
212template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
213decltype(auto) operator+( const Proxy<PT,RT>& lhs, const T& rhs );
214
215template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
216decltype(auto) operator+( const T& lhs, const Proxy<PT,RT>& rhs );
217
218template< typename PT1, typename RT1, typename PT2, typename RT2 >
219decltype(auto) operator-( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
220
221template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
222decltype(auto) operator-( const Proxy<PT,RT>& lhs, const T& rhs );
223
224template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
225decltype(auto) operator-( const T& lhs, const Proxy<PT,RT>& rhs );
226
227template< typename PT1, typename RT1, typename PT2, typename RT2 >
228decltype(auto) operator*( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
229
230template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
231decltype(auto) operator*( const Proxy<PT,RT>& lhs, const T& rhs );
232
233template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
234decltype(auto) operator*( const T& lhs, const Proxy<PT,RT>& rhs );
235
236template< typename PT1, typename RT1, typename PT2, typename RT2 >
237decltype(auto) operator/( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
238
239template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
240decltype(auto) operator/( const Proxy<PT,RT>& lhs, const T& rhs );
241
242template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
243decltype(auto) operator/( const T& lhs, const Proxy<PT,RT>& rhs );
244
245template< typename PT1, typename RT1, typename PT2, typename RT2 >
246bool operator==( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
247
248template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
249bool operator==( const Proxy<PT,RT>& lhs, const T& rhs );
250
251template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
252bool operator==( const T& lhs, const Proxy<PT,RT>& rhs );
253
254template< typename PT1, typename RT1, typename PT2, typename RT2 >
255bool operator!=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
256
257template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
258bool operator!=( const Proxy<PT,RT>& lhs, const T& rhs );
259
260template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
261bool operator!=( const T& lhs, const Proxy<PT,RT>& rhs );
262
263template< typename PT1, typename RT1, typename PT2, typename RT2 >
264bool operator<( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
265
266template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
267bool operator<( const Proxy<PT,RT>& lhs, const T& rhs );
268
269template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
270bool operator<( const T& lhs, const Proxy<PT,RT>& rhs );
271
272template< typename PT1, typename RT1, typename PT2, typename RT2 >
273bool operator>( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
274
275template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
276bool operator>( const Proxy<PT,RT>& lhs, const T& rhs );
277
278template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
279bool operator>( const T& lhs, const Proxy<PT,RT>& rhs );
280
281template< typename PT1, typename RT1, typename PT2, typename RT2 >
282bool operator<=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
283
284template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
285bool operator<=( const Proxy<PT,RT>& lhs, const T& rhs );
286
287template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
288bool operator<=( const T& lhs, const Proxy<PT,RT>& rhs );
289
290template< typename PT1, typename RT1, typename PT2, typename RT2 >
291bool operator>=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
292
293template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
294bool operator>=( const Proxy<PT,RT>& lhs, const T& rhs );
295
296template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
297bool operator>=( const T& lhs, const Proxy<PT,RT>& rhs );
298
299template< typename PT, typename RT >
300std::ostream& operator<<( std::ostream& os, const Proxy<PT,RT>& proxy );
302//*************************************************************************************************
303
304
305//*************************************************************************************************
313template< typename T, typename PT, typename RT >
314inline decltype(auto) operator+=( T& lhs, const Proxy<PT,RT>& rhs )
315{
316 return lhs += (*rhs).get();
317}
318//*************************************************************************************************
319
320
321//*************************************************************************************************
329template< typename T, typename PT, typename RT >
330inline decltype(auto) operator-=( T& lhs, const Proxy<PT,RT>& rhs )
331{
332 return lhs -= (*rhs).get();
333}
334//*************************************************************************************************
335
336
337//*************************************************************************************************
345template< typename T, typename PT, typename RT >
346inline decltype(auto) operator*=( T& lhs, const Proxy<PT,RT>& rhs )
347{
348 return lhs *= (*rhs).get();
349}
350//*************************************************************************************************
351
352
353//*************************************************************************************************
361template< typename T, typename PT, typename RT >
362inline decltype(auto) operator/=( T& lhs, const Proxy<PT,RT>& rhs )
363{
364 return lhs /= (*rhs).get();
365}
366//*************************************************************************************************
367
368
369//*************************************************************************************************
377template< typename PT1, typename RT1, typename PT2, typename RT2 >
378inline decltype(auto) operator+( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
379{
380 return (*lhs).get() + (*rhs).get();
381}
382//*************************************************************************************************
383
384
385//*************************************************************************************************
393template< typename PT, typename RT, typename T, typename >
394inline decltype(auto) operator+( const Proxy<PT,RT>& lhs, const T& rhs )
395{
396 return (*lhs).get() + rhs;
397}
398//*************************************************************************************************
399
400
401//*************************************************************************************************
409template< typename T, typename PT, typename RT, typename >
410inline decltype(auto) operator+( const T& lhs, const Proxy<PT,RT>& rhs )
411{
412 return lhs + (*rhs).get();
413}
414//*************************************************************************************************
415
416
417//*************************************************************************************************
425template< typename PT1, typename RT1, typename PT2, typename RT2 >
426inline decltype(auto) operator-( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
427{
428 return (*lhs).get() - (*rhs).get();
429}
430//*************************************************************************************************
431
432
433//*************************************************************************************************
441template< typename PT, typename RT, typename T, typename >
442inline decltype(auto) operator-( const Proxy<PT,RT>& lhs, const T& rhs )
443{
444 return (*lhs).get() - rhs;
445}
446//*************************************************************************************************
447
448
449//*************************************************************************************************
457template< typename T, typename PT, typename RT, typename >
458inline decltype(auto) operator-( const T& lhs, const Proxy<PT,RT>& rhs )
459{
460 return lhs - (*rhs).get();
461}
462//*************************************************************************************************
463
464
465//*************************************************************************************************
473template< typename PT1, typename RT1, typename PT2, typename RT2 >
474inline decltype(auto) operator*( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
475{
476 return (*lhs).get() * (*rhs).get();
477}
478//*************************************************************************************************
479
480
481//*************************************************************************************************
489template< typename PT, typename RT, typename T, typename >
490inline decltype(auto) operator*( const Proxy<PT,RT>& lhs, const T& rhs )
491{
492 return (*lhs).get() * rhs;
493}
494//*************************************************************************************************
495
496
497//*************************************************************************************************
505template< typename T, typename PT, typename RT, typename >
506inline decltype(auto) operator*( const T& lhs, const Proxy<PT,RT>& rhs )
507{
508 return lhs * (*rhs).get();
509}
510//*************************************************************************************************
511
512
513//*************************************************************************************************
521template< typename PT1, typename RT1, typename PT2, typename RT2 >
522inline decltype(auto) operator/( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
523{
524 return (*lhs).get() / (*rhs).get();
525}
526//*************************************************************************************************
527
528
529//*************************************************************************************************
537template< typename PT, typename RT, typename T, typename >
538inline decltype(auto) operator/( const Proxy<PT,RT>& lhs, const T& rhs )
539{
540 return (*lhs).get() / rhs;
541}
542//*************************************************************************************************
543
544
545//*************************************************************************************************
553template< typename T, typename PT, typename RT, typename >
554inline decltype(auto) operator/( const T& lhs, const Proxy<PT,RT>& rhs )
555{
556 return lhs / (*rhs).get();
557}
558//*************************************************************************************************
559
560
561//*************************************************************************************************
569template< typename PT1, typename RT1, typename PT2, typename RT2 >
570inline bool operator==( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
571{
572 return ( (*lhs).get() == (*rhs).get() );
573}
574//*************************************************************************************************
575
576
577//*************************************************************************************************
585template< typename PT, typename RT, typename T, typename >
586inline bool operator==( const Proxy<PT,RT>& lhs, const T& rhs )
587{
588 return ( (*lhs).get() == rhs );
589}
590//*************************************************************************************************
591
592
593//*************************************************************************************************
601template< typename T, typename PT, typename RT, typename >
602inline bool operator==( const T& lhs, const Proxy<PT,RT>& rhs )
603{
604 return ( lhs == (*rhs).get() );
605}
606//*************************************************************************************************
607
608
609//*************************************************************************************************
617template< typename PT1, typename RT1, typename PT2, typename RT2 >
618inline bool operator!=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
619{
620 return ( (*lhs).get() != (*rhs).get() );
621}
622//*************************************************************************************************
623
624
625//*************************************************************************************************
633template< typename PT, typename RT, typename T, typename >
634inline bool operator!=( const Proxy<PT,RT>& lhs, const T& rhs )
635{
636 return ( (*lhs).get() != rhs );
637}
638//*************************************************************************************************
639
640
641//*************************************************************************************************
649template< typename T, typename PT, typename RT, typename >
650inline bool operator!=( const T& lhs, const Proxy<PT,RT>& rhs )
651{
652 return ( lhs != (*rhs).get() );
653}
654//*************************************************************************************************
655
656
657//*************************************************************************************************
665template< typename PT1, typename RT1, typename PT2, typename RT2 >
666inline bool operator<( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
667{
668 return ( (*lhs).get() < (*rhs).get() );
669}
670//*************************************************************************************************
671
672
673//*************************************************************************************************
681template< typename PT, typename RT, typename T, typename >
682inline bool operator<( const Proxy<PT,RT>& lhs, const T& rhs )
683{
684 return ( (*lhs).get() < rhs );
685}
686//*************************************************************************************************
687
688
689//*************************************************************************************************
697template< typename T, typename PT, typename RT, typename >
698inline bool operator<( const T& lhs, const Proxy<PT,RT>& rhs )
699{
700 return ( lhs < rhs.get() );
701}
702//*************************************************************************************************
703
704
705//*************************************************************************************************
713template< typename PT1, typename RT1, typename PT2, typename RT2 >
714inline bool operator>( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
715{
716 return ( (*lhs).get() > (*rhs).get() );
717}
718//*************************************************************************************************
719
720
721//*************************************************************************************************
729template< typename PT, typename RT, typename T, typename >
730inline bool operator>( const Proxy<PT,RT>& lhs, const T& rhs )
731{
732 return ( (*lhs).get() > rhs );
733}
734//*************************************************************************************************
735
736
737//*************************************************************************************************
745template< typename T, typename PT, typename RT, typename >
746inline bool operator>( const T& lhs, const Proxy<PT,RT>& rhs )
747{
748 return ( lhs > (*rhs).get() );
749}
750//*************************************************************************************************
751
752
753//*************************************************************************************************
761template< typename PT1, typename RT1, typename PT2, typename RT2 >
762inline bool operator<=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
763{
764 return ( (*lhs).get() <= (*rhs).get() );
765}
766//*************************************************************************************************
767
768
769//*************************************************************************************************
777template< typename PT, typename RT, typename T, typename >
778inline bool operator<=( const Proxy<PT,RT>& lhs, const T& rhs )
779{
780 return ( (*lhs).get() <= rhs );
781}
782//*************************************************************************************************
783
784
785//*************************************************************************************************
793template< typename T, typename PT, typename RT, typename >
794inline bool operator<=( const T& lhs, const Proxy<PT,RT>& rhs )
795{
796 return ( lhs <= (*rhs).get() );
797}
798//*************************************************************************************************
799
800
801//*************************************************************************************************
809template< typename PT1, typename RT1, typename PT2, typename RT2 >
810inline bool operator>=( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
811{
812 return ( (*lhs).get() >= (*rhs).get() );
813}
814//*************************************************************************************************
815
816
817//*************************************************************************************************
825template< typename PT, typename RT, typename T, typename >
826inline bool operator>=( const Proxy<PT,RT>& lhs, const T& rhs )
827{
828 return ( (*lhs).get() >= rhs );
829}
830//*************************************************************************************************
831
832
833//*************************************************************************************************
841template< typename T, typename PT, typename RT, typename >
842inline bool operator>=( const T& lhs, const Proxy<PT,RT>& rhs )
843{
844 return ( lhs >= (*rhs).get() );
845}
846//*************************************************************************************************
847
848
849//*************************************************************************************************
857template< typename PT, typename RT >
858inline std::ostream& operator<<( std::ostream& os, const Proxy<PT,RT>& proxy )
859{
860 return os << (*proxy).get();
861}
862//*************************************************************************************************
863
864
865
866
867//=================================================================================================
868//
869// GLOBAL FUNCTIONS
870//
871//=================================================================================================
872
873//*************************************************************************************************
876template< typename PT, typename RT >
877decltype(auto) abs( const Proxy<PT,RT>& proxy );
878
879template< typename PT, typename RT >
880decltype(auto) sign( const Proxy<PT,RT>& proxy );
881
882template< typename PT, typename RT >
883decltype(auto) floor( const Proxy<PT,RT>& proxy );
884
885template< typename PT, typename RT >
886decltype(auto) ceil( const Proxy<PT,RT>& proxy );
887
888template< typename PT, typename RT >
889decltype(auto) trunc( const Proxy<PT,RT>& proxy );
890
891template< typename PT, typename RT >
892decltype(auto) round( const Proxy<PT,RT>& proxy );
893
894template< typename PT, typename RT >
895decltype(auto) conj( const Proxy<PT,RT>& proxy );
896
897template< typename PT, typename RT >
898decltype(auto) trans( const Proxy<PT,RT>& proxy );
899
900template< typename PT, typename RT >
901decltype(auto) ctrans( const Proxy<PT,RT>& proxy );
902
903template< typename PT, typename RT >
904decltype(auto) real( const Proxy<PT,RT>& proxy );
905
906template< typename PT, typename RT >
907decltype(auto) imag( const Proxy<PT,RT>& proxy );
908
909template< typename PT, typename RT >
910decltype(auto) sqrt( const Proxy<PT,RT>& proxy );
911
912template< typename PT, typename RT >
913decltype(auto) invsqrt( const Proxy<PT,RT>& proxy );
914
915template< typename PT, typename RT >
916decltype(auto) cbrt( const Proxy<PT,RT>& proxy );
917
918template< typename PT, typename RT >
919decltype(auto) invcbrt( const Proxy<PT,RT>& proxy );
920
921template< typename PT1, typename RT1, typename PT2, typename RT2 >
922decltype(auto) hypot( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
923
924template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
925decltype(auto) hypot( const Proxy<PT,RT>& lhs, const T& rhs );
926
927template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
928decltype(auto) hypot( const T& lhs, const Proxy<PT,RT>& rhs );
929
930template< typename PT, typename RT, typename ET >
931decltype(auto) pow( const Proxy<PT,RT>& proxy, const ET& exp );
932
933template< typename PT, typename RT >
934decltype(auto) pow2( const Proxy<PT,RT>& proxy );
935
936template< typename PT, typename RT >
937decltype(auto) pow3( const Proxy<PT,RT>& proxy );
938
939template< typename PT, typename RT >
940decltype(auto) pow4( const Proxy<PT,RT>& proxy );
941
942template< typename PT, typename RT >
943decltype(auto) exp( const Proxy<PT,RT>& proxy );
944
945template< typename PT, typename RT >
946decltype(auto) exp2( const Proxy<PT,RT>& proxy );
947
948template< typename PT, typename RT >
949decltype(auto) exp10( const Proxy<PT,RT>& proxy );
950
951template< typename PT, typename RT >
952decltype(auto) log( const Proxy<PT,RT>& proxy );
953
954template< typename PT, typename RT >
955decltype(auto) log2( const Proxy<PT,RT>& proxy );
956
957template< typename PT, typename RT >
958decltype(auto) log10( const Proxy<PT,RT>& proxy );
959
960template< typename PT, typename RT >
961decltype(auto) sin( const Proxy<PT,RT>& proxy );
962
963template< typename PT, typename RT >
964decltype(auto) asin( const Proxy<PT,RT>& proxy );
965
966template< typename PT, typename RT >
967decltype(auto) sinh( const Proxy<PT,RT>& proxy );
968
969template< typename PT, typename RT >
970decltype(auto) asinh( const Proxy<PT,RT>& proxy );
971
972template< typename PT, typename RT >
973decltype(auto) cos( const Proxy<PT,RT>& proxy );
974
975template< typename PT, typename RT >
976decltype(auto) acos( const Proxy<PT,RT>& proxy );
977
978template< typename PT, typename RT >
979decltype(auto) cosh( const Proxy<PT,RT>& proxy );
980
981template< typename PT, typename RT >
982decltype(auto) acosh( const Proxy<PT,RT>& proxy );
983
984template< typename PT, typename RT >
985decltype(auto) tan( const Proxy<PT,RT>& proxy );
986
987template< typename PT, typename RT >
988decltype(auto) atan( const Proxy<PT,RT>& proxy );
989
990template< typename PT, typename RT >
991decltype(auto) tanh( const Proxy<PT,RT>& proxy );
992
993template< typename PT, typename RT >
994decltype(auto) atanh( const Proxy<PT,RT>& proxy );
995
996template< typename PT1, typename RT1, typename PT2, typename RT2 >
997decltype(auto) atan2( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
998
999template< typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
1000decltype(auto) atan2( const Proxy<PT,RT>& lhs, const T& rhs );
1001
1002template< typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
1003decltype(auto) atan2( const T& lhs, const Proxy<PT,RT>& rhs );
1004
1005template< typename PT, typename RT >
1006decltype(auto) erf( const Proxy<PT,RT>& proxy );
1007
1008template< typename PT, typename RT >
1009decltype(auto) erfc( const Proxy<PT,RT>& proxy );
1010
1011template< typename PT, typename RT >
1012void reset( const Proxy<PT,RT>& proxy );
1013
1014template< typename PT, typename RT >
1015void reset( const Proxy<PT,RT>& proxy, size_t i );
1016
1017template< typename PT, typename RT >
1018void transpose( const Proxy<PT,RT>& proxy );
1019
1020template< typename PT, typename RT >
1021void ctranspose( const Proxy<PT,RT>& proxy );
1022
1023template< typename PT, typename RT >
1024void invert( const Proxy<PT,RT>& proxy );
1025
1026template< InversionFlag IF, typename PT, typename RT >
1027void invert( const Proxy<PT,RT>& proxy );
1028
1029template< RelaxationFlag RF, typename PT, typename RT >
1030bool isDefault( const Proxy<PT,RT>& proxy );
1031
1032template< RelaxationFlag RF, typename PT, typename RT >
1033bool isReal( const Proxy<PT,RT>& proxy );
1034
1035template< RelaxationFlag RF, typename PT, typename RT >
1036bool isZero( const Proxy<PT,RT>& proxy );
1037
1038template< RelaxationFlag RF, typename PT, typename RT >
1039bool isOne( const Proxy<PT,RT>& proxy );
1040
1041template< typename PT, typename RT >
1042bool isnan( const Proxy<PT,RT>& proxy );
1043
1044template< typename PT, typename RT >
1045bool isinf( const Proxy<PT,RT>& proxy );
1046
1047template< typename PT, typename RT >
1048bool isfinite( const Proxy<PT,RT>& proxy );
1049
1050template< RelaxationFlag RF, typename PT1, typename RT1, typename PT2, typename RT2 >
1051bool equal( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs );
1052
1053template< RelaxationFlag RF, typename PT, typename RT, typename T, typename = DisableIf_t< IsProxy_v<T> > >
1054bool equal( const Proxy<PT,RT>& lhs, const T& rhs );
1055
1056template< RelaxationFlag RF, typename T, typename PT, typename RT, typename = DisableIf_t< IsProxy_v<T> > >
1057bool equal( const T& lhs, const Proxy<PT,RT>& rhs );
1058
1059template< typename PT, typename RT >
1060decltype(auto) evaluate( const Proxy<PT,RT>& proxy );
1062//*************************************************************************************************
1063
1064
1065//*************************************************************************************************
1076template< typename PT, typename RT >
1077inline decltype(auto) abs( const Proxy<PT,RT>& proxy )
1078{
1079 using blaze::abs;
1080
1081 return abs( (*proxy).get() );
1082}
1083//*************************************************************************************************
1084
1085
1086//*************************************************************************************************
1097template< typename PT, typename RT >
1098inline decltype(auto) sign( const Proxy<PT,RT>& proxy )
1099{
1100 using blaze::sign;
1101
1102 return sign( (*proxy).get() );
1103}
1104//*************************************************************************************************
1105
1106
1107//*************************************************************************************************
1118template< typename PT, typename RT >
1119inline decltype(auto) floor( const Proxy<PT,RT>& proxy )
1120{
1121 using blaze::floor;
1122
1123 return floor( (*proxy).get() );
1124}
1125//*************************************************************************************************
1126
1127
1128//*************************************************************************************************
1139template< typename PT, typename RT >
1140inline decltype(auto) ceil( const Proxy<PT,RT>& proxy )
1141{
1142 using blaze::ceil;
1143
1144 return ceil( (*proxy).get() );
1145}
1146//*************************************************************************************************
1147
1148
1149//*************************************************************************************************
1160template< typename PT, typename RT >
1161inline decltype(auto) trunc( const Proxy<PT,RT>& proxy )
1162{
1163 using blaze::trunc;
1164
1165 return trunc( (*proxy).get() );
1166}
1167//*************************************************************************************************
1168
1169
1170//*************************************************************************************************
1181template< typename PT, typename RT >
1182inline decltype(auto) round( const Proxy<PT,RT>& proxy )
1183{
1184 using blaze::round;
1185
1186 return round( (*proxy).get() );
1187}
1188//*************************************************************************************************
1189
1190
1191//*************************************************************************************************
1202template< typename PT, typename RT >
1203inline decltype(auto) conj( const Proxy<PT,RT>& proxy )
1204{
1205 using blaze::conj;
1206
1207 return conj( (*proxy).get() );
1208}
1209//*************************************************************************************************
1210
1211
1212//*************************************************************************************************
1222template< typename PT, typename RT >
1223inline decltype(auto) trans( const Proxy<PT,RT>& proxy )
1224{
1225 using blaze::trans;
1226
1227 return trans( (*proxy).get() );
1228}
1229//*************************************************************************************************
1230
1231
1232//*************************************************************************************************
1242template< typename PT, typename RT >
1243inline decltype(auto) ctrans( const Proxy<PT,RT>& proxy )
1244{
1245 using blaze::ctrans;
1246
1247 return ctrans( (*proxy).get() );
1248}
1249//*************************************************************************************************
1250
1251
1252//*************************************************************************************************
1263template< typename PT, typename RT >
1264inline decltype(auto) real( const Proxy<PT,RT>& proxy )
1265{
1266 using blaze::real;
1267
1268 return real( (*proxy).get() );
1269}
1270//*************************************************************************************************
1271
1272
1273//*************************************************************************************************
1284template< typename PT, typename RT >
1285inline decltype(auto) imag( const Proxy<PT,RT>& proxy )
1286{
1287 using blaze::imag;
1288
1289 return imag( (*proxy).get() );
1290}
1291//*************************************************************************************************
1292
1293
1294//*************************************************************************************************
1305template< typename PT, typename RT >
1306inline decltype(auto) sqrt( const Proxy<PT,RT>& proxy )
1307{
1308 using blaze::sqrt;
1309
1310 return sqrt( (*proxy).get() );
1311}
1312//*************************************************************************************************
1313
1314
1315//*************************************************************************************************
1326template< typename PT, typename RT >
1327inline decltype(auto) invsqrt( const Proxy<PT,RT>& proxy )
1328{
1329 using blaze::invsqrt;
1330
1331 return invsqrt( (*proxy).get() );
1332}
1333//*************************************************************************************************
1334
1335
1336//*************************************************************************************************
1347template< typename PT, typename RT >
1348inline decltype(auto) cbrt( const Proxy<PT,RT>& proxy )
1349{
1350 using blaze::cbrt;
1351
1352 return cbrt( (*proxy).get() );
1353}
1354//*************************************************************************************************
1355
1356
1357//*************************************************************************************************
1368template< typename PT, typename RT >
1369inline decltype(auto) invcbrt( const Proxy<PT,RT>& proxy )
1370{
1371 using blaze::invcbrt;
1372
1373 return invcbrt( (*proxy).get() );
1374}
1375//*************************************************************************************************
1376
1377
1378//*************************************************************************************************
1390template< typename PT1, typename RT1, typename PT2, typename RT2 >
1391inline decltype(auto) hypot( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
1392{
1393 using blaze::hypot;
1394
1395 return hypot( (*lhs).get(), (*rhs).get() );
1396}
1397//*************************************************************************************************
1398
1399
1400//*************************************************************************************************
1413template< typename PT, typename RT, typename T, typename >
1414inline decltype(auto) hypot( const Proxy<PT,RT>& lhs, const T& rhs )
1415{
1416 using blaze::hypot;
1417
1418 return hypot( (*lhs).get(), rhs );
1419}
1420//*************************************************************************************************
1421
1422
1423//*************************************************************************************************
1436template< typename T, typename PT, typename RT, typename >
1437inline decltype(auto) hypot( const T& lhs, const Proxy<PT,RT>& rhs )
1438{
1439 using blaze::hypot;
1440
1441 return hypot( lhs, (*rhs).get() );
1442}
1443//*************************************************************************************************
1444
1445
1446//*************************************************************************************************
1458template< typename PT, typename RT, typename ET >
1459inline decltype(auto) pow( const Proxy<PT,RT>& proxy, const ET& exp )
1460{
1461 using blaze::pow;
1462
1463 return pow( (*proxy).get(), exp );
1464}
1465//*************************************************************************************************
1466
1467
1468//*************************************************************************************************
1479template< typename PT, typename RT, typename ET >
1480inline decltype(auto) pow2( const Proxy<PT,RT>& proxy )
1481{
1482 using blaze::pow2;
1483
1484 return pow2( (*proxy).get() );
1485}
1486//*************************************************************************************************
1487
1488
1489//*************************************************************************************************
1500template< typename PT, typename RT, typename ET >
1501inline decltype(auto) pow3( const Proxy<PT,RT>& proxy )
1502{
1503 using blaze::pow3;
1504
1505 return pow3( (*proxy).get() );
1506}
1507//*************************************************************************************************
1508
1509
1510//*************************************************************************************************
1521template< typename PT, typename RT, typename ET >
1522inline decltype(auto) pow4( const Proxy<PT,RT>& proxy )
1523{
1524 using blaze::pow4;
1525
1526 return pow4( (*proxy).get() );
1527}
1528//*************************************************************************************************
1529
1530
1531//*************************************************************************************************
1542template< typename PT, typename RT >
1543inline decltype(auto) exp( const Proxy<PT,RT>& proxy )
1544{
1545 using blaze::exp;
1546
1547 return exp( (*proxy).get() );
1548}
1549//*************************************************************************************************
1550
1551
1552//*************************************************************************************************
1563template< typename PT, typename RT >
1564inline decltype(auto) exp2( const Proxy<PT,RT>& proxy )
1565{
1566 using blaze::exp2;
1567
1568 return exp2( (*proxy).get() );
1569}
1570//*************************************************************************************************
1571
1572
1573//*************************************************************************************************
1584template< typename PT, typename RT >
1585inline decltype(auto) exp10( const Proxy<PT,RT>& proxy )
1586{
1587 using blaze::exp10;
1588
1589 return exp10( (*proxy).get() );
1590}
1591//*************************************************************************************************
1592
1593
1594//*************************************************************************************************
1605template< typename PT, typename RT >
1606inline decltype(auto) log( const Proxy<PT,RT>& proxy )
1607{
1608 using blaze::log;
1609
1610 return log( (*proxy).get() );
1611}
1612//*************************************************************************************************
1613
1614
1615//*************************************************************************************************
1626template< typename PT, typename RT >
1627inline decltype(auto) log2( const Proxy<PT,RT>& proxy )
1628{
1629 using blaze::log2;
1630
1631 return log2( (*proxy).get() );
1632}
1633//*************************************************************************************************
1634
1635
1636//*************************************************************************************************
1647template< typename PT, typename RT >
1648inline decltype(auto) log10( const Proxy<PT,RT>& proxy )
1649{
1650 using blaze::log10;
1651
1652 return log10( (*proxy).get() );
1653}
1654//*************************************************************************************************
1655
1656
1657//*************************************************************************************************
1668template< typename PT, typename RT >
1669inline decltype(auto) log1p( const Proxy<PT,RT>& proxy )
1670{
1671 using blaze::log1p;
1672
1673 return log1p( (*proxy).get() );
1674}
1675//*************************************************************************************************
1676
1677
1678//*************************************************************************************************
1691template< typename PT, typename RT >
1692inline decltype(auto) lgamma( const Proxy<PT,RT>& proxy )
1693{
1694 using blaze::lgamma;
1695
1696 return lgamma( (*proxy).get() );
1697}
1698//*************************************************************************************************
1699
1700
1701//*************************************************************************************************
1712template< typename PT, typename RT >
1713inline decltype(auto) sin( const Proxy<PT,RT>& proxy )
1714{
1715 using blaze::sin;
1716
1717 return sin( (*proxy).get() );
1718}
1719//*************************************************************************************************
1720
1721
1722//*************************************************************************************************
1733template< typename PT, typename RT >
1734inline decltype(auto) asin( const Proxy<PT,RT>& proxy )
1735{
1736 using blaze::asin;
1737
1738 return asin( (*proxy).get() );
1739}
1740//*************************************************************************************************
1741
1742
1743//*************************************************************************************************
1754template< typename PT, typename RT >
1755inline decltype(auto) sinh( const Proxy<PT,RT>& proxy )
1756{
1757 using blaze::sinh;
1758
1759 return sinh( (*proxy).get() );
1760}
1761//*************************************************************************************************
1762
1763
1764//*************************************************************************************************
1775template< typename PT, typename RT >
1776inline decltype(auto) asinh( const Proxy<PT,RT>& proxy )
1777{
1778 using blaze::asinh;
1779
1780 return asinh( (*proxy).get() );
1781}
1782//*************************************************************************************************
1783
1784
1785//*************************************************************************************************
1796template< typename PT, typename RT >
1797inline decltype(auto) cos( const Proxy<PT,RT>& proxy )
1798{
1799 using blaze::cos;
1800
1801 return cos( (*proxy).get() );
1802}
1803//*************************************************************************************************
1804
1805
1806//*************************************************************************************************
1817template< typename PT, typename RT >
1818inline decltype(auto) acos( const Proxy<PT,RT>& proxy )
1819{
1820 using blaze::acos;
1821
1822 return acos( (*proxy).get() );
1823}
1824//*************************************************************************************************
1825
1826
1827//*************************************************************************************************
1838template< typename PT, typename RT >
1839inline decltype(auto) cosh( const Proxy<PT,RT>& proxy )
1840{
1841 using blaze::cosh;
1842
1843 return cosh( (*proxy).get() );
1844}
1845//*************************************************************************************************
1846
1847
1848//*************************************************************************************************
1859template< typename PT, typename RT >
1860inline decltype(auto) acosh( const Proxy<PT,RT>& proxy )
1861{
1862 using blaze::acosh;
1863
1864 return acosh( (*proxy).get() );
1865}
1866//*************************************************************************************************
1867
1868
1869//*************************************************************************************************
1880template< typename PT, typename RT >
1881inline decltype(auto) tan( const Proxy<PT,RT>& proxy )
1882{
1883 using blaze::tan;
1884
1885 return tan( (*proxy).get() );
1886}
1887//*************************************************************************************************
1888
1889
1890//*************************************************************************************************
1901template< typename PT, typename RT >
1902inline decltype(auto) atan( const Proxy<PT,RT>& proxy )
1903{
1904 using blaze::atan;
1905
1906 return atan( (*proxy).get() );
1907}
1908//*************************************************************************************************
1909
1910
1911//*************************************************************************************************
1922template< typename PT, typename RT >
1923inline decltype(auto) tanh( const Proxy<PT,RT>& proxy )
1924{
1925 using blaze::tanh;
1926
1927 return tanh( (*proxy).get() );
1928}
1929//*************************************************************************************************
1930
1931
1932//*************************************************************************************************
1943template< typename PT, typename RT >
1944inline decltype(auto) atanh( const Proxy<PT,RT>& proxy )
1945{
1946 using blaze::atanh;
1947
1948 return atanh( (*proxy).get() );
1949}
1950//*************************************************************************************************
1951
1952
1953//*************************************************************************************************
1966template< typename PT1, typename RT1, typename PT2, typename RT2 >
1967inline decltype(auto) atan2( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
1968{
1969 return atan2( (*lhs).get(), (*rhs).get() );
1970}
1971//*************************************************************************************************
1972
1973
1974//*************************************************************************************************
1987template< typename PT, typename RT, typename T, typename >
1988inline decltype(auto) atan2( const Proxy<PT,RT>& lhs, const T& rhs )
1989{
1990 return atan2( (*lhs).get(), rhs );
1991}
1992//*************************************************************************************************
1993
1994
1995//*************************************************************************************************
2008template< typename T, typename PT, typename RT, typename >
2009inline decltype(auto) atan2( const T& lhs, const Proxy<PT,RT>& rhs )
2010{
2011 return atan2( lhs, (*rhs).get() );
2012}
2013//*************************************************************************************************
2014
2015
2016//*************************************************************************************************
2027template< typename PT, typename RT >
2028inline decltype(auto) erf( const Proxy<PT,RT>& proxy )
2029{
2030 using blaze::erf;
2031
2032 return erf( (*proxy).get() );
2033}
2034//*************************************************************************************************
2035
2036
2037//*************************************************************************************************
2049template< typename PT, typename RT >
2050inline decltype(auto) erfc( const Proxy<PT,RT>& proxy )
2051{
2052 using blaze::erfc;
2053
2054 return erfc( (*proxy).get() );
2055}
2056//*************************************************************************************************
2057
2058
2059//*************************************************************************************************
2066template< typename PT, typename RT >
2067inline void reset( const Proxy<PT,RT>& proxy )
2068{
2069 using blaze::reset;
2070
2071 reset( (*proxy).get() );
2072}
2073//*************************************************************************************************
2074
2075
2076//*************************************************************************************************
2089template< typename PT, typename RT >
2090inline void reset( const Proxy<PT,RT>& proxy, size_t i )
2091{
2092 using blaze::reset;
2093
2094 reset( (*proxy).get(), i );
2095}
2096//*************************************************************************************************
2097
2098
2099//*************************************************************************************************
2106template< typename PT, typename RT >
2107inline void clear( const Proxy<PT,RT>& proxy )
2108{
2109 using blaze::clear;
2110
2111 clear( (*proxy).get() );
2112}
2113//*************************************************************************************************
2114
2115
2116//*************************************************************************************************
2133template< typename PT, typename RT >
2134inline void transpose( const Proxy<PT,RT>& proxy )
2135{
2136 if( (*proxy).isRestricted() ) {
2137 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
2138 }
2139
2140 transpose( (*proxy).get() );
2141}
2142//*************************************************************************************************
2143
2144
2145//*************************************************************************************************
2162template< typename PT, typename RT >
2163inline void ctranspose( const Proxy<PT,RT>& proxy )
2164{
2165 if( (*proxy).isRestricted() ) {
2166 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
2167 }
2168
2169 ctranspose( (*proxy).get() );
2170}
2171//*************************************************************************************************
2172
2173
2174//*************************************************************************************************
2202template< typename PT, typename RT >
2203inline void invert( const Proxy<PT,RT>& proxy )
2204{
2205 if( (*proxy).isRestricted() ) {
2206 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
2207 }
2208
2209 invert( (*proxy).get() );
2210}
2211//*************************************************************************************************
2212
2213
2214//*************************************************************************************************
2251template< InversionFlag IF, typename PT, typename RT >
2252inline void invert( const Proxy<PT,RT>& proxy )
2253{
2254 if( (*proxy).isRestricted() ) {
2255 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
2256 }
2257
2258 invert<IF>( (*proxy).get() );
2259}
2260//*************************************************************************************************
2261
2262
2263//*************************************************************************************************
2274template< RelaxationFlag RF, typename PT, typename RT >
2275inline bool isDefault( const Proxy<PT,RT>& proxy )
2276{
2277 using blaze::isDefault;
2278
2279 return isDefault<RF>( (*proxy).get() );
2280}
2281//*************************************************************************************************
2282
2283
2284//*************************************************************************************************
2296template< RelaxationFlag RF, typename PT, typename RT >
2297inline bool isReal( const Proxy<PT,RT>& proxy )
2298{
2299 using blaze::isReal;
2300
2301 return isReal<RF>( (*proxy).get() );
2302}
2303//*************************************************************************************************
2304
2305
2306//*************************************************************************************************
2316template< RelaxationFlag RF, typename PT, typename RT >
2317inline bool isZero( const Proxy<PT,RT>& proxy )
2318{
2319 using blaze::isZero;
2320
2321 return isZero<RF>( (*proxy).get() );
2322}
2323//*************************************************************************************************
2324
2325
2326//*************************************************************************************************
2336template< RelaxationFlag RF, typename PT, typename RT >
2337inline bool isOne( const Proxy<PT,RT>& proxy )
2338{
2339 using blaze::isOne;
2340
2341 return isOne<RF>( (*proxy).get() );
2342}
2343//*************************************************************************************************
2344
2345
2346//*************************************************************************************************
2356template< typename PT, typename RT >
2357inline bool isnan( const Proxy<PT,RT>& proxy )
2358{
2359 using blaze::isnan;
2360
2361 return isnan( (*proxy).get() );
2362}
2363//*************************************************************************************************
2364
2365
2366//*************************************************************************************************
2376template< typename PT, typename RT >
2377inline bool isinf( const Proxy<PT,RT>& proxy )
2378{
2379 using blaze::isinf;
2380
2381 return isinf( (*proxy).get() );
2382}
2383//*************************************************************************************************
2384
2385
2386//*************************************************************************************************
2397template< typename PT, typename RT >
2398inline bool isfinite( const Proxy<PT,RT>& proxy )
2399{
2400 using blaze::isfinite;
2401
2402 return isfinite( (*proxy).get() );
2403}
2404//*************************************************************************************************
2405
2406
2407//*************************************************************************************************
2415template< RelaxationFlag RF, typename PT1, typename RT1, typename PT2, typename RT2 >
2416inline bool equal( const Proxy<PT1,RT1>& lhs, const Proxy<PT2,RT2>& rhs )
2417{
2418 return equal<RF>( (*lhs).get(), (*rhs).get() );
2419}
2420//*************************************************************************************************
2421
2422
2423//*************************************************************************************************
2431template< RelaxationFlag RF, typename PT, typename RT, typename T, typename >
2432inline bool equal( const Proxy<PT,RT>& lhs, const T& rhs )
2433{
2434 return equal<RF>( (*lhs).get(), rhs );
2435}
2436//*************************************************************************************************
2437
2438
2439//*************************************************************************************************
2447template< RelaxationFlag RF, typename T, typename PT, typename RT, typename >
2448inline bool equal( const T& lhs, const Proxy<PT,RT>& rhs )
2449{
2450 return equal<RF>( lhs, (*rhs).get() );
2451}
2452//*************************************************************************************************
2453
2454
2455//*************************************************************************************************
2466template< typename PT, typename RT >
2467inline decltype(auto) evaluate( const Proxy<PT,RT>& proxy )
2468{
2469 using blaze::evaluate;
2470
2471 return evaluate( (*proxy).get() );
2472}
2473//*************************************************************************************************
2474
2475} // namespace blaze
2476
2477#endif
Header file for auxiliary alias declarations.
Header file for the ComplexProxy class.
Header file for the conjugate shim.
Header file for the DefaultProxy class.
Header file for the DenseMatrixProxy class.
Header file for the DenseVectorProxy class.
Header file for the EnableIf class template.
Header file for the evaluate shim.
Header file for the If class template.
Header file for the imaginary shim.
Header file for the dense matrix inversion flags.
Header file for the invert shim.
Header file for the IsComplex type trait.
Header file for the isDefault shim.
Header file for the IsDenseMatrix type trait.
Header file for the IsDenseVector type trait.
Header file for the isfinite shim.
Header file for the isinf shim.
Header file for the IsMatrix type trait.
Header file for the isnan shim.
Header file for the isOne shim.
Header file for the IsProxy type trait.
Header file for the isReal shim.
Header file for the IsVector type trait.
Header file for the relaxation flag enumeration.
Header file for the SparseMatrixProxy class.
Header file for the SparseVectorProxy class.
Proxy base class.
Definition: Proxy.h:169
bool operator!=(const T &lhs, const Proxy< PT, RT > &rhs)
Inquality comparison between an object of different type and a Proxy object.
Definition: Proxy.h:650
bool operator>(const T &lhs, const Proxy< PT, RT > &rhs)
Greater-than comparison between an object of different type and a Proxy object.
Definition: Proxy.h:746
decltype(auto) erfc(const Proxy< PT, RT > &proxy)
Computing the complementary error function of the represented element.
Definition: Proxy.h:2050
decltype(auto) log(const Proxy< PT, RT > &proxy)
Computing the natural logarithm of the represented element.
Definition: Proxy.h:1606
bool isfinite(const Proxy< PT, RT > &proxy)
Returns whether the represented element is finite.
Definition: Proxy.h:2398
decltype(auto) atan2(const T &lhs, const Proxy< PT, RT > &rhs)
Computes the multi-valued inverse tangent of an object of different type and a Proxy object.
Definition: Proxy.h:2009
decltype(auto) evaluate(const Proxy< PT, RT > &proxy)
Returns whether the represented element is finite.
Definition: Proxy.h:2467
decltype(auto) ceil(const Proxy< PT, RT > &proxy)
Computes the smallest integral value that is not less than the represented element.
Definition: Proxy.h:1140
decltype(auto) pow4(const Proxy< PT, RT > &proxy)
Computing the quadruple value of the represented element.
Definition: Proxy.h:1522
decltype(auto) trunc(const Proxy< PT, RT > &proxy)
Computes the nearest integral value that is not greater than the represented element.
Definition: Proxy.h:1161
decltype(auto) imag(const Proxy< PT, RT > &proxy)
Computing the imaginary part of the represented element.
Definition: Proxy.h:1285
bool isOne(const Proxy< PT, RT > &proxy)
Returns whether the represented element is 1.
Definition: Proxy.h:2337
void reset(const Proxy< PT, RT > &proxy, size_t i)
Reset the specified row/column of the represented matrix.
Definition: Proxy.h:2090
decltype(auto) abs(const Proxy< PT, RT > &proxy)
Computing the absolute value of the represented element.
Definition: Proxy.h:1077
decltype(auto) tan(const Proxy< PT, RT > &proxy)
Computing the tangent of the represented element.
Definition: Proxy.h:1881
decltype(auto) log1p(const Proxy< PT, RT > &proxy)
Computing the natural logarithm of x+1 of the represented element.
Definition: Proxy.h:1669
decltype(auto) invcbrt(const Proxy< PT, RT > &proxy)
Computing the inverse cubic root of the represented element.
Definition: Proxy.h:1369
decltype(auto) exp10(const Proxy< PT, RT > &proxy)
Computing the base-10 exponential of the represented element.
Definition: Proxy.h:1585
decltype(auto) log10(const Proxy< PT, RT > &proxy)
Computing the common logarithm of the represented element.
Definition: Proxy.h:1648
decltype(auto) acosh(const Proxy< PT, RT > &proxy)
Computing the inverse hyperbolic cosine of the represented element.
Definition: Proxy.h:1860
bool isReal(const Proxy< PT, RT > &proxy)
Returns whether the element represents a real number.
Definition: Proxy.h:2297
decltype(auto) floor(const Proxy< PT, RT > &proxy)
Computes the largest integral value that is not greater than the represented element.
Definition: Proxy.h:1119
decltype(auto) log2(const Proxy< PT, RT > &proxy)
Computing the binary logarithm of the represented element.
Definition: Proxy.h:1627
decltype(auto) conj(const Proxy< PT, RT > &proxy)
Computing the complex conjugate of the represented element.
Definition: Proxy.h:1203
decltype(auto) cbrt(const Proxy< PT, RT > &proxy)
Computing the cubic root of the represented element.
Definition: Proxy.h:1348
decltype(auto) cosh(const Proxy< PT, RT > &proxy)
Computing the hyperbolic cosine of the represented element.
Definition: Proxy.h:1839
void transpose(const Proxy< PT, RT > &proxy)
In-place transpose of the represented matrix element.
Definition: Proxy.h:2134
bool equal(const T &lhs, const Proxy< PT, RT > &rhs)
Equality comparison between an object of different type and a Proxy object.
Definition: Proxy.h:2448
decltype(auto) cos(const Proxy< PT, RT > &proxy)
Computing the cosine of the represented element.
Definition: Proxy.h:1797
bool operator<=(const T &lhs, const Proxy< PT, RT > &rhs)
Less-or-equal-than comparison between an object of different type and a Proxy object.
Definition: Proxy.h:794
decltype(auto) asinh(const Proxy< PT, RT > &proxy)
Computing the inverse hyperbolic sine of the represented element.
Definition: Proxy.h:1776
decltype(auto) atan(const Proxy< PT, RT > &proxy)
Computing the inverse tangent of the represented element.
Definition: Proxy.h:1902
decltype(auto) pow2(const Proxy< PT, RT > &proxy)
Computing the square value of the represented element.
Definition: Proxy.h:1480
decltype(auto) ctrans(const Proxy< PT, RT > &proxy)
Computing the conjugate transpose of the represented element.
Definition: Proxy.h:1243
bool isinf(const Proxy< PT, RT > &proxy)
Returns whether the represented element is infinite.
Definition: Proxy.h:2377
decltype(auto) round(const Proxy< PT, RT > &proxy)
Computes the nearest integral value to the represented element.
Definition: Proxy.h:1182
bool operator<(const T &lhs, const Proxy< PT, RT > &rhs)
Less-than comparison between an object of different type and a Proxy object.
Definition: Proxy.h:698
decltype(auto) pow(const Proxy< PT, RT > &proxy, const ET &exp)
Computing the exponential value of the represented element.
Definition: Proxy.h:1459
decltype(auto) acos(const Proxy< PT, RT > &proxy)
Computing the inverse cosine of the represented element.
Definition: Proxy.h:1818
decltype(auto) exp2(const Proxy< PT, RT > &proxy)
Computing the base-2 exponential of the represented element.
Definition: Proxy.h:1564
decltype(auto) pow3(const Proxy< PT, RT > &proxy)
Computing the cube value of the represented element.
Definition: Proxy.h:1501
bool operator>=(const T &lhs, const Proxy< PT, RT > &rhs)
Greater-or-equal-than comparison between an object of different type and a Proxy object.
Definition: Proxy.h:842
std::ostream & operator<<(std::ostream &os, const Proxy< PT, RT > &proxy)
Global output operator for the Proxy class template.
Definition: Proxy.h:858
bool operator==(const T &lhs, const Proxy< PT, RT > &rhs)
Equality comparison between an object of different type and a Proxy object.
Definition: Proxy.h:602
decltype(auto) tanh(const Proxy< PT, RT > &proxy)
Computing the hyperbolic tangent of the represented element.
Definition: Proxy.h:1923
decltype(auto) atanh(const Proxy< PT, RT > &proxy)
Computing the inverse hyperbolic tangent of the represented element.
Definition: Proxy.h:1944
decltype(auto) erf(const Proxy< PT, RT > &proxy)
Computing the error function of the represented element.
Definition: Proxy.h:2028
decltype(auto) invsqrt(const Proxy< PT, RT > &proxy)
Computing the inverse square root of the represented element.
Definition: Proxy.h:1327
decltype(auto) trans(const Proxy< PT, RT > &proxy)
Computing the transpose of the represented element.
Definition: Proxy.h:1223
decltype(auto) asin(const Proxy< PT, RT > &proxy)
Computing the inverse sine of the represented element.
Definition: Proxy.h:1734
decltype(auto) hypot(const T &lhs, const Proxy< PT, RT > &rhs)
Computes the hypotenous of an object of different type and a Proxy object.
Definition: Proxy.h:1437
bool isDefault(const Proxy< PT, RT > &proxy)
Returns whether the represented element is in default state.
Definition: Proxy.h:2275
bool isZero(const Proxy< PT, RT > &proxy)
Returns whether the represented element is 0.
Definition: Proxy.h:2317
decltype(auto) sin(const Proxy< PT, RT > &proxy)
Computing the sine of the represented element.
Definition: Proxy.h:1713
decltype(auto) lgamma(const Proxy< PT, RT > &proxy)
Computing the natural logarithm of the absolute value of the gamma function of the represented elemen...
Definition: Proxy.h:1692
decltype(auto) sqrt(const Proxy< PT, RT > &proxy)
Computing the square root of the represented element.
Definition: Proxy.h:1306
void invert(const Proxy< PT, RT > &proxy)
In-place inversion of the represented element.
Definition: Proxy.h:2252
decltype(auto) exp(const Proxy< PT, RT > &proxy)
Computing the base-e exponential of the represented element.
Definition: Proxy.h:1543
bool isnan(const Proxy< PT, RT > &proxy)
Returns whether the represented element is not-a-number.
Definition: Proxy.h:2357
void clear(const Proxy< PT, RT > &proxy)
Clearing the represented element.
Definition: Proxy.h:2107
decltype(auto) sinh(const Proxy< PT, RT > &proxy)
Computing the hyperbolic sine of the represented element.
Definition: Proxy.h:1755
decltype(auto) sign(const Proxy< PT, RT > &proxy)
Evaluating the sign of the represented element.
Definition: Proxy.h:1098
decltype(auto) real(const Proxy< PT, RT > &proxy)
Computing the real part of the represented element.
Definition: Proxy.h:1264
void ctranspose(const Proxy< PT, RT > &proxy)
In-place conjugate transpose of the represented matrix element.
Definition: Proxy.h:2163
typename If< Condition >::template Type< T1, T2 > If_t
Auxiliary alias template for the If class template.
Definition: If.h:108
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
Header file for the exception macros of the math module.
Header file for the abs shim.
Header file for the acos shim.
Header file for the acosh shim.
Header file for the asin shim.
Header file for the asinh shim.
Header file for the atan2 shim.
Header file for the atan shim.
Header file for the atanh shim.
Header file for the cbrt shim.
Header file for the ceil shim.
Header file for the clear shim.
Header file for the cos shim.
Header file for the cosh shim.
Header file for the erf shim.
Header file for the erfc shim.
Header file for the exp10 shim.
Header file for the exp2 shim.
Header file for the exp shim.
Header file for the floor shim.
Header file for the invcbrt shim.
Header file for the invsqrt shim.
Header file for the isZero shim.
Header file for the log10 shim.
Header file for the log2 shim.
Header file for the log shim.
Header file for the pow2 shim.
Header file for the pow3 shim.
Header file for the pow4 shim.
Header file for the pow shim.
Header file for the real shim.
Header file for the reset shim.
Header file for the round shim.
Header file for the sign shim.
Header file for the sin shim.
Header file for the sinh shim.
Header file for the sqrt shim.
Header file for the tan shim.
Header file for the tanh shim.
Header file for the trunc shim.
Header file for the generic max algorithm.
Header file for the generic min algorithm.