/usr/include/armadillo_bits/upgrade_val.hpp is in libarmadillo-dev 1:4.200.0+dfsg-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | // Copyright (C) 2009-2010 Conrad Sanderson
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au)
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//! \addtogroup upgrade_val
//! @{
//! upgrade_val is used to ensure an operation such as multiplication is possible between two types.
//! values are upgraded only where necessary.
template<typename T1, typename T2>
struct upgrade_val
{
typedef typename promote_type<T1,T2>::result T1_result;
typedef typename promote_type<T1,T2>::result T2_result;
arma_inline
static
typename promote_type<T1,T2>::result
apply(const T1 x)
{
typedef typename promote_type<T1,T2>::result out_type;
return out_type(x);
}
arma_inline
static
typename promote_type<T1,T2>::result
apply(const T2 x)
{
typedef typename promote_type<T1,T2>::result out_type;
return out_type(x);
}
};
// template<>
template<typename T>
struct upgrade_val<T,T>
{
typedef T T1_result;
typedef T T2_result;
arma_inline static const T& apply(const T& x) { return x; }
};
//! upgrade a type to allow multiplication with a complex type
//! e.g. the int in "int * complex<double>" is upgraded to a double
// template<>
template<typename T, typename T2>
struct upgrade_val< std::complex<T>, T2 >
{
typedef std::complex<T> T1_result;
typedef T T2_result;
arma_inline static const std::complex<T>& apply(const std::complex<T>& x) { return x; }
arma_inline static T apply(const T2 x) { return T(x); }
};
// template<>
template<typename T1, typename T>
struct upgrade_val< T1, std::complex<T> >
{
typedef T T1_result;
typedef std::complex<T> T2_result;
arma_inline static T apply(const T1 x) { return T(x); }
arma_inline static const std::complex<T>& apply(const std::complex<T>& x) { return x; }
};
//! ensure we don't lose precision when multiplying a complex number with a higher precision real number
template<>
struct upgrade_val< std::complex<float>, double >
{
typedef std::complex<double> T1_result;
typedef double T2_result;
arma_inline static const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
arma_inline static double apply(const double x) { return x; }
};
template<>
struct upgrade_val< double, std::complex<float> >
{
typedef double T1_result;
typedef std::complex<float> T2_result;
arma_inline static double apply(const double x) { return x; }
arma_inline static const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
};
//! ensure we don't lose precision when multiplying complex numbers with different underlying types
template<>
struct upgrade_val< std::complex<float>, std::complex<double> >
{
typedef std::complex<double> T1_result;
typedef std::complex<double> T2_result;
arma_inline static const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
arma_inline static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
};
template<>
struct upgrade_val< std::complex<double>, std::complex<float> >
{
typedef std::complex<double> T1_result;
typedef std::complex<double> T2_result;
arma_inline static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
arma_inline static const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
};
//! work around limitations in the complex class (at least as present in gcc 4.1 & 4.3)
template<>
struct upgrade_val< std::complex<double>, float >
{
typedef std::complex<double> T1_result;
typedef double T2_result;
arma_inline static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
arma_inline static double apply(const float x) { return double(x); }
};
template<>
struct upgrade_val< float, std::complex<double> >
{
typedef double T1_result;
typedef std::complex<double> T2_result;
arma_inline static double apply(const float x) { return double(x); }
arma_inline static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
};
//! @}
|