Mercurial > hg > vamp-build-and-test

comparison DEPENDENCIES/generic/include/boost/math/octonion.hpp @ 101:c530137014c0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update Boost headers (1.58.0)
author Chris Cannam
date Mon, 07 Sep 2015 11:12:49 +0100
parents 2665513ce2d3
children
comparison
equal deleted inserted replaced
100:793467b5e61c 101:c530137014c0
16 16
17 namespace boost 17 namespace boost
18 { 18 {
19 namespace math 19 namespace math
20 { 20 {
21 #if BOOST_WORKAROUND(__GNUC__, < 3)
22 // gcc 2.95.x uses expression templates for valarray calculations, but
23 // the result is not conforming. We need BOOST_GET_VALARRAY to get an
24 // actual valarray result when we need to call a member function
25 #define BOOST_GET_VALARRAY(T,x) ::std::valarray<T>(x)
26 // gcc 2.95.x has an "std::ios" class that is similar to
27 // "std::ios_base", so we just use a #define
28 #define BOOST_IOS_BASE ::std::ios
29 // gcc 2.x ignores function scope using declarations,
30 // put them in the scope of the enclosing namespace instead:
31 using ::std::valarray;
32 using ::std::sqrt;
33 using ::std::cos;
34 using ::std::sin;
35 using ::std::exp;
36 using ::std::cosh;
37 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
38 21
39 #define BOOST_OCTONION_ACCESSOR_GENERATOR(type) \ 22 #define BOOST_OCTONION_ACCESSOR_GENERATOR(type) \
40 type real() const \ 23 type real() const \
41 { \ 24 { \
42 return(a); \ 25 return(a); \
956 d /= rhs; \ 939 d /= rhs; \
957 \ 940 \
958 return(*this); \ 941 return(*this); \
959 } 942 }
960 943
961 #if defined(__GNUC__) && (__GNUC__ < 3) 944 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
962 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type) \
963 octonion<type> & operator /= (::std::complex<type> const & rhs) \
964 { \
965 using ::std::valarray; \
966 \
967 valarray<type> tr(2); \
968 \
969 tr[0] = rhs.real(); \
970 tr[1] = rhs.imag(); \
971 \
972 type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)(); \
973 \
974 tr *= mixam; \
975 \
976 valarray<type> tt(8); \
977 \
978 tt[0] = +a*tr[0]-b*tr[1]; \
979 tt[1] = -a*tr[1]+b*tr[0]; \
980 tt[2] = +c*tr[0]-d*tr[1]; \
981 tt[3] = +c*tr[1]+d*tr[0]; \
982 tt[4] = +e*tr[0]-f*tr[1]; \
983 tt[5] = +e*tr[1]+f*tr[0]; \
984 tt[6] = +g*tr[0]+h*tr[1]; \
985 tt[7] = +g*tr[1]+h*tr[0]; \
986 \
987 tr *= tr; \
988 \
989 tt *= (mixam/tr.sum()); \
990 \
991 a = tt[0]; \
992 b = tt[1]; \
993 c = tt[2]; \
994 d = tt[3]; \
995 e = tt[4]; \
996 f = tt[5]; \
997 g = tt[6]; \
998 h = tt[7]; \
999 \
1000 return(*this); \
1001 }
1002 #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
1003 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type) \ 945 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_2(type) \
1004 octonion<type> & operator /= (::std::complex<type> const & rhs) \ 946 octonion<type> & operator /= (::std::complex<type> const & rhs) \
1005 { \ 947 { \
1006 using ::std::valarray; \ 948 using ::std::valarray; \
1007 using ::std::abs; \ 949 using ::std::abs; \
1080 g = tt[6]; \ 1022 g = tt[6]; \
1081 h = tt[7]; \ 1023 h = tt[7]; \
1082 \ 1024 \
1083 return(*this); \ 1025 return(*this); \
1084 } 1026 }
1085 #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ 1027 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
1086 1028
1087 #if defined(__GNUC__) && (__GNUC__ < 3) 1029 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
1088 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type) \
1089 octonion<type> & operator /= (::boost::math::quaternion<type> const & rhs) \
1090 { \
1091 using ::std::valarray; \
1092 \
1093 valarray<type> tr(4); \
1094 \
1095 tr[0] = static_cast<type>(rhs.R_component_1()); \
1096 tr[1] = static_cast<type>(rhs.R_component_2()); \
1097 tr[2] = static_cast<type>(rhs.R_component_3()); \
1098 tr[3] = static_cast<type>(rhs.R_component_4()); \
1099 \
1100 type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)();\
1101 \
1102 tr *= mixam; \
1103 \
1104 valarray<type> tt(8); \
1105 \
1106 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]; \
1107 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]; \
1108 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]; \
1109 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]; \
1110 tt[4] = +e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \
1111 tt[5] = +e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \
1112 tt[6] = +e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \
1113 tt[7] = +e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \
1114 \
1115 tr *= tr; \
1116 \
1117 tt *= (mixam/tr.sum()); \
1118 \
1119 a = tt[0]; \
1120 b = tt[1]; \
1121 c = tt[2]; \
1122 d = tt[3]; \
1123 e = tt[4]; \
1124 f = tt[5]; \
1125 g = tt[6]; \
1126 h = tt[7]; \
1127 \
1128 return(*this); \
1129 }
1130 #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
1131 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type) \ 1030 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_3(type) \
1132 octonion<type> & operator /= (::boost::math::quaternion<type> const & rhs) \ 1031 octonion<type> & operator /= (::boost::math::quaternion<type> const & rhs) \
1133 { \ 1032 { \
1134 using ::std::valarray; \ 1033 using ::std::valarray; \
1135 using ::std::abs; \ 1034 using ::std::abs; \
1212 g = tt[6]; \ 1111 g = tt[6]; \
1213 h = tt[7]; \ 1112 h = tt[7]; \
1214 \ 1113 \
1215 return(*this); \ 1114 return(*this); \
1216 } 1115 }
1217 #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ 1116 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
1218 1117
1219 #if defined(__GNUC__) && (__GNUC__ < 3) 1118 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
1220 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type) \
1221 template<typename X> \
1222 octonion<type> & operator /= (octonion<X> const & rhs) \
1223 { \
1224 using ::std::valarray; \
1225 \
1226 valarray<type> tr(8); \
1227 \
1228 tr[0] = static_cast<type>(rhs.R_component_1()); \
1229 tr[1] = static_cast<type>(rhs.R_component_2()); \
1230 tr[2] = static_cast<type>(rhs.R_component_3()); \
1231 tr[3] = static_cast<type>(rhs.R_component_4()); \
1232 tr[4] = static_cast<type>(rhs.R_component_5()); \
1233 tr[5] = static_cast<type>(rhs.R_component_6()); \
1234 tr[6] = static_cast<type>(rhs.R_component_7()); \
1235 tr[7] = static_cast<type>(rhs.R_component_8()); \
1236 \
1237 type mixam = (BOOST_GET_VALARRAY(type,static_cast<type>(1)/abs(tr)).max)();\
1238 \
1239 tr *= mixam; \
1240 \
1241 valarray<type> tt(8); \
1242 \
1243 tt[0] = +a*tr[0]+b*tr[1]+c*tr[2]+d*tr[3]+e*tr[4]+f*tr[5]+g*tr[6]+h*tr[7]; \
1244 tt[1] = -a*tr[1]+b*tr[0]-c*tr[3]+d*tr[2]-e*tr[5]+f*tr[4]+g*tr[7]-h*tr[6]; \
1245 tt[2] = -a*tr[2]+b*tr[3]+c*tr[0]-d*tr[1]-e*tr[6]-f*tr[7]+g*tr[4]+h*tr[5]; \
1246 tt[3] = -a*tr[3]-b*tr[2]+c*tr[1]+d*tr[0]-e*tr[7]+f*tr[6]-g*tr[5]+h*tr[4]; \
1247 tt[4] = -a*tr[4]+b*tr[5]+c*tr[6]+d*tr[7]+e*tr[0]-f*tr[1]-g*tr[2]-h*tr[3]; \
1248 tt[5] = -a*tr[5]-b*tr[4]+c*tr[7]-d*tr[6]+e*tr[1]+f*tr[0]+g*tr[3]-h*tr[2]; \
1249 tt[6] = -a*tr[6]-b*tr[7]-c*tr[4]+d*tr[5]+e*tr[2]-f*tr[3]+g*tr[0]+h*tr[1]; \
1250 tt[7] = -a*tr[7]+b*tr[6]-c*tr[5]-d*tr[4]+e*tr[3]+f*tr[2]-g*tr[1]+h*tr[0]; \
1251 \
1252 tr *= tr; \
1253 \
1254 tt *= (mixam/tr.sum()); \
1255 \
1256 a = tt[0]; \
1257 b = tt[1]; \
1258 c = tt[2]; \
1259 d = tt[3]; \
1260 e = tt[4]; \
1261 f = tt[5]; \
1262 g = tt[6]; \
1263 h = tt[7]; \
1264 \
1265 return(*this); \
1266 }
1267 #elif defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
1268 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type) \ 1119 #define BOOST_OCTONION_MEMBER_DIV_GENERATOR_4(type) \
1269 template<typename X> \ 1120 template<typename X> \
1270 octonion<type> & operator /= (octonion<X> const & rhs) \ 1121 octonion<type> & operator /= (octonion<X> const & rhs) \
1271 { \ 1122 { \
1272 using ::std::valarray; \ 1123 using ::std::valarray; \
1359 g = tt[6]; \ 1210 g = tt[6]; \
1360 h = tt[7]; \ 1211 h = tt[7]; \
1361 \ 1212 \
1362 return(*this); \ 1213 return(*this); \
1363 } 1214 }
1364 #endif /* defined(__GNUC__) && (__GNUC__ < 3) */ /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ 1215 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
1365 1216
1366 1217
1367 #define BOOST_OCTONION_MEMBER_ADD_GENERATOR(type) \ 1218 #define BOOST_OCTONION_MEMBER_ADD_GENERATOR(type) \
1368 BOOST_OCTONION_MEMBER_ADD_GENERATOR_1(type) \ 1219 BOOST_OCTONION_MEMBER_ADD_GENERATOR_1(type) \
1369 BOOST_OCTONION_MEMBER_ADD_GENERATOR_2(type) \ 1220 BOOST_OCTONION_MEMBER_ADD_GENERATOR_2(type) \
1854 #undef BOOST_OCTONION_NOT_EQUAL_GENERATOR 1705 #undef BOOST_OCTONION_NOT_EQUAL_GENERATOR
1855 1706
1856 1707
1857 // Note: the default values in the constructors of the complex and quaternions make for 1708 // Note: the default values in the constructors of the complex and quaternions make for
1858 // a very complex and ambiguous situation; we have made choices to disambiguate. 1709 // a very complex and ambiguous situation; we have made choices to disambiguate.
1859
1860 #if BOOST_WORKAROUND(__GNUC__, < 3)
1861 template<typename T>
1862 ::std::istream & operator >> ( ::std::istream & is,
1863 octonion<T>& o)
1864 #else
1865 template<typename T, typename charT, class traits> 1710 template<typename T, typename charT, class traits>
1866 ::std::basic_istream<charT,traits> & operator >> ( ::std::basic_istream<charT,traits> & is, 1711 ::std::basic_istream<charT,traits> & operator >> ( ::std::basic_istream<charT,traits> & is,
1867 octonion<T> & o) 1712 octonion<T> & o)
1868 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1869 { 1713 {
1870 #if BOOST_WORKAROUND(__GNUC__, < 3)
1871 typedef char charT;
1872 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1873
1874 #ifdef BOOST_NO_STD_LOCALE 1714 #ifdef BOOST_NO_STD_LOCALE
1875 #else 1715 #else
1876 const ::std::ctype<charT> & ct = ::std::use_facet< ::std::ctype<charT> >(is.getloc()); 1716 const ::std::ctype<charT> & ct = ::std::use_facet< ::std::ctype<charT> >(is.getloc());
1877 #endif /* BOOST_NO_STD_LOCALE */ 1717 #endif /* BOOST_NO_STD_LOCALE */
1878 1718
1986 { 1826 {
1987 o = octonion<T>(p,q); 1827 o = octonion<T>(p,q);
1988 } 1828 }
1989 else // error 1829 else // error
1990 { 1830 {
1991 #if BOOST_WORKAROUND(__GNUC__, < 3)
1992 is.setstate(::std::ios::failbit);
1993 #else
1994 is.setstate(::std::ios_base::failbit); 1831 is.setstate(::std::ios_base::failbit);
1995 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
1996 } 1832 }
1997 } 1833 }
1998 else // error 1834 else // error
1999 { 1835 {
2000 #if BOOST_WORKAROUND(__GNUC__, < 3)
2001 is.setstate(::std::ios::failbit);
2002 #else
2003 is.setstate(::std::ios_base::failbit); 1836 is.setstate(::std::ios_base::failbit);
2004 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2005 } 1837 }
2006 } 1838 }
2007 else if (cc ==',') // read "((u," 1839 else if (cc ==',') // read "((u,"
2008 { 1840 {
2009 is >> v; // read "((u,v" 1841 is >> v; // read "((u,v"
2058 { 1890 {
2059 o = octonion<T>(p,q); 1891 o = octonion<T>(p,q);
2060 } 1892 }
2061 else // error 1893 else // error
2062 { 1894 {
2063 #if BOOST_WORKAROUND(__GNUC__, < 3)
2064 is.setstate(::std::ios::failbit);
2065 #else
2066 is.setstate(::std::ios_base::failbit); 1895 is.setstate(::std::ios_base::failbit);
2067 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2068 } 1896 }
2069 } 1897 }
2070 else // error 1898 else // error
2071 { 1899 {
2072 #if BOOST_WORKAROUND(__GNUC__, < 3)
2073 is.setstate(::std::ios::failbit);
2074 #else
2075 is.setstate(::std::ios_base::failbit); 1900 is.setstate(::std::ios_base::failbit);
2076 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2077 } 1901 }
2078 } 1902 }
2079 else // error 1903 else // error
2080 { 1904 {
2081 #if BOOST_WORKAROUND(__GNUC__, < 3)
2082 is.setstate(::std::ios::failbit);
2083 #else
2084 is.setstate(::std::ios_base::failbit); 1905 is.setstate(::std::ios_base::failbit);
2085 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2086 } 1906 }
2087 } 1907 }
2088 else // error 1908 else // error
2089 { 1909 {
2090 #if BOOST_WORKAROUND(__GNUC__, < 3)
2091 is.setstate(::std::ios::failbit);
2092 #else
2093 is.setstate(::std::ios_base::failbit); 1910 is.setstate(::std::ios_base::failbit);
2094 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2095 } 1911 }
2096 } 1912 }
2097 else // read "((a" 1913 else // read "((a"
2098 { 1914 {
2099 is.putback(ch); 1915 is.putback(ch);
2178 1994
2179 o = octonion<T>(p,q); 1995 o = octonion<T>(p,q);
2180 } 1996 }
2181 else // error 1997 else // error
2182 { 1998 {
2183 #if BOOST_WORKAROUND(__GNUC__, < 3)
2184 is.setstate(::std::ios::failbit);
2185 #else
2186 is.setstate(::std::ios_base::failbit); 1999 is.setstate(::std::ios_base::failbit);
2187 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2188 } 2000 }
2189 } 2001 }
2190 else // read "((a),(c" or "((a),(e" 2002 else // read "((a),(c" or "((a),(e"
2191 { 2003 {
2192 is.putback(ch); 2004 is.putback(ch);
2265 { 2077 {
2266 o = octonion<T>(u,v,x,y); 2078 o = octonion<T>(u,v,x,y);
2267 } 2079 }
2268 else // error 2080 else // error
2269 { 2081 {
2270 #if BOOST_WORKAROUND(__GNUC__, < 3)
2271 is.setstate(::std::ios::failbit);
2272 #else
2273 is.setstate(::std::ios_base::failbit); 2082 is.setstate(::std::ios_base::failbit);
2274 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2275 } 2083 }
2276 } 2084 }
2277 else // error 2085 else // error
2278 { 2086 {
2279 #if BOOST_WORKAROUND(__GNUC__, < 3)
2280 is.setstate(::std::ios::failbit);
2281 #else
2282 is.setstate(::std::ios_base::failbit); 2087 is.setstate(::std::ios_base::failbit);
2283 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2284 } 2088 }
2285 } 2089 }
2286 else // error 2090 else // error
2287 { 2091 {
2288 #if BOOST_WORKAROUND(__GNUC__, < 3)
2289 is.setstate(::std::ios::failbit);
2290 #else
2291 is.setstate(::std::ios_base::failbit); 2092 is.setstate(::std::ios_base::failbit);
2292 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2293 } 2093 }
2294 } 2094 }
2295 else if (cc == ',') // read "((a),(c," or "((a),(e," 2095 else if (cc == ',') // read "((a),(c," or "((a),(e,"
2296 { 2096 {
2297 is >> ch; // get the next lexeme 2097 is >> ch; // get the next lexeme
2340 { 2140 {
2341 o = octonion<T>(p,q); 2141 o = octonion<T>(p,q);
2342 } 2142 }
2343 else // error 2143 else // error
2344 { 2144 {
2345 #if BOOST_WORKAROUND(__GNUC__, < 3)
2346 is.setstate(::std::ios::failbit);
2347 #else
2348 is.setstate(::std::ios_base::failbit); 2145 is.setstate(::std::ios_base::failbit);
2349 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2350 } 2146 }
2351 } 2147 }
2352 else // error 2148 else // error
2353 { 2149 {
2354 #if BOOST_WORKAROUND(__GNUC__, < 3)
2355 is.setstate(::std::ios::failbit);
2356 #else
2357 is.setstate(::std::ios_base::failbit); 2150 is.setstate(::std::ios_base::failbit);
2358 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2359 } 2151 }
2360 } 2152 }
2361 else // read "((a),(c,d" or "((a),(e,f" 2153 else // read "((a),(c,d" or "((a),(e,f"
2362 { 2154 {
2363 is.putback(ch); 2155 is.putback(ch);
2436 { 2228 {
2437 o = octonion<T>(u,v,x,y); 2229 o = octonion<T>(u,v,x,y);
2438 } 2230 }
2439 else // error 2231 else // error
2440 { 2232 {
2441 #if BOOST_WORKAROUND(__GNUC__, < 3)
2442 is.setstate(::std::ios::failbit);
2443 #else
2444 is.setstate(::std::ios_base::failbit); 2233 is.setstate(::std::ios_base::failbit);
2445 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2446 } 2234 }
2447 } 2235 }
2448 else // error 2236 else // error
2449 { 2237 {
2450 #if BOOST_WORKAROUND(__GNUC__, < 3)
2451 is.setstate(::std::ios::failbit);
2452 #else
2453 is.setstate(::std::ios_base::failbit); 2238 is.setstate(::std::ios_base::failbit);
2454 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2455 } 2239 }
2456 } 2240 }
2457 else // error 2241 else // error
2458 { 2242 {
2459 #if BOOST_WORKAROUND(__GNUC__, < 3)
2460 is.setstate(::std::ios::failbit);
2461 #else
2462 is.setstate(::std::ios_base::failbit); 2243 is.setstate(::std::ios_base::failbit);
2463 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2464 } 2244 }
2465 } 2245 }
2466 else if (cc == ',') // read "((a),(e,f," (ambiguity resolution) 2246 else if (cc == ',') // read "((a),(e,f," (ambiguity resolution)
2467 { 2247 {
2468 p = ::boost::math::quaternion<T>(a); 2248 p = ::boost::math::quaternion<T>(a);
2499 { 2279 {
2500 o = octonion<T>(p,q); 2280 o = octonion<T>(p,q);
2501 } 2281 }
2502 else // error 2282 else // error
2503 { 2283 {
2504 #if BOOST_WORKAROUND(__GNUC__, < 3)
2505 is.setstate(::std::ios::failbit);
2506 #else
2507 is.setstate(::std::ios_base::failbit); 2284 is.setstate(::std::ios_base::failbit);
2508 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2509 } 2285 }
2510 } 2286 }
2511 else if (cc == ',') // read "((a),(e,f,g," 2287 else if (cc == ',') // read "((a),(e,f,g,"
2512 { 2288 {
2513 is >> h; // read "((a),(e,f,g,h" 2289 is >> h; // read "((a),(e,f,g,h"
2542 { 2318 {
2543 o = octonion<T>(p,q); 2319 o = octonion<T>(p,q);
2544 } 2320 }
2545 else // error 2321 else // error
2546 { 2322 {
2547 #if BOOST_WORKAROUND(__GNUC__, < 3)
2548 is.setstate(::std::ios::failbit);
2549 #else
2550 is.setstate(::std::ios_base::failbit); 2323 is.setstate(::std::ios_base::failbit);
2551 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2552 } 2324 }
2553 } 2325 }
2554 else // error 2326 else // error
2555 { 2327 {
2556 #if BOOST_WORKAROUND(__GNUC__, < 3)
2557 is.setstate(::std::ios::failbit);
2558 #else
2559 is.setstate(::std::ios_base::failbit); 2328 is.setstate(::std::ios_base::failbit);
2560 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2561 } 2329 }
2562 } 2330 }
2563 else // error 2331 else // error
2564 { 2332 {
2565 #if BOOST_WORKAROUND(__GNUC__, < 3)
2566 is.setstate(::std::ios::failbit);
2567 #else
2568 is.setstate(::std::ios_base::failbit); 2333 is.setstate(::std::ios_base::failbit);
2569 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2570 } 2334 }
2571 } 2335 }
2572 else // error 2336 else // error
2573 { 2337 {
2574 #if BOOST_WORKAROUND(__GNUC__, < 3)
2575 is.setstate(::std::ios::failbit);
2576 #else
2577 is.setstate(::std::ios_base::failbit); 2338 is.setstate(::std::ios_base::failbit);
2578 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2579 } 2339 }
2580 } 2340 }
2581 } 2341 }
2582 else // error 2342 else // error
2583 { 2343 {
2584 #if BOOST_WORKAROUND(__GNUC__, < 3)
2585 is.setstate(::std::ios::failbit);
2586 #else
2587 is.setstate(::std::ios_base::failbit); 2344 is.setstate(::std::ios_base::failbit);
2588 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2589 } 2345 }
2590 } 2346 }
2591 } 2347 }
2592 else // read "((a),c" (ambiguity resolution) 2348 else // read "((a),c" (ambiguity resolution)
2593 { 2349 {
2649 { 2405 {
2650 o = octonion<T>(a,b,c,d,x.real(),x.imag(),y.real(),y.imag()); 2406 o = octonion<T>(a,b,c,d,x.real(),x.imag(),y.real(),y.imag());
2651 } 2407 }
2652 else // error 2408 else // error
2653 { 2409 {
2654 #if BOOST_WORKAROUND(__GNUC__, < 3)
2655 is.setstate(::std::ios::failbit);
2656 #else
2657 is.setstate(::std::ios_base::failbit); 2410 is.setstate(::std::ios_base::failbit);
2658 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2659 } 2411 }
2660 } 2412 }
2661 else // error 2413 else // error
2662 { 2414 {
2663 #if BOOST_WORKAROUND(__GNUC__, < 3)
2664 is.setstate(::std::ios::failbit);
2665 #else
2666 is.setstate(::std::ios_base::failbit); 2415 is.setstate(::std::ios_base::failbit);
2667 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2668 } 2416 }
2669 } 2417 }
2670 else // error 2418 else // error
2671 { 2419 {
2672 #if BOOST_WORKAROUND(__GNUC__, < 3)
2673 is.setstate(::std::ios::failbit);
2674 #else
2675 is.setstate(::std::ios_base::failbit); 2420 is.setstate(::std::ios_base::failbit);
2676 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2677 } 2421 }
2678 } 2422 }
2679 } 2423 }
2680 else // error 2424 else // error
2681 { 2425 {
2682 #if BOOST_WORKAROUND(__GNUC__, < 3)
2683 is.setstate(::std::ios::failbit);
2684 #else
2685 is.setstate(::std::ios_base::failbit); 2426 is.setstate(::std::ios_base::failbit);
2686 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2687 } 2427 }
2688 } 2428 }
2689 else if (cc ==',') // read "((a," 2429 else if (cc ==',') // read "((a,"
2690 { 2430 {
2691 is >> ch; // get the next lexeme 2431 is >> ch; // get the next lexeme
2756 { 2496 {
2757 o = octonion<T>(p,q); 2497 o = octonion<T>(p,q);
2758 } 2498 }
2759 else // error 2499 else // error
2760 { 2500 {
2761 #if BOOST_WORKAROUND(__GNUC__, < 3)
2762 is.setstate(::std::ios::failbit);
2763 #else
2764 is.setstate(::std::ios_base::failbit); 2501 is.setstate(::std::ios_base::failbit);
2765 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2766 } 2502 }
2767 } 2503 }
2768 else // error 2504 else // error
2769 { 2505 {
2770 #if BOOST_WORKAROUND(__GNUC__, < 3)
2771 is.setstate(::std::ios::failbit);
2772 #else
2773 is.setstate(::std::ios_base::failbit); 2506 is.setstate(::std::ios_base::failbit);
2774 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2775 } 2507 }
2776 } 2508 }
2777 else // error 2509 else // error
2778 { 2510 {
2779 #if BOOST_WORKAROUND(__GNUC__, < 3)
2780 is.setstate(::std::ios::failbit);
2781 #else
2782 is.setstate(::std::ios_base::failbit); 2511 is.setstate(::std::ios_base::failbit);
2783 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2784 } 2512 }
2785 } 2513 }
2786 else 2514 else
2787 { 2515 {
2788 is.putback(ch); 2516 is.putback(ch);
2867 { 2595 {
2868 o = octonion<T>(p,q); 2596 o = octonion<T>(p,q);
2869 } 2597 }
2870 else // error 2598 else // error
2871 { 2599 {
2872 #if BOOST_WORKAROUND(__GNUC__, < 3)
2873 is.setstate(::std::ios::failbit);
2874 #else
2875 is.setstate(::std::ios_base::failbit); 2600 is.setstate(::std::ios_base::failbit);
2876 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2877 } 2601 }
2878 } 2602 }
2879 else // read "((a,b),(c" or "((a,b),(e" 2603 else // read "((a,b),(c" or "((a,b),(e"
2880 { 2604 {
2881 is.putback(ch); 2605 is.putback(ch);
2954 { 2678 {
2955 o = octonion<T>(u,v,x,y); 2679 o = octonion<T>(u,v,x,y);
2956 } 2680 }
2957 else // error 2681 else // error
2958 { 2682 {
2959 #if BOOST_WORKAROUND(__GNUC__, < 3)
2960 is.setstate(::std::ios::failbit);
2961 #else
2962 is.setstate(::std::ios_base::failbit); 2683 is.setstate(::std::ios_base::failbit);
2963 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2964 } 2684 }
2965 } 2685 }
2966 else // error 2686 else // error
2967 { 2687 {
2968 #if BOOST_WORKAROUND(__GNUC__, < 3)
2969 is.setstate(::std::ios::failbit);
2970 #else
2971 is.setstate(::std::ios_base::failbit); 2688 is.setstate(::std::ios_base::failbit);
2972 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2973 } 2689 }
2974 } 2690 }
2975 else // error 2691 else // error
2976 { 2692 {
2977 #if BOOST_WORKAROUND(__GNUC__, < 3)
2978 is.setstate(::std::ios::failbit);
2979 #else
2980 is.setstate(::std::ios_base::failbit); 2693 is.setstate(::std::ios_base::failbit);
2981 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
2982 } 2694 }
2983 } 2695 }
2984 else if (cc == ',') // read "((a,b),(c," or "((a,b),(e," 2696 else if (cc == ',') // read "((a,b),(c," or "((a,b),(e,"
2985 { 2697 {
2986 is >> ch; // get the next lexeme 2698 is >> ch; // get the next lexeme
3031 { 2743 {
3032 o = octonion<T>(u,v,x,y); 2744 o = octonion<T>(u,v,x,y);
3033 } 2745 }
3034 else // error 2746 else // error
3035 { 2747 {
3036 #if BOOST_WORKAROUND(__GNUC__, < 3)
3037 is.setstate(::std::ios::failbit);
3038 #else
3039 is.setstate(::std::ios_base::failbit); 2748 is.setstate(::std::ios_base::failbit);
3040 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3041 } 2749 }
3042 } 2750 }
3043 else // error 2751 else // error
3044 { 2752 {
3045 #if BOOST_WORKAROUND(__GNUC__, < 3)
3046 is.setstate(::std::ios::failbit);
3047 #else
3048 is.setstate(::std::ios_base::failbit); 2753 is.setstate(::std::ios_base::failbit);
3049 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3050 } 2754 }
3051 } 2755 }
3052 else // read "((a,b),(c,d" or "((a,b),(e,f" 2756 else // read "((a,b),(c,d" or "((a,b),(e,f"
3053 { 2757 {
3054 is.putback(ch); 2758 is.putback(ch);
3127 { 2831 {
3128 o = octonion<T>(u,v,x,y); 2832 o = octonion<T>(u,v,x,y);
3129 } 2833 }
3130 else // error 2834 else // error
3131 { 2835 {
3132 #if BOOST_WORKAROUND(__GNUC__, < 3)
3133 is.setstate(::std::ios::failbit);
3134 #else
3135 is.setstate(::std::ios_base::failbit); 2836 is.setstate(::std::ios_base::failbit);
3136 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3137 } 2837 }
3138 } 2838 }
3139 else // error 2839 else // error
3140 { 2840 {
3141 #if BOOST_WORKAROUND(__GNUC__, < 3)
3142 is.setstate(::std::ios::failbit);
3143 #else
3144 is.setstate(::std::ios_base::failbit); 2841 is.setstate(::std::ios_base::failbit);
3145 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3146 } 2842 }
3147 } 2843 }
3148 else // error 2844 else // error
3149 { 2845 {
3150 #if BOOST_WORKAROUND(__GNUC__, < 3)
3151 is.setstate(::std::ios::failbit);
3152 #else
3153 is.setstate(::std::ios_base::failbit); 2846 is.setstate(::std::ios_base::failbit);
3154 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3155 } 2847 }
3156 } 2848 }
3157 else if (cc == ',') // read "((a,b),(e,f," (ambiguity resolution) 2849 else if (cc == ',') // read "((a,b),(e,f," (ambiguity resolution)
3158 { 2850 {
3159 p = ::boost::math::quaternion<T>(a,b); // too late to backtrack 2851 p = ::boost::math::quaternion<T>(a,b); // too late to backtrack
3190 2882
3191 o = octonion<T>(p,q); 2883 o = octonion<T>(p,q);
3192 } 2884 }
3193 else // error 2885 else // error
3194 { 2886 {
3195 #if BOOST_WORKAROUND(__GNUC__, < 3)
3196 is.setstate(::std::ios::failbit);
3197 #else
3198 is.setstate(::std::ios_base::failbit); 2887 is.setstate(::std::ios_base::failbit);
3199 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3200 } 2888 }
3201 } 2889 }
3202 else if (cc == ',') // read "((a,b),(e,f,g," 2890 else if (cc == ',') // read "((a,b),(e,f,g,"
3203 { 2891 {
3204 is >> h; // read "((a,b),(e,f,g,h" 2892 is >> h; // read "((a,b),(e,f,g,h"
3233 2921
3234 o = octonion<T>(p,q); 2922 o = octonion<T>(p,q);
3235 } 2923 }
3236 else // error 2924 else // error
3237 { 2925 {
3238 #if BOOST_WORKAROUND(__GNUC__, < 3)
3239 is.setstate(::std::ios::failbit);
3240 #else
3241 is.setstate(::std::ios_base::failbit); 2926 is.setstate(::std::ios_base::failbit);
3242 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3243 } 2927 }
3244 } 2928 }
3245 else // error 2929 else // error
3246 { 2930 {
3247 #if BOOST_WORKAROUND(__GNUC__, < 3)
3248 is.setstate(::std::ios::failbit);
3249 #else
3250 is.setstate(::std::ios_base::failbit); 2931 is.setstate(::std::ios_base::failbit);
3251 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3252 } 2932 }
3253 } 2933 }
3254 else // error 2934 else // error
3255 { 2935 {
3256 #if BOOST_WORKAROUND(__GNUC__, < 3)
3257 is.setstate(::std::ios::failbit);
3258 #else
3259 is.setstate(::std::ios_base::failbit); 2936 is.setstate(::std::ios_base::failbit);
3260 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3261 } 2937 }
3262 } 2938 }
3263 else // error 2939 else // error
3264 { 2940 {
3265 #if BOOST_WORKAROUND(__GNUC__, < 3)
3266 is.setstate(::std::ios::failbit);
3267 #else
3268 is.setstate(::std::ios_base::failbit); 2941 is.setstate(::std::ios_base::failbit);
3269 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3270 } 2942 }
3271 } 2943 }
3272 } 2944 }
3273 else // error 2945 else // error
3274 { 2946 {
3275 #if BOOST_WORKAROUND(__GNUC__, < 3)
3276 is.setstate(::std::ios::failbit);
3277 #else
3278 is.setstate(::std::ios_base::failbit); 2947 is.setstate(::std::ios_base::failbit);
3279 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3280 } 2948 }
3281 } 2949 }
3282 } 2950 }
3283 else // error 2951 else // error
3284 { 2952 {
3285 #if BOOST_WORKAROUND(__GNUC__, < 3)
3286 is.setstate(::std::ios::failbit);
3287 #else
3288 is.setstate(::std::ios_base::failbit); 2953 is.setstate(::std::ios_base::failbit);
3289 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3290 } 2954 }
3291 } 2955 }
3292 else // error 2956 else // error
3293 { 2957 {
3294 #if BOOST_WORKAROUND(__GNUC__, < 3)
3295 is.setstate(::std::ios::failbit);
3296 #else
3297 is.setstate(::std::ios_base::failbit); 2958 is.setstate(::std::ios_base::failbit);
3298 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3299 } 2959 }
3300 } 2960 }
3301 else if (cc == ',') // read "((a,b," 2961 else if (cc == ',') // read "((a,b,"
3302 { 2962 {
3303 is >> c; // read "((a,b,c" 2963 is >> c; // read "((a,b,c"
3352 { 3012 {
3353 o = octonion<T>(p,q); 3013 o = octonion<T>(p,q);
3354 } 3014 }
3355 else // error 3015 else // error
3356 { 3016 {
3357 #if BOOST_WORKAROUND(__GNUC__, < 3)
3358 is.setstate(::std::ios::failbit);
3359 #else
3360 is.setstate(::std::ios_base::failbit); 3017 is.setstate(::std::ios_base::failbit);
3361 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3362 } 3018 }
3363 } 3019 }
3364 else // error 3020 else // error
3365 { 3021 {
3366 #if BOOST_WORKAROUND(__GNUC__, < 3)
3367 is.setstate(::std::ios::failbit);
3368 #else
3369 is.setstate(::std::ios_base::failbit); 3022 is.setstate(::std::ios_base::failbit);
3370 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3371 } 3023 }
3372 } 3024 }
3373 else if (cc == ',') // read "((a,b,c," 3025 else if (cc == ',') // read "((a,b,c,"
3374 { 3026 {
3375 is >> d; // read "((a,b,c,d" 3027 is >> d; // read "((a,b,c,d"
3424 { 3076 {
3425 o = octonion<T>(p,q); 3077 o = octonion<T>(p,q);
3426 } 3078 }
3427 else // error 3079 else // error
3428 { 3080 {
3429 #if BOOST_WORKAROUND(__GNUC__, < 3)
3430 is.setstate(::std::ios::failbit);
3431 #else
3432 is.setstate(::std::ios_base::failbit); 3081 is.setstate(::std::ios_base::failbit);
3433 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3434 } 3082 }
3435 } 3083 }
3436 else // error 3084 else // error
3437 { 3085 {
3438 #if BOOST_WORKAROUND(__GNUC__, < 3)
3439 is.setstate(::std::ios::failbit);
3440 #else
3441 is.setstate(::std::ios_base::failbit); 3086 is.setstate(::std::ios_base::failbit);
3442 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3443 } 3087 }
3444 } 3088 }
3445 else // error 3089 else // error
3446 { 3090 {
3447 #if BOOST_WORKAROUND(__GNUC__, < 3)
3448 is.setstate(::std::ios::failbit);
3449 #else
3450 is.setstate(::std::ios_base::failbit); 3091 is.setstate(::std::ios_base::failbit);
3451 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3452 } 3092 }
3453 } 3093 }
3454 else // error 3094 else // error
3455 { 3095 {
3456 #if BOOST_WORKAROUND(__GNUC__, < 3)
3457 is.setstate(::std::ios::failbit);
3458 #else
3459 is.setstate(::std::ios_base::failbit); 3096 is.setstate(::std::ios_base::failbit);
3460 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3461 } 3097 }
3462 } 3098 }
3463 else // error 3099 else // error
3464 { 3100 {
3465 #if BOOST_WORKAROUND(__GNUC__, < 3)
3466 is.setstate(::std::ios::failbit);
3467 #else
3468 is.setstate(::std::ios_base::failbit); 3101 is.setstate(::std::ios_base::failbit);
3469 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3470 } 3102 }
3471 } 3103 }
3472 } 3104 }
3473 else // error 3105 else // error
3474 { 3106 {
3475 #if BOOST_WORKAROUND(__GNUC__, < 3)
3476 is.setstate(::std::ios::failbit);
3477 #else
3478 is.setstate(::std::ios_base::failbit); 3107 is.setstate(::std::ios_base::failbit);
3479 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3480 } 3108 }
3481 } 3109 }
3482 } 3110 }
3483 else // read "(a" 3111 else // read "(a"
3484 { 3112 {
3552 { 3180 {
3553 o = octonion<T>(p,q); 3181 o = octonion<T>(p,q);
3554 } 3182 }
3555 else // error 3183 else // error
3556 { 3184 {
3557 #if BOOST_WORKAROUND(__GNUC__, < 3)
3558 is.setstate(::std::ios::failbit);
3559 #else
3560 is.setstate(::std::ios_base::failbit); 3185 is.setstate(::std::ios_base::failbit);
3561 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3562 } 3186 }
3563 } 3187 }
3564 else // read "(a,(c" or "(a,(e" 3188 else // read "(a,(c" or "(a,(e"
3565 { 3189 {
3566 is.putback(ch); 3190 is.putback(ch);
3639 { 3263 {
3640 o = octonion<T>(u,v,x,y); 3264 o = octonion<T>(u,v,x,y);
3641 } 3265 }
3642 else // error 3266 else // error
3643 { 3267 {
3644 #if BOOST_WORKAROUND(__GNUC__, < 3)
3645 is.setstate(::std::ios::failbit);
3646 #else
3647 is.setstate(::std::ios_base::failbit); 3268 is.setstate(::std::ios_base::failbit);
3648 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3649 } 3269 }
3650 } 3270 }
3651 else // error 3271 else // error
3652 { 3272 {
3653 #if BOOST_WORKAROUND(__GNUC__, < 3)
3654 is.setstate(::std::ios::failbit);
3655 #else
3656 is.setstate(::std::ios_base::failbit); 3273 is.setstate(::std::ios_base::failbit);
3657 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3658 } 3274 }
3659 } 3275 }
3660 else // error 3276 else // error
3661 { 3277 {
3662 #if BOOST_WORKAROUND(__GNUC__, < 3)
3663 is.setstate(::std::ios::failbit);
3664 #else
3665 is.setstate(::std::ios_base::failbit); 3278 is.setstate(::std::ios_base::failbit);
3666 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3667 } 3279 }
3668 } 3280 }
3669 else if (cc == ',') // read "(a,(c," or "(a,(e," 3281 else if (cc == ',') // read "(a,(c," or "(a,(e,"
3670 { 3282 {
3671 is >> ch; // get the next lexeme 3283 is >> ch; // get the next lexeme
3716 { 3328 {
3717 o = octonion<T>(u,v,x,y); 3329 o = octonion<T>(u,v,x,y);
3718 } 3330 }
3719 else // error 3331 else // error
3720 { 3332 {
3721 #if BOOST_WORKAROUND(__GNUC__, < 3)
3722 is.setstate(::std::ios::failbit);
3723 #else
3724 is.setstate(::std::ios_base::failbit); 3333 is.setstate(::std::ios_base::failbit);
3725 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3726 } 3334 }
3727 } 3335 }
3728 else // error 3336 else // error
3729 { 3337 {
3730 #if BOOST_WORKAROUND(__GNUC__, < 3)
3731 is.setstate(::std::ios::failbit);
3732 #else
3733 is.setstate(::std::ios_base::failbit); 3338 is.setstate(::std::ios_base::failbit);
3734 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3735 } 3339 }
3736 } 3340 }
3737 else // read "(a,(c,d" or "(a,(e,f" 3341 else // read "(a,(c,d" or "(a,(e,f"
3738 { 3342 {
3739 is.putback(ch); 3343 is.putback(ch);
3812 { 3416 {
3813 o = octonion<T>(u,v,x,y); 3417 o = octonion<T>(u,v,x,y);
3814 } 3418 }
3815 else // error 3419 else // error
3816 { 3420 {
3817 #if BOOST_WORKAROUND(__GNUC__, < 3)
3818 is.setstate(::std::ios::failbit);
3819 #else
3820 is.setstate(::std::ios_base::failbit); 3421 is.setstate(::std::ios_base::failbit);
3821 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3822 } 3422 }
3823 } 3423 }
3824 else // error 3424 else // error
3825 { 3425 {
3826 #if BOOST_WORKAROUND(__GNUC__, < 3)
3827 is.setstate(::std::ios::failbit);
3828 #else
3829 is.setstate(::std::ios_base::failbit); 3426 is.setstate(::std::ios_base::failbit);
3830 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3831 } 3427 }
3832 } 3428 }
3833 else // error 3429 else // error
3834 { 3430 {
3835 #if BOOST_WORKAROUND(__GNUC__, < 3)
3836 is.setstate(::std::ios::failbit);
3837 #else
3838 is.setstate(::std::ios_base::failbit); 3431 is.setstate(::std::ios_base::failbit);
3839 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3840 } 3432 }
3841 } 3433 }
3842 else if (cc == ',') // read "(a,(e,f," (ambiguity resolution) 3434 else if (cc == ',') // read "(a,(e,f," (ambiguity resolution)
3843 { 3435 {
3844 p = ::boost::math::quaternion<T>(a); 3436 p = ::boost::math::quaternion<T>(a);
3875 3467
3876 o = octonion<T>(p,q); 3468 o = octonion<T>(p,q);
3877 } 3469 }
3878 else // error 3470 else // error
3879 { 3471 {
3880 #if BOOST_WORKAROUND(__GNUC__, < 3)
3881 is.setstate(::std::ios::failbit);
3882 #else
3883 is.setstate(::std::ios_base::failbit); 3472 is.setstate(::std::ios_base::failbit);
3884 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3885 } 3473 }
3886 } 3474 }
3887 else if (cc == ',') // read "(a,(e,f,g," 3475 else if (cc == ',') // read "(a,(e,f,g,"
3888 { 3476 {
3889 is >> h; // read "(a,(e,f,g,h" 3477 is >> h; // read "(a,(e,f,g,h"
3918 3506
3919 o = octonion<T>(p,q); 3507 o = octonion<T>(p,q);
3920 } 3508 }
3921 else // error 3509 else // error
3922 { 3510 {
3923 #if BOOST_WORKAROUND(__GNUC__, < 3)
3924 is.setstate(::std::ios::failbit);
3925 #else
3926 is.setstate(::std::ios_base::failbit); 3511 is.setstate(::std::ios_base::failbit);
3927 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3928 } 3512 }
3929 } 3513 }
3930 else // error 3514 else // error
3931 { 3515 {
3932 #if BOOST_WORKAROUND(__GNUC__, < 3)
3933 is.setstate(::std::ios::failbit);
3934 #else
3935 is.setstate(::std::ios_base::failbit); 3516 is.setstate(::std::ios_base::failbit);
3936 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3937 } 3517 }
3938 } 3518 }
3939 else // error 3519 else // error
3940 { 3520 {
3941 #if BOOST_WORKAROUND(__GNUC__, < 3)
3942 is.setstate(::std::ios::failbit);
3943 #else
3944 is.setstate(::std::ios_base::failbit); 3521 is.setstate(::std::ios_base::failbit);
3945 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3946 } 3522 }
3947 } 3523 }
3948 else // error 3524 else // error
3949 { 3525 {
3950 #if BOOST_WORKAROUND(__GNUC__, < 3)
3951 is.setstate(::std::ios::failbit);
3952 #else
3953 is.setstate(::std::ios_base::failbit); 3526 is.setstate(::std::ios_base::failbit);
3954 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3955 } 3527 }
3956 } 3528 }
3957 } 3529 }
3958 else // error 3530 else // error
3959 { 3531 {
3960 #if BOOST_WORKAROUND(__GNUC__, < 3)
3961 is.setstate(::std::ios::failbit);
3962 #else
3963 is.setstate(::std::ios_base::failbit); 3532 is.setstate(::std::ios_base::failbit);
3964 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
3965 } 3533 }
3966 } 3534 }
3967 } 3535 }
3968 else // read "(a,b" or "(a,c" (ambiguity resolution) 3536 else // read "(a,b" or "(a,c" (ambiguity resolution)
3969 { 3537 {
4045 { 3613 {
4046 o = octonion<T>(u,v,x,y); 3614 o = octonion<T>(u,v,x,y);
4047 } 3615 }
4048 else // error 3616 else // error
4049 { 3617 {
4050 #if BOOST_WORKAROUND(__GNUC__, < 3)
4051 is.setstate(::std::ios::failbit);
4052 #else
4053 is.setstate(::std::ios_base::failbit); 3618 is.setstate(::std::ios_base::failbit);
4054 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4055 } 3619 }
4056 } 3620 }
4057 else // error 3621 else // error
4058 { 3622 {
4059 #if BOOST_WORKAROUND(__GNUC__, < 3)
4060 is.setstate(::std::ios::failbit);
4061 #else
4062 is.setstate(::std::ios_base::failbit); 3623 is.setstate(::std::ios_base::failbit);
4063 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4064 } 3624 }
4065 } 3625 }
4066 else // read "(a,b,c" or "(a,c,e" 3626 else // read "(a,b,c" or "(a,c,e"
4067 { 3627 {
4068 is.putback(ch); 3628 is.putback(ch);
4125 { 3685 {
4126 o = octonion<T>(u,v,x,y); 3686 o = octonion<T>(u,v,x,y);
4127 } 3687 }
4128 else // error 3688 else // error
4129 { 3689 {
4130 #if BOOST_WORKAROUND(__GNUC__, < 3)
4131 is.setstate(::std::ios::failbit);
4132 #else
4133 is.setstate(::std::ios_base::failbit); 3690 is.setstate(::std::ios_base::failbit);
4134 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4135 } 3691 }
4136 } 3692 }
4137 else // read "(a,b,c,d" (ambiguity resolution) 3693 else // read "(a,b,c,d" (ambiguity resolution)
4138 { 3694 {
4139 is.putback(ch); // we backtrack 3695 is.putback(ch); // we backtrack
4236 { 3792 {
4237 o = octonion<T>(a,b,c,d,e,f,g,h); 3793 o = octonion<T>(a,b,c,d,e,f,g,h);
4238 } 3794 }
4239 else // error 3795 else // error
4240 { 3796 {
4241 #if BOOST_WORKAROUND(__GNUC__, < 3)
4242 is.setstate(::std::ios::failbit);
4243 #else
4244 is.setstate(::std::ios_base::failbit); 3797 is.setstate(::std::ios_base::failbit);
4245 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4246 } 3798 }
4247 } 3799 }
4248 else // error 3800 else // error
4249 { 3801 {
4250 #if BOOST_WORKAROUND(__GNUC__, < 3)
4251 is.setstate(::std::ios::failbit);
4252 #else
4253 is.setstate(::std::ios_base::failbit); 3802 is.setstate(::std::ios_base::failbit);
4254 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4255 } 3803 }
4256 } 3804 }
4257 else // error 3805 else // error
4258 { 3806 {
4259 #if BOOST_WORKAROUND(__GNUC__, < 3)
4260 is.setstate(::std::ios::failbit);
4261 #else
4262 is.setstate(::std::ios_base::failbit); 3807 is.setstate(::std::ios_base::failbit);
4263 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4264 } 3808 }
4265 } 3809 }
4266 else // error 3810 else // error
4267 { 3811 {
4268 #if BOOST_WORKAROUND(__GNUC__, < 3)
4269 is.setstate(::std::ios::failbit);
4270 #else
4271 is.setstate(::std::ios_base::failbit); 3812 is.setstate(::std::ios_base::failbit);
4272 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4273 } 3813 }
4274 } 3814 }
4275 else // error 3815 else // error
4276 { 3816 {
4277 #if BOOST_WORKAROUND(__GNUC__, < 3)
4278 is.setstate(::std::ios::failbit);
4279 #else
4280 is.setstate(::std::ios_base::failbit); 3817 is.setstate(::std::ios_base::failbit);
4281 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4282 } 3818 }
4283 } 3819 }
4284 } 3820 }
4285 else // error 3821 else // error
4286 { 3822 {
4287 #if BOOST_WORKAROUND(__GNUC__, < 3)
4288 is.setstate(::std::ios::failbit);
4289 #else
4290 is.setstate(::std::ios_base::failbit); 3823 is.setstate(::std::ios_base::failbit);
4291 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4292 } 3824 }
4293 } 3825 }
4294 } 3826 }
4295 else // error 3827 else // error
4296 { 3828 {
4297 #if BOOST_WORKAROUND(__GNUC__, < 3)
4298 is.setstate(::std::ios::failbit);
4299 #else
4300 is.setstate(::std::ios_base::failbit); 3829 is.setstate(::std::ios_base::failbit);
4301 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4302 } 3830 }
4303 } 3831 }
4304 } 3832 }
4305 else // error 3833 else // error
4306 { 3834 {
4307 #if BOOST_WORKAROUND(__GNUC__, < 3)
4308 is.setstate(::std::ios::failbit);
4309 #else
4310 is.setstate(::std::ios_base::failbit); 3835 is.setstate(::std::ios_base::failbit);
4311 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4312 } 3836 }
4313 } 3837 }
4314 } 3838 }
4315 else // format: a 3839 else // format: a
4316 { 3840 {
4326 finish: 3850 finish:
4327 return(is); 3851 return(is);
4328 } 3852 }
4329 3853
4330 3854
4331 #if BOOST_WORKAROUND(__GNUC__, < 3)
4332 template<typename T>
4333 ::std::ostream & operator << ( ::std::ostream & os,
4334 octonion<T> const & o)
4335 #else
4336 template<typename T, typename charT, class traits> 3855 template<typename T, typename charT, class traits>
4337 ::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os, 3856 ::std::basic_ostream<charT,traits> & operator << ( ::std::basic_ostream<charT,traits> & os,
4338 octonion<T> const & o) 3857 octonion<T> const & o)
4339 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4340 { 3858 {
4341 #if BOOST_WORKAROUND(__GNUC__, < 3)
4342 ::std::ostringstream s;
4343 #else
4344 ::std::basic_ostringstream<charT,traits> s; 3859 ::std::basic_ostringstream<charT,traits> s;
4345 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4346 3860
4347 s.flags(os.flags()); 3861 s.flags(os.flags());
4348 #ifdef BOOST_NO_STD_LOCALE 3862 #ifdef BOOST_NO_STD_LOCALE
4349 #else 3863 #else
4350 s.imbue(os.getloc()); 3864 s.imbue(os.getloc());
4402 using ::std::abs; 3916 using ::std::abs;
4403 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ 3917 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
4404 3918
4405 BOOST_OCTONION_VALARRAY_LOADER 3919 BOOST_OCTONION_VALARRAY_LOADER
4406 3920
4407 #if BOOST_WORKAROUND(__GNUC__, < 3)
4408 return((BOOST_GET_VALARRAY(T, abs(temp)).max)());
4409 #else
4410 return((abs(temp).max)()); 3921 return((abs(temp).max)());
4411 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4412 } 3922 }
4413 3923
4414 3924
4415 template<typename T> 3925 template<typename T>
4416 inline T l1(octonion<T> const & o) 3926 inline T l1(octonion<T> const & o)
4419 using ::std::abs; 3929 using ::std::abs;
4420 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */ 3930 #endif /* BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP */
4421 3931
4422 BOOST_OCTONION_VALARRAY_LOADER 3932 BOOST_OCTONION_VALARRAY_LOADER
4423 3933
4424 #if BOOST_WORKAROUND(__GNUC__, < 3)
4425 return(BOOST_GET_VALARRAY(T, abs(temp)).sum());
4426 #else
4427 return(abs(temp).sum()); 3934 return(abs(temp).sum());
4428 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4429 } 3935 }
4430 3936
4431 3937
4432 template<typename T> 3938 template<typename T>
4433 inline T abs(const octonion<T> & o) 3939 inline T abs(const octonion<T> & o)
4438 3944
4439 using ::std::sqrt; 3945 using ::std::sqrt;
4440 3946
4441 BOOST_OCTONION_VALARRAY_LOADER 3947 BOOST_OCTONION_VALARRAY_LOADER
4442 3948
4443 #if BOOST_WORKAROUND(__GNUC__, < 3)
4444 T maxim = (BOOST_GET_VALARRAY(T,abs(temp)).max)(); // overflow protection
4445 #else
4446 T maxim = (abs(temp).max)(); // overflow protection 3949 T maxim = (abs(temp).max)(); // overflow protection
4447 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4448 3950
4449 if (maxim == static_cast<T>(0)) 3951 if (maxim == static_cast<T>(0))
4450 { 3952 {
4451 return(maxim); 3953 return(maxim);
4452 } 3954 }
4743 } 4245 }
4744 } 4246 }
4745 } 4247 }
4746 } 4248 }
4747 4249
4748
4749 #if BOOST_WORKAROUND(__GNUC__, < 3)
4750 #undef BOOST_GET_VALARRAY
4751 #endif /* BOOST_WORKAROUND(__GNUC__, < 3) */
4752
4753
4754 #endif /* BOOST_OCTONION_HPP */ 4250 #endif /* BOOST_OCTONION_HPP */