2 // { dg-additional-options "-Wno-return-type" }
6 typedef __SIZE_TYPE__ size_t;
11 template <typename> struct complex;
12 template <typename _Tp>
13 complex<_Tp> operator+(complex<_Tp> &__x, complex<_Tp> __y)
19 template <> struct complex<double>
24 return __imag__ _M_value;
26 void operator+=(complex __z) { _M_value += _M_value; _M_value += __z.imag (); }
27 _Complex double _M_value;
32 typedef std::complex<double> &const_reference;
38 std::complex<double> &operator[](int i) { return data_[i]; }
39 std::complex<double> *data_;
43 static std::complex<double>
44 apply (A::const_reference t1, std::complex<double> t2)
48 typedef std::complex<double> result_type;
50 template <class T1, class> struct D
53 apply (T1 t1, std::complex<double> t2)
58 class ublas_expression
63 template <class> class F
66 template <class E> class matrix_expression : ublas_expression
71 class I : public F<int>
74 typedef int value_type;
77 template <class E1, class E2> matrix_expression<int> outer_prod (F<E1>, F<E2>);
78 template <class E1, class F> class J : public matrix_expression<J<E1, F> >
81 typedef typename F::result_type value_type;
82 value_type operator()(int i, int)
84 return F::apply (e1_ (i, 0), e2_ (0, 0));
89 template <class E1, class E2>
90 J<H, C> operator+(matrix_expression<E1>, matrix_expression<E2>);
91 template <template <class, class> class F, class M, class E>
93 indexing_matrix_assign (M m, matrix_expression<E> e, int)
96 F<typename M::reference, typename E::value_type>::apply (m (0, 0),
99 template <template <class, class> class F, class, class M, class E, class C>
101 matrix_assign (M m, matrix_expression<E> e, int, C)
103 indexing_matrix_assign<F> (m, e, 0);
105 template <template <class, class> class F, class M, class E>
107 matrix_assign (M m, matrix_expression<E> e)
109 matrix_assign<F, int> (m, e, 0, typename M::orientation_category ());
111 class H : matrix_expression<int>
114 typedef std::complex<double> &reference;
115 typedef int orientation_category;
116 H (int, int) : data_ (0) {}
117 template <class AE> H (matrix_expression<AE> ae) : data_ (0)
119 matrix_assign<D> (*this, ae);
125 std::complex<double> &operator()(int i, int) { return data ()[i]; }
126 void operator+=(matrix_expression ae) { H (*this + ae); }
129 template <class M, class T, class V1, class V2>
131 sr2 (M m, T, V1 v1, V2 v2)
133 m += outer_prod (v2, v1);
135 template <class, class, std::size_t> struct G
139 template struct G<I, H, 3>;
140 template <class V, class M, std::size_t N>
146 sr2 (m, typename V::value_type (), b, c);