Image

head

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use v6.c;

unit class Math::Libgsl::Sort:ver<0.0.3>:auth<zef:FRITH>;

use Math::Libgsl::Raw::Sort :ALL;
use Math::Libgsl::Vector;
use Math::Libgsl::Permutation;
use NativeCall;

# Sorting vectors
sub num64sort(:@data, Int :$stride? = 1 --> List) is export {
  my CArray[num64] $d .= new: @data».Num;
  gsl_sort($d, $stride, ($d.list.elems / $stride).ceiling);
  $d.list
}

sub num64sort2(:@data1, Int :$stride1? = 1, :@data2, Int :$stride2? = 1 --> List) is export {
  my CArray[num64] $d1 .= new: @data1».Num;
  my CArray[num64] $d2 .= new: @data2».Num;
  gsl_sort2($d1, $stride1, $d2, $stride2, ($d1.list.elems / $stride1).ceiling);
  data1 => $d1.list, data2 => $d2.list
}

sub num64sort-index(:@data, Int :$stride? = 1 --> List) is export {
  my CArray[num64] $d .= new: @data».Num;
  my size_t $n = ($d.list.elems / $stride).ceiling;
  my $p = CArray[size_t].allocate($n);
  gsl_sort_index($p, $d, $stride, $n);
  $p.list
}

sub num64sort-vector(Math::Libgsl::Vector $v) is export {
  gsl_sort_vector($v.vector)
}

sub num64sort2-vector(Math::Libgsl::Vector $v1, Math::Libgsl::Vector $v2) is export {
  gsl_sort_vector2($v1.vector, $v2.vector)
}

sub num64sort-vector-index(Math::Libgsl::Vector $v, Math::Libgsl::Permutation $p where $v.vector.size == *.p.size) is export {
  gsl_sort_vector_index($p.p, $v.vector)
}

# Selecting the k smallest or largest elements
sub num64smallest(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List) is export {
  my CArray[num64] $src .= new: @data».Num;
  my $dst = CArray[num64].allocate: $k;
  gsl_sort_smallest($dst, $k, $src, $stride, ($src.list.elems / $stride).ceiling);
  $dst.list
}

sub num64largest(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List) is export {
  my CArray[num64] $src .= new: @data».Num;
  my $dst = CArray[num64].allocate: $k;
  gsl_sort_largest($dst, $k, $src, $stride, ($src.list.elems / $stride).ceiling);
  $dst.list
}

sub num64smallest-index(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List) is export {
  my CArray[num64] $src .= new: @data».Num;
  my $dst = CArray[size_t].allocate: $k;
  gsl_sort_smallest_index($dst, $k, $src, $stride, ($src.list.elems / $stride).ceiling);
  $dst.list
}

sub num64largest-index(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List) is export {
  my CArray[num64] $src .= new: @data».Num;
  my $dst = CArray[size_t].allocate: $k;
  gsl_sort_largest_index($dst, $k, $src, $stride, ($src.list.elems / $stride).ceiling);
  $dst.list
}

sub num64vector-smallest(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List) is export {
  my $dst = CArray[num64].allocate: $k;
  gsl_sort_vector_smallest($dst, $k, $v.vector);
  $dst.list
}

sub num64vector-largest(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List) is export {
  my $dst = CArray[num64].allocate: $k;
  gsl_sort_vector_largest($dst, $k, $v.vector);
  $dst.list
}

sub num64vector-smallest-index(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List) is export {
  my $dst = CArray[size_t].allocate: $k;
  gsl_sort_vector_smallest_index($dst, $k, $v.vector);
  $dst.list
}

sub num64vector-largest-index(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List) is export {
  my $dst = CArray[size_t].allocate: $k;
  gsl_sort_vector_largest_index($dst, $k, $v.vector);
  $dst.list
}



Math::Libgsl::Sort - An interface to libgsl, the Gnu Scientific Library - Sort.


=begin code :lang<raku>

use Math::Libgsl::Raw::Sort :ALL;

use Math::Libgsl::Sort;

=end code


Math::Libgsl::Sort provides an interface to the sort functions of libgsl, the GNU Scientific Library.


This package provides both the low-level interface to the C library (Raw) and a more comfortable interface layer for the Raku programmer.


This package comes with the Sort module tailored to all the real and integer types:


All the subs of each package have their name prefixed by the relative data type:


Math::Libgsl::Sort has a sub num64sort, while Math::Libgsl::Sort::Int8 has a sub int8sort, and so on.


num64sort(:@data, Int :$stride? = 1 --> List)


This sub takes two named arguments: the data array and the stride. The sub returns a List of values: the element of the original array sorted in ascending order.


=begin code
my @data = (10…0)».Num;
say @data; # output: [10 9 8 7 6 5 4 3 2 1 0]
my @out = num64sort(:@data, :stride(2)); # sort the elements of @data, with a stride of 2: 10, 8, 6, 4, 2
say @out;  # output: [0 9 2 7 4 5 6 3 8 1 10]
=end code


num64sort2(:@data1, Int :$stride1? = 1, :@data2, Int :$stride2? = 1 --> List)


This sub takes four named arguments: two data arrays and the relative strides. The sub returns a List of Pairs: 'data1' and the element of the first array taken with a stride $stride1, sorted in ascending order, and 'data2' and the elements of the second array taken with a stride $stride2, rearranged as the first array.


=begin code
my @data1 = (10…0)».Num;
my @data2 = (20…0)».Num;
say @data1; # output: [10 9 8 7 6 5 4 3 2 1 0]
say @data2; # output: [20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0]
my %out = num64sort2(:@data1, :stride1(2), :@data2, :stride2(3));
say %out<data1>; # output: (0 9 2 7 4 5 6 3 8 1 10)
say %out<data2>; # output: (5 19 18 8 16 15 11 13 12 14 10 9 17 7 6 20 4 3 2 1 0)
=end code


num64sort-index(:@data, Int :$stride? = 1 --> List)


This sub indirectly sorts the elements of the array with stride into ascending order, returning the resulting permutation.


num64sort-vector(Math::Libgsl::Vector $v)


This sub sorts in place the elements of the Math::Libgsl::Vector $v into ascending numerical order.


num64sort2-vector(Math::Libgsl::Vector $v1, Math::Libgsl::Vector $v2)


This sub sorts the elements of the Math::Libgsl::Vector $v1 into ascending numerical order, while making the same rearrangement of the vector $v2.


num64sort-vector-index(Math::Libgsl::Vector $v, Math::Libgsl::Permutation $p where $v.vector.size == $p.p.size)


This sub indirectly sorts the elements of the Math::Libgsl::Vector $v, storing the resulting permutation in $p.
The vector and the permutation must have the same number of elements.


num64smallest(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List)


This sub returns the $k smallest elements of the array, extracted with $stride, in ascending numerical order.


num64largest(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List)


This sub returns the $k largest elements of the array, extracted with $stride, in ascending numerical order.


num64smallest-index(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List)


This sub returns the indices of the $k smallest elements of the array, extracted with $stride, in ascending numerical order.


num64largest-index(:@data, Int :$stride? = 1, Int :$k? where * ≤ (@data.elems / $stride).ceiling = @data.elems --> List)


This sub returns the indices of the $k largest elements of the array, extracted with $stride, in ascending numerical order.


num64vector-smallest(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List)


This sub returns the $k smallest elements of the vector, extracted with $stride, in ascending numerical order.


num64vector-largest(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List)


This sub returns the $k largest elements of the vector, extracted with $stride, in ascending numerical order.


num64vector-smallest-index(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List)


This sub returns the indices of the $k largest elements of the vector, extracted with $stride, in ascending numerical order.


num64vector-largest-index(Math::Libgsl::Vector $v, Int $k? where * < $v.vector.size = $v.vector.size --> List)


For more details on libgsl see L<https://www.gnu.org/software/gsl/>.
The excellent C Library manual is available here L<https://www.gnu.org/software/gsl/doc/html/index.html>, or here L<https://www.gnu.org/software/gsl/doc/latex/gsl-ref.pdf> in PDF format.


This module requires the libgsl library to be installed. Please follow the instructions below based on your platform:


=begin code
sudo apt install libgsl23 libgsl-dev libgslcblas0
=end code


That command will install libgslcblas0 as well, since it's used by the GSL.


Sort

unit class Math::Libgsl::Series:ver<0.0.1>:auth<zef:FRITH>;

use NativeCall;
use Math::Libgsl::Constants;
use Math::Libgsl::Exception;
use Math::Libgsl::Raw::Series;

has gsl_sum_levin_u_workspace       $.w;
has gsl_sum_levin_utrunc_workspace  $.wt;
has Bool                            $.truncation;
has UInt                            $.size;

# Workspace allocation
multi method new(UInt:D() $size!,  Bool  $truncation? = False) { self.bless(:$size, :$truncation) }
multi method new(UInt:D() :$size!, Bool :$truncation? = False) { self.bless(:$size, :$truncation) }
submethod BUILD(UInt:D :$!size, Bool :$!truncation) {
  if $!truncation {
    $!wt = gsl_sum_levin_utrunc_alloc($!size);
  } else {
    $!w  = gsl_sum_levin_u_alloc($!size);
  }
}

submethod DESTROY {
  if $!truncation {
    gsl_sum_levin_utrunc_free($!wt);
  } else {
    gsl_sum_levin_u_free($!w);
  }
}

method levin-accel(*@array where *.all > 0 --> List){
  my CArray[num64] $carray .= new: @array».Num;
  my num64 ($sum-accel, $abserr);
  my int32 $ret;
  my $terms-used;
  if $!truncation {
    $ret = gsl_sum_levin_utrunc_accel($carray, $!size, $!wt, $sum-accel, $abserr);
    $terms-used = $!wt.terms_used;
  } else {
    $ret = gsl_sum_levin_u_accel($carray, $!size, $!w, $sum-accel, $abserr);
    $terms-used = $!w.terms_used;
  }
  fail X::Libgsl.new: errno => $ret, error => "Can't compute series" if $ret ≠ GSL_SUCCESS;
  return $sum-accel, $abserr, $terms-used;
}



Math::Libgsl::Series - An interface to libgsl, the Gnu Scientific Library - Series Acceleration


=begin code :lang<raku>

use Math::Libgsl::Series;

=end code


=begin code :lang<raku>

use Math::Libgsl::Series;

my Math::Libgsl::Series $s .= new: N;
constant \N = 20;
my @array := Array[Num].new;
(^N).map: -> $n { my $np1 = $n + 1e0; @array[$n] = 1e0 / ($np1 * $np1) }
my ($sum, $err) = $s.levin-accel: @array;
say "The series' sum is $sum, with an estimated error $err";

=end code


Math::Libgsl::Series is an interface to the Series Acceleration functions of libgsl, the Gnu Scientific Library.


new(UInt:D() $size!,  Bool  $truncation? = False)


new(UInt:D() :$size!, Bool :$truncation? = False)


The constructor accepts one or optionally two simple or named arguments: the mandatory series size and the optional
error estimation type.
This last argoment may have two values: propagation of rounding error or truncation error in the estrapolation.
If the B<Bool :$truncation> parameter is B<True> then the error is estimated by means of the truncation error in
the estrapolation.
If the B<Bool :$truncation> parameter is B<False> then the error is estimated by means of the propagation of rounding
errors.


levin-accel(*@array where *.all > 0 --> List)


This method computes the extrapolated limit of the series using a Levin u-transform.
It returns a B<List>: the extrapolated B<$sum>, the estimated B<$error>, and the number of B<$terms-used> during the
computation.


libgsl23 and libgslcblas0 have a missing symbol on Ubuntu 18.04.
I solved the issue installing the Debian Buster version of those three libraries:


To install it using zef (a module management tool):


=begin code
$ zef install Math::Libgsl::Series
=end code


Fernando Santagata <nando.santagata@gmail.com>


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


Series

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

SYNOPSIS

DESCRIPTION

new(UInt:D() truncation? = False)

new(UInt:D() :truncation? = False)

levin-accel(_@array where _.all > 0 --> List)

C Library Documentation

Prerequisites

Debian Linux and Ubuntu 20.04+

Ubuntu 18.04

Installation

AUTHOR

COPYRIGHT AND LICENSE

Math::Libgsl::Series v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation