Mercurial > octave-nkf

comparison libinterp/corefcn/dot.cc @ 20588:4bed806ee3d4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
eliminate more simple uses of error_state * daspk.cc, dassl.cc, dot.cc, luinc.cc, sylvester.cc, variables.cc, __eigs__.cc: Eliminate simple uses of error_state.
author John W. Eaton <jwe@octave.org>
date Mon, 05 Oct 2015 20:21:55 -0400
parents b2100e1659ac
children
comparison
equal deleted inserted replaced
20587:f90c8372b7ba 20588:4bed806ee3d4
145 // Change to column vectors. 145 // Change to column vectors.
146 dimx = dimx.redim (1); 146 dimx = dimx.redim (1);
147 argx = argx.reshape (dimx); 147 argx = argx.reshape (dimx);
148 dimy = dimy.redim (1); 148 dimy = dimy.redim (1);
149 argy = argy.reshape (dimy); 149 argy = argy.reshape (dimy);
150 match = ! error_state && (dimx == dimy); 150 match = dimx == dimy;
151 } 151 }
152 152
153 if (match) 153 if (match)
154 { 154 {
155 int dim; 155 int dim;
156 if (nargin == 2) 156 if (nargin == 2)
157 dim = dimx.first_non_singleton (); 157 dim = dimx.first_non_singleton ();
158 else 158 else
159 dim = args(2).int_value (true) - 1; 159 dim = args(2).int_value (true) - 1;
160 160
161 if (error_state) 161 if (dim < 0)
162 ;
163 else if (dim < 0)
164 error ("dot: DIM must be a valid dimension"); 162 error ("dot: DIM must be a valid dimension");
165 else 163 else
166 { 164 {
167 octave_idx_type m, n, k; 165 octave_idx_type m, n, k;
168 dim_vector dimz; 166 dim_vector dimz;
172 { 170 {
173 FloatComplexNDArray x = argx.float_complex_array_value (); 171 FloatComplexNDArray x = argx.float_complex_array_value ();
174 FloatComplexNDArray y = argy.float_complex_array_value (); 172 FloatComplexNDArray y = argy.float_complex_array_value ();
175 get_red_dims (dimx, dimy, dim, dimz, m, n, k); 173 get_red_dims (dimx, dimy, dim, dimz, m, n, k);
176 FloatComplexNDArray z (dimz); 174 FloatComplexNDArray z (dimz);
177 if (! error_state) 175
178 F77_XFCN (cdotc3, CDOTC3, (m, n, k, 176 F77_XFCN (cdotc3, CDOTC3, (m, n, k,
179 x.data (), y.data (), 177 x.data (), y.data (),
180 z.fortran_vec ())); 178 z.fortran_vec ()));
181 retval = z; 179 retval = z;
182 } 180 }
183 else 181 else
184 { 182 {
185 ComplexNDArray x = argx.complex_array_value (); 183 ComplexNDArray x = argx.complex_array_value ();
186 ComplexNDArray y = argy.complex_array_value (); 184 ComplexNDArray y = argy.complex_array_value ();
187 get_red_dims (dimx, dimy, dim, dimz, m, n, k); 185 get_red_dims (dimx, dimy, dim, dimz, m, n, k);
188 ComplexNDArray z (dimz); 186 ComplexNDArray z (dimz);
189 if (! error_state) 187
190 F77_XFCN (zdotc3, ZDOTC3, (m, n, k, 188 F77_XFCN (zdotc3, ZDOTC3, (m, n, k,
191 x.data (), y.data (), 189 x.data (), y.data (),
192 z.fortran_vec ())); 190 z.fortran_vec ()));
193 retval = z; 191 retval = z;
194 } 192 }
195 } 193 }
196 else if (argx.is_float_type () && argy.is_float_type ()) 194 else if (argx.is_float_type () && argy.is_float_type ())
197 { 195 {
199 { 197 {
200 FloatNDArray x = argx.float_array_value (); 198 FloatNDArray x = argx.float_array_value ();
201 FloatNDArray y = argy.float_array_value (); 199 FloatNDArray y = argy.float_array_value ();
202 get_red_dims (dimx, dimy, dim, dimz, m, n, k); 200 get_red_dims (dimx, dimy, dim, dimz, m, n, k);
203 FloatNDArray z (dimz); 201 FloatNDArray z (dimz);
204 if (! error_state) 202
205 F77_XFCN (sdot3, SDOT3, (m, n, k, x.data (), y.data (), 203 F77_XFCN (sdot3, SDOT3, (m, n, k, x.data (), y.data (),
206 z.fortran_vec ())); 204 z.fortran_vec ()));
207 retval = z; 205 retval = z;
208 } 206 }
209 else 207 else
210 { 208 {
211 NDArray x = argx.array_value (); 209 NDArray x = argx.array_value ();
212 NDArray y = argy.array_value (); 210 NDArray y = argy.array_value ();
213 get_red_dims (dimx, dimy, dim, dimz, m, n, k); 211 get_red_dims (dimx, dimy, dim, dimz, m, n, k);
214 NDArray z (dimz); 212 NDArray z (dimz);
215 if (! error_state) 213
216 F77_XFCN (ddot3, DDOT3, (m, n, k, x.data (), y.data (), 214 F77_XFCN (ddot3, DDOT3, (m, n, k, x.data (), y.data (),
217 z.fortran_vec ())); 215 z.fortran_vec ()));
218 retval = z; 216 retval = z;
219 } 217 }
220 } 218 }
221 else 219 else
222 { 220 {
223 // Non-optimized evaluation. 221 // Non-optimized evaluation.
224 octave_value_list tmp; 222 octave_value_list tmp;
225 tmp(1) = dim + 1; 223 tmp(1) = dim + 1;
226 tmp(0) = do_binary_op (octave_value::op_el_mul, argx, argy); 224 tmp(0) = do_binary_op (octave_value::op_el_mul, argx, argy);
227 if (! error_state) 225
228 { 226 tmp = feval ("sum", tmp, 1);
229 tmp = feval ("sum", tmp, 1); 227 if (! tmp.empty ())
230 if (! tmp.empty ()) 228 retval = tmp(0);
231 retval = tmp(0);
232 }
233 } 229 }
234 } 230 }
235 } 231 }
236 else 232 else
237 error ("dot: sizes of X and Y must match"); 233 error ("dot: sizes of X and Y must match");
339 if (argx.is_single_type () || argy.is_single_type ()) 335 if (argx.is_single_type () || argy.is_single_type ())
340 { 336 {
341 FloatComplexNDArray x = argx.float_complex_array_value (); 337 FloatComplexNDArray x = argx.float_complex_array_value ();
342 FloatComplexNDArray y = argy.float_complex_array_value (); 338 FloatComplexNDArray y = argy.float_complex_array_value ();
343 FloatComplexNDArray z (dimz); 339 FloatComplexNDArray z (dimz);
344 if (! error_state) 340
345 F77_XFCN (cmatm3, CMATM3, (m, n, k, np, 341 F77_XFCN (cmatm3, CMATM3, (m, n, k, np,
346 x.data (), y.data (), 342 x.data (), y.data (),
347 z.fortran_vec ())); 343 z.fortran_vec ()));
348 retval = z; 344 retval = z;
349 } 345 }
350 else 346 else
351 { 347 {
352 ComplexNDArray x = argx.complex_array_value (); 348 ComplexNDArray x = argx.complex_array_value ();
353 ComplexNDArray y = argy.complex_array_value (); 349 ComplexNDArray y = argy.complex_array_value ();
354 ComplexNDArray z (dimz); 350 ComplexNDArray z (dimz);
355 if (! error_state) 351
356 F77_XFCN (zmatm3, ZMATM3, (m, n, k, np, 352 F77_XFCN (zmatm3, ZMATM3, (m, n, k, np,
357 x.data (), y.data (), 353 x.data (), y.data (),
358 z.fortran_vec ())); 354 z.fortran_vec ()));
359 retval = z; 355 retval = z;
360 } 356 }
361 } 357 }
362 else 358 else
363 { 359 {
364 if (argx.is_single_type () || argy.is_single_type ()) 360 if (argx.is_single_type () || argy.is_single_type ())
365 { 361 {
366 FloatNDArray x = argx.float_array_value (); 362 FloatNDArray x = argx.float_array_value ();
367 FloatNDArray y = argy.float_array_value (); 363 FloatNDArray y = argy.float_array_value ();
368 FloatNDArray z (dimz); 364 FloatNDArray z (dimz);
369 if (! error_state) 365
370 F77_XFCN (smatm3, SMATM3, (m, n, k, np, 366 F77_XFCN (smatm3, SMATM3, (m, n, k, np,
371 x.data (), y.data (), 367 x.data (), y.data (),
372 z.fortran_vec ())); 368 z.fortran_vec ()));
373 retval = z; 369 retval = z;
374 } 370 }
375 else 371 else
376 { 372 {
377 NDArray x = argx.array_value (); 373 NDArray x = argx.array_value ();
378 NDArray y = argy.array_value (); 374 NDArray y = argy.array_value ();
379 NDArray z (dimz); 375 NDArray z (dimz);
380 if (! error_state) 376
381 F77_XFCN (dmatm3, DMATM3, (m, n, k, np, 377 F77_XFCN (dmatm3, DMATM3, (m, n, k, np,
382 x.data (), y.data (), 378 x.data (), y.data (),
383 z.fortran_vec ())); 379 z.fortran_vec ()));
384 retval = z; 380 retval = z;
385 } 381 }
386 } 382 }
387 } 383 }
388 else 384 else