---
name: "Math::GSL::Sort"
section: "3pm"
platform: "linux"
package: "libmath-gsl-perl"
version: "0.45-2+b1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Math::GSL::Sort"
---

# Math::GSL::Sort(3pm)

Functions for sorting data

## NAME

Math::GSL::Sort - Functions for sorting data

## SYNOPSIS

```
    use Math::GSL::Sort qw/:all/;
    my $x       = [ 2**15, 1.67, 20e5, -17, 6900, 1/3 , 42e-10 ];
    my $sorted  = gsl_sort($x, 1, $#$x+1 );
    my $numbers = [ map { rand(100) } (1..100) ];
    my ($status, $smallest10) = gsl_sort_smallest($array, 10, $x, 1, $#$x+1);
```

## DESCRIPTION

- •

  gsl\_sort\_vector($v)

  This function sorts the elements of the vector `$v` into ascending numerical order.

- •

  gsl\_sort\_vector\_index($p, `$v`)

  This function indirectly sorts the elements of the vector `$v` into ascending order, storing the resulting permutation in `$p`. The elements of `$p` give the index of the vector element which would have been stored in that position if the vector had been sorted in place. The first element of `$p` gives the index of the least element in `$v`, and the last element of `$p` gives the index of the greatest element in `$v`. The vector `$v` is not changed.

- •

  gsl\_sort\_vector\_smallest($array, `$k`, `$vector`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the `$k` smallest elements of the vector `$v`. `$k` must be less than or equal to the length of the vector `$v`.

- •

  gsl\_sort\_vector\_smallest\_index($p, `$k`, `$v`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the indices of the `$k` smallest elements of the vector `$v`. `$p` must be a prealocated array reference. This should be removed in further versions. `$k` must be less than or equal to the length of the vector `$v`.

- •

  gsl\_sort\_vector\_largest($array, `$k`, `$vector`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the `$k` largest elements of the vector `$v`. `$k` must be less than or equal to the length of the vector `$v`.

- •

  gsl\_sort\_vector\_largest\_index($p, `$k`, `$v`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the indices of the `$k` largest elements of the vector `$v`. `$p` must be a prealocated array reference. This should be removed in further versions. `$k` must be less than or equal to the length of the vector `$v`.

- •

  gsl\_sort($data, `$stride`, `$n`)

  This function returns an array reference to the sorted `$n` elements of the array `$data` with stride `$stride` into ascending numerical order.

- •

  gsl\_sort\_index($p, `$data`, `$stride`, `$n`)

  This function indirectly sorts the `$n` elements of the array `$data` with stride `$stride` into ascending order, outputting the permutation in the foram of an array. `$p` must be a prealocated array reference. This should be removed in further versions. The array `$data` is not changed.

- •

  gsl\_sort\_smallest($array, `$k`, `$data`, `$stride`, `$n`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the `$k` smallest elements of the array `$data`, of size `$n` and stride `$stride`, in ascending numerical. The size `$k` of the subset must be less than or equal to `$n`. The data `$src` is not modified by this operation. `$array` must be a prealocated array reference. This should be removed in further versions.

- •

  gsl\_sort\_smallest\_index($p, `$k`, `$src`, `$stride`, `$n`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the indices of the `$k` smallest elements of the array `$src`, of size `$n` and stride `$stride`. The indices are chosen so that the corresponding data is in ascending numerical order. `$k` must be less than or equal to `$n`. The data `$src` is not modified by this operation. `$p` must be a prealocated array reference. This should be removed in further versions.

- •

  gsl\_sort\_largest($array, `$k`, `$data`, `$stride`, `$n`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the `$k` largest elements of the array `$data`, of size `$n` and stride `$stride`, in ascending numerical. The size `$k` of the subset must be less than or equal to `$n`. The data `$src` is not modified by this operation. `$array` must be a prealocated array reference. This should be removed in further versions.

- •

  gsl\_sort\_largest\_index($p, `$k`, `$src`, `$stride`, `$n`)

  This function outputs 0 if the operation succeeded, 1 otherwise and then the indices of the `$k` largest elements of the array `$src`, of size `$n` and stride `$stride`. The indices are chosen so that the corresponding data is in ascending numerical order. `$k` must be less than or equal to `$n`. The data `$src` is not modified by this operation. `$p` must be a prealocated array reference. This should be removed in further versions.

```
 Here is a complete list of all tags for this module :
```

- all

  - plain

  - vector

  For more information on the functions, we refer you to the GSL official documentation: \<http://www.gnu.org/software/gsl/manual/html\_node/\>

## PERFORMANCE

In the source code of Math::GSL, the file "examples/benchmark/sort" compares the performance of **gsl\_sort()** to Perl's builtin **sort()** function. Its first argument is the number of iterations and the second is the size of the array of numbers to sort. For example, to see a benchmark of 1000 iterations for arrays of size 50000 you would type

```
    ./examples/benchmark/sort 1000 50000
```

Initial benchmarks indicate just slightly above a 2x performance increase over **sort()** for arrays of between 5000 and 50000 elements. This may mostly be due to the fact that **gsl\_sort()** takes and returns a reference while **sort()** takes and returns a plain list.

## AUTHORS

Jonathan "Duke" Leto \<jonathan@leto.net\> and Thierry Moisan \<thierry.moisan@gmail.com\>

## COPYRIGHT AND LICENSE

Copyright (C) 2008-2024 Jonathan "Duke" Leto and Thierry Moisan

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.