Mercurial > octave-nkf

comparison libinterp/octave-value/ov-base-mat.cc @ 20590:1a0a433c8263

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
eliminate more simple uses of error_state * dirfns.cc, oct-map.cc, oct-stream.cc, regexp.cc, ov-base-mat.cc, ov-cell.cc, pt-idx.cc, pt-mat.cc: Eliminate simple uses of error_state.
author John W. Eaton <jwe@octave.org>
date Mon, 05 Oct 2015 21:13:12 -0400
parents dd6345fd8a97
children
comparison
equal deleted inserted replaced
20589:b10432a40432 20590:1a0a433c8263
156 156
157 case 1: 157 case 1:
158 { 158 {
159 idx_vector i = idx (0).index_vector (); 159 idx_vector i = idx (0).index_vector ();
160 160
161 if (! error_state) 161 // optimize single scalar index.
162 { 162 if (! resize_ok && i.is_scalar ())
163 // optimize single scalar index. 163 retval = cmatrix.checkelem (i(0));
164 if (! resize_ok && i.is_scalar ()) 164 else
165 retval = cmatrix.checkelem (i(0)); 165 retval = MT (matrix.index (i, resize_ok));
166 else
167 retval = MT (matrix.index (i, resize_ok));
168 }
169 } 166 }
170 break; 167 break;
171 168
172 case 2: 169 case 2:
173 { 170 {
174 idx_vector i = idx (0).index_vector (); 171 idx_vector i = idx (0).index_vector ();
175 172
176 if (! error_state) 173 k=1;
177 { 174 idx_vector j = idx (1).index_vector ();
178 k=1; 175
179 idx_vector j = idx (1).index_vector (); 176 // optimize two scalar indices.
180 177 if (! resize_ok && i.is_scalar () && j.is_scalar ())
181 if (! error_state) 178 retval = cmatrix.checkelem (i(0), j(0));
182 { 179 else
183 // optimize two scalar indices. 180 retval = MT (matrix.index (i, j, resize_ok));
184 if (! resize_ok && i.is_scalar () && j.is_scalar ())
185 retval = cmatrix.checkelem (i(0), j(0));
186 else
187 retval = MT (matrix.index (i, j, resize_ok));
188 }
189 }
190 } 181 }
191 break; 182 break;
192 183
193 default: 184 default:
194 { 185 {
198 189
199 for (k = 0; k < n_idx; k++) 190 for (k = 0; k < n_idx; k++)
200 { 191 {
201 idx_vec(k) = idx(k).index_vector (); 192 idx_vec(k) = idx(k).index_vector ();
202 193
203 if (error_state)
204 break;
205
206 scalar_opt = (scalar_opt && idx_vec(k).is_scalar ()); 194 scalar_opt = (scalar_opt && idx_vec(k).is_scalar ());
207 } 195 }
208 196
209 if (! error_state) 197 if (scalar_opt)
210 { 198 retval = cmatrix.checkelem (conv_to_int_array (idx_vec));
211 if (scalar_opt) 199 else
212 retval = cmatrix.checkelem (conv_to_int_array (idx_vec)); 200 retval = MT (matrix.index (idx_vec, resize_ok));
213 else
214 retval = MT (matrix.index (idx_vec, resize_ok));
215 }
216 } 201 }
217 break; 202 break;
218 } 203 }
219 } 204 }
220 catch (index_exception& e) 205 catch (index_exception& e)
247 panic_impossible (); 232 panic_impossible ();
248 break; 233 break;
249 234
250 case 1: 235 case 1:
251 { 236 {
252 idx_vector i = idx (0).index_vector (); 237 idx_vector i = idx (0).index_vector ();
253 238
254 if (! error_state) 239 matrix.assign (i, rhs);
255 matrix.assign (i, rhs);
256 } 240 }
257 break; 241 break;
258 242
259 case 2: 243 case 2:
260 { 244 {
261 idx_vector i = idx (0).index_vector (); 245 idx_vector i = idx (0).index_vector ();
262 246
263 if (! error_state) 247 k = 1;
264 { 248 idx_vector j = idx (1).index_vector ();
265 k = 1; 249
266 idx_vector j = idx (1).index_vector (); 250 matrix.assign (i, j, rhs);
267
268 if (! error_state)
269 matrix.assign (i, j, rhs);
270 }
271 } 251 }
272 break; 252 break;
273 253
274 default: 254 default:
275 { 255 {
276 Array<idx_vector> idx_vec (dim_vector (n_idx, 1)); 256 Array<idx_vector> idx_vec (dim_vector (n_idx, 1));
277 257
278 for (k = 0; k < n_idx; k++) 258 for (k = 0; k < n_idx; k++)
279 { 259 idx_vec(k) = idx(k).index_vector ();
280 idx_vec(k) = idx(k).index_vector (); 260
281 261 matrix.assign (idx_vec, rhs);
282 if (error_state)
283 break;
284 }
285
286 if (! error_state)
287 matrix.assign (idx_vec, rhs);
288 } 262 }
289 break; 263 break;
290 } 264 }
291 } 265 }
292 catch (index_exception& e) 266 catch (index_exception& e)
334 308
335 case 1: 309 case 1:
336 { 310 {
337 idx_vector i = idx (0).index_vector (); 311 idx_vector i = idx (0).index_vector ();
338 312
339 if (! error_state) 313 // optimize single scalar index.
340 { 314 if (i.is_scalar () && i(0) < matrix.numel ())
341 // optimize single scalar index. 315 matrix(i(0)) = rhs;
342 if (i.is_scalar () && i(0) < matrix.numel ()) 316 else
343 matrix(i(0)) = rhs; 317 matrix.assign (i, mrhs);
344 else
345 matrix.assign (i, mrhs);
346 }
347 } 318 }
348 break; 319 break;
349 320
350 case 2: 321 case 2:
351 { 322 {
352 idx_vector i = idx (0).index_vector (); 323 idx_vector i = idx (0).index_vector ();
353 324
354 if (! error_state) 325 k = 1;
355 { 326 idx_vector j = idx (1).index_vector ();
356 k = 1; 327
357 idx_vector j = idx (1).index_vector (); 328 // optimize two scalar indices.
358 329 if (i.is_scalar () && j.is_scalar () && nd == 2
359 if (! error_state) 330 && i(0) < matrix.rows () && j(0) < matrix.columns ())
360 { 331 matrix(i(0), j(0)) = rhs;
361 // optimize two scalar indices. 332 else
362 if (i.is_scalar () && j.is_scalar () && nd == 2 333 matrix.assign (i, j, mrhs);
363 && i(0) < matrix.rows () && j(0) < matrix.columns ())
364 matrix(i(0), j(0)) = rhs;
365 else
366 matrix.assign (i, j, mrhs);
367 }
368 }
369 } 334 }
370 break; 335 break;
371 336
372 default: 337 default:
373 { 338 {
377 342
378 for (k = 0; k < n_idx; k++) 343 for (k = 0; k < n_idx; k++)
379 { 344 {
380 idx_vec(k) = idx(k).index_vector (); 345 idx_vec(k) = idx(k).index_vector ();
381 346
382 if (error_state)
383 break;
384
385 scalar_opt = (scalar_opt && idx_vec(k).is_scalar () 347 scalar_opt = (scalar_opt && idx_vec(k).is_scalar ()
386 && idx_vec(k)(0) < dv(k)); 348 && idx_vec(k)(0) < dv(k));
387 } 349 }
388 350
389 if (! error_state) 351 if (scalar_opt)
390 { 352 {
391 if (scalar_opt) 353 // optimize all scalar indices. Don't construct
354 // an index array, but rather calc a scalar index directly.
355 octave_idx_type n = 1;
356 octave_idx_type j = 0;
357 for (octave_idx_type i = 0; i < n_idx; i++)
392 { 358 {
393 // optimize all scalar indices. Don't construct 359 j += idx_vec(i)(0) * n;
394 // an index array, but rather calc a scalar index directly. 360 n *= dv (i);
395 octave_idx_type n = 1;
396 octave_idx_type j = 0;
397 for (octave_idx_type i = 0; i < n_idx; i++)
398 {
399 j += idx_vec(i)(0) * n;
400 n *= dv (i);
401 }
402 matrix(j) = rhs;
403 } 361 }
404 else 362 matrix(j) = rhs;
405 matrix.assign (idx_vec, mrhs);
406 } 363 }
364 else
365 matrix.assign (idx_vec, mrhs);
407 } 366 }
408 break; 367 break;
409 } 368 }
410 } 369 }
411 catch (const index_exception& e) 370 catch (const index_exception& e)