Mercurial > hg > octave-nkf

comparison src/data.cc @ 7433:402168152bb9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2008-01-31 18:59:09 by dbateman]
author dbateman
date Thu, 31 Jan 2008 18:59:11 +0000
parents 3fade00a6ac7
children bd2bd04e68ca
comparison
equal deleted inserted replaced
7432:3c999b2b5de8 7433:402168152bb9
3303 retval (0) = sys + usr; 3303 retval (0) = sys + usr;
3304 3304
3305 return retval; 3305 return retval;
3306 } 3306 }
3307 3307
3308 DEFUN (sort, args, nargout,
3309 "-*- texinfo -*-\n\
3310 @deftypefn {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x})\n\
3311 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim})\n\
3312 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{mode})\n\
3313 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim}, @var{mode})\n\
3314 Return a copy of @var{x} with the elements arranged in increasing\n\
3315 order. For matrices, @code{sort} orders the elements in each column.\n\
3316 \n\
3317 For example,\n\
3318 \n\
3319 @example\n\
3320 @group\n\
3321 sort ([1, 2; 2, 3; 3, 1])\n\
3322 @result{} 1 1\n\
3323 2 2\n\
3324 3 3\n\
3325 @end group\n\
3326 @end example\n\
3327 \n\
3328 The @code{sort} function may also be used to produce a matrix\n\
3329 containing the original row indices of the elements in the sorted\n\
3330 matrix. For example,\n\
3331 \n\
3332 @example\n\
3333 @group\n\
3334 [s, i] = sort ([1, 2; 2, 3; 3, 1])\n\
3335 @result{} s = 1 1\n\
3336 2 2\n\
3337 3 3\n\
3338 @result{} i = 1 3\n\
3339 2 1\n\
3340 3 2\n\
3341 @end group\n\
3342 @end example\n\
3343 \n\
3344 If the optional argument @var{dim} is given, then the matrix is sorted\n\
3345 along the dimension defined by @var{dim}. The optional argument @code{mode}\n\
3346 defines the order in which the values will be sorted. Valid values of\n\
3347 @code{mode} are `ascend' or `descend'.\n\
3348 \n\
3349 For equal elements, the indices are such that the equal elements are listed\n\
3350 in the order that appeared in the original list.\n\
3351 \n\
3352 The @code{sort} function may also be used to sort strings and cell arrays\n\
3353 of strings, in which case the dictionary order of the strings is used.\n\
3354 \n\
3355 The algorithm used in @code{sort} is optimized for the sorting of partially\n\
3356 ordered lists.\n\
3357 @end deftypefn")
3358 {
3359 octave_value_list retval;
3360
3361 int nargin = args.length ();
3362 sortmode smode = ASCENDING;
3363
3364 if (nargin < 1 || nargin > 3)
3365 {
3366 print_usage ();
3367 return retval;
3368 }
3369
3370 bool return_idx = nargout > 1;
3371
3372 octave_value arg = args(0);
3373
3374 int dim = 0;
3375 if (nargin > 1)
3376 {
3377 if (args(1).is_string ())
3378 {
3379 std::string mode = args(1).string_value();
3380 if (mode == "ascend")
3381 smode = ASCENDING;
3382 else if (mode == "descend")
3383 smode = DESCENDING;
3384 else
3385 {
3386 error ("sort: mode must be either \"ascend\" or \"descend\"");
3387 return retval;
3388 }
3389 }
3390 else
3391 dim = args(1).nint_value () - 1;
3392 }
3393
3394 if (nargin > 2)
3395 {
3396 if (args(1).is_string ())
3397 {
3398 print_usage ();
3399 return retval;
3400 }
3401
3402 if (! args(2).is_string ())
3403 {
3404 error ("sort: mode must be a string");
3405 return retval;
3406 }
3407 std::string mode = args(2).string_value();
3408 if (mode == "ascend")
3409 smode = ASCENDING;
3410 else if (mode == "descend")
3411 smode = DESCENDING;
3412 else
3413 {
3414 error ("sort: mode must be either \"ascend\" or \"descend\"");
3415 return retval;
3416 }
3417 }
3418
3419 dim_vector dv = arg.dims ();
3420 if (error_state)
3421 {
3422 gripe_wrong_type_arg ("sort", arg);
3423 return retval;
3424 }
3425 if (nargin == 1 || args(1).is_string ())
3426 {
3427 // Find first non singleton dimension
3428 for (int i = 0; i < dv.length (); i++)
3429 if (dv(i) > 1)
3430 {
3431 dim = i;
3432 break;
3433 }
3434 }
3435 else
3436 {
3437 if (dim < 0 || dim > dv.length () - 1)
3438 {
3439 error ("sort: dim must be a valid dimension");
3440 return retval;
3441 }
3442 }
3443
3444 if (return_idx)
3445 {
3446 Array<octave_idx_type> sidx;
3447
3448 retval (0) = arg.sort (sidx, dim, smode);
3449
3450 octave_idx_type *ps = sidx.fortran_vec ();
3451 NDArray midx (sidx.dims ());
3452 double *pm = midx.fortran_vec ();
3453
3454 for (octave_idx_type i = 0; i < sidx.numel (); i++)
3455 pm [i] = static_cast<double>
3456 (ps [i] + static_cast<octave_idx_type> (1));
3457
3458 retval (1) = midx;
3459 }
3460 else
3461 retval(0) = arg.sort (dim, smode);
3462
3463 return retval;
3464 }
3465
3466 /*
3467
3468 %% Double
3469 %!assert (sort ([NaN, 1, -1, 2, Inf]), [-1, 1, 2, Inf, NaN])
3470 %!assert (sort ([NaN, 1, -1, 2, Inf], 1), [NaN, 1, -1, 2, Inf])
3471 %!assert (sort ([NaN, 1, -1, 2, Inf], 2), [-1, 1, 2, Inf, NaN])
3472 %!error (sort ([NaN, 1, -1, 2, Inf], 3))
3473 %!assert (sort ([NaN, 1, -1, 2, Inf], "ascend"), [-1, 1, 2, Inf, NaN])
3474 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "ascend"), [-1, 1, 2, Inf, NaN])
3475 %!assert (sort ([NaN, 1, -1, 2, Inf], "descend"), [NaN, Inf, 2, 1, -1])
3476 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, 1, -1])
3477 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4]), [3, 1, 6, 4; 8, 2, 7, 5])
3478 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 1), [3, 1, 6, 4; 8, 2, 7, 5])
3479 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 2), [1, 3, 5, 7; 2, 4, 6, 8])
3480 %!assert (sort (1), 1)
3481
3482 %!test
3483 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]);
3484 %! assert (v, [-1, 1, 1, Inf, NaN])
3485 %! assert (i, [3, 2, 5, 4, 1])
3486
3487 %% Complex
3488 %!assert (sort ([NaN, 1i, -1, 2, Inf]), [1i, -1, 2, Inf, NaN])
3489 %!assert (sort ([NaN, 1i, -1, 2, Inf], 1), [NaN, 1i, -1, 2, Inf])
3490 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2), [1i, -1, 2, Inf, NaN])
3491 %!error (sort ([NaN, 1i, -1, 2, Inf], 3))
3492 %!assert (sort ([NaN, 1i, -1, 2, Inf], "ascend"), [1i, -1, 2, Inf, NaN])
3493 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "ascend"), [1i, -1, 2, Inf, NaN])
3494 %!assert (sort ([NaN, 1i, -1, 2, Inf], "descend"), [NaN, Inf, 2, -1, 1i])
3495 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, -1, 1i])
3496 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4]), [3, 1i, 6, 4; 8, 2, 7, 5])
3497 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 1), [3, 1i, 6, 4; 8, 2, 7, 5])
3498 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 2), [1i, 3, 5, 7; 2, 4, 6, 8])
3499 %!assert (sort (1i), 1i)
3500
3501 %!test
3502 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]);
3503 %! assert (v, [1, 1i, 1i, -1, Inf, NaN])
3504 %! assert (i, [5, 2, 6, 3, 4, 1])
3505
3506 %% Bool
3507 %!assert (sort ([true, false, true, false]), [false, false, true, true])
3508 %!assert (sort ([true, false, true, false], 1), [true, false, true, false])
3509 %!assert (sort ([true, false, true, false], 2), [false, false, true, true])
3510 %!error (sort ([true, false, true, false], 3))
3511 %!assert (sort ([true, false, true, false], "ascend"), [false, false, true, true])
3512 %!assert (sort ([true, false, true, false], 2, "ascend"), [false, false, true, true])
3513 %!assert (sort ([true, false, true, false], "descend"), [true, true, false, false])
3514 %!assert (sort ([true, false, true, false], 2, "descend"), [true, true, false, false])
3515 %!assert (sort (true), true)
3516
3517 %!test
3518 %! [v, i] = sort ([true, false, true, false]);
3519 %! assert (v, [false, false, true, true])
3520 %! assert (i, [2, 4, 1, 3])
3521
3522 %% Sparse Double
3523 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf])), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
3524 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1, 0, -1, 2, Inf]))
3525 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
3526 %!error (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 3))
3527 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
3528 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
3529 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1]))
3530 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1]))
3531
3532 %!shared a
3533 %! a = randn (10, 10);
3534 %! a (a < 0) = 0;
3535 %!assert (sort (sparse (a)), sparse (sort (a)))
3536 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
3537 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
3538 %!test
3539 %! [v, i] = sort (a);
3540 %! [vs, is] = sort (sparse (a));
3541 %! assert (vs, sparse (v))
3542 %! assert (is, i)
3543
3544 %% Sparse Complex
3545 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf])), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
3546 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1i, 0, -1, 2, Inf]))
3547 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
3548 %!error (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 3))
3549 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
3550 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
3551 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0]))
3552 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0]))
3553
3554 %!shared a
3555 %! a = randn (10, 10);
3556 %! a (a < 0) = 0;
3557 %! a = 1i * a;
3558 %!assert (sort (sparse (a)), sparse (sort (a)))
3559 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
3560 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
3561 %!test
3562 %! [v, i] = sort (a);
3563 %! [vs, is] = sort (sparse (a));
3564 %! assert (vs, sparse (v))
3565 %! assert (is, i)
3566
3567 %% Sparse Bool
3568 %!assert (sort (sparse ([true, false, true, false])), sparse ([false, false, true, true]))
3569 %!assert (sort (sparse([true, false, true, false]), 1), sparse ([true, false, true, false]))
3570 %!assert (sort (sparse ([true, false, true, false]), 2), sparse ([false, false, true, true]))
3571 %!error (sort (sparse ([true, false, true, false], 3)))
3572 %!assert (sort (sparse ([true, false, true, false]), "ascend"), sparse([false, false, true, true]))
3573 %!assert (sort (sparse ([true, false, true, false]), 2, "ascend"), sparse([false, false, true, true]))
3574 %!assert (sort (sparse ([true, false, true, false]), "descend"), sparse ([true, true, false, false]))
3575 %!assert (sort (sparse ([true, false, true, false]), 2, "descend"), sparse([true, true, false, false]))
3576
3577 %!test
3578 %! [v, i] = sort (sparse([true, false, true, false]));
3579 %! assert (v, sparse([false, false, true, true]))
3580 %! assert (i, [2, 4, 1, 3])
3581
3582 %% Cell string array
3583 %!shared a, b, c
3584 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"};
3585 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"};
3586 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"};
3587 %!assert (sort (a), b);
3588 %!assert (sort (a, 1), a)
3589 %!assert (sort (a, 2), b)
3590 %!error (sort (a, 3))
3591 %!assert (sort (a, "ascend"), b)
3592 %!assert (sort (a, 2, "ascend"), b)
3593 %!assert (sort (a, "descend"), c)
3594 %!assert (sort (a, 2, "descend"), c)
3595
3596 %!test
3597 %! [v, i] = sort (a);
3598 %! assert (i, [1, 4, 2, 5, 3])
3599
3600 */
3601
3308 /* 3602 /*
3309 ;;; Local Variables: *** 3603 ;;; Local Variables: ***
3310 ;;; mode: C++ *** 3604 ;;; mode: C++ ***
3311 ;;; End: *** 3605 ;;; End: ***
3312 */ 3606 */