### ----------------------------------------------------
### -- Math::Libgsl::Function
### -- Licenses: Artistic-2.0
### -- Authors: Fernando Santagata
### -- File: lib/Math/Libgsl/Function.rakumod
### ----------------------------------------------------
### -- Chunk 3 of 8
}
sub E1-e(Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_expint_E1_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub E2(Num(Cool) $x --> Num) is export(:expint) {
  gsl_sf_expint_E2($x);
}
sub E2-e(Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_expint_E2_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub En(Int $n, Num(Cool) $x --> Num) is export(:expint) {
  gsl_sf_expint_En($n, $x);
}
sub En-e(Int $n, Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_expint_En_e($n, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub Ei(Num(Cool) $x --> Num) is export(:expint) {
  gsl_sf_expint_Ei($x);
}
sub Ei-e(Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_expint_Ei_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub Shi(Num(Cool) $x --> Num) is export(:expint) {
  gsl_sf_Shi($x);
}
sub Shi-e(Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_Shi_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub Chi(Num(Cool) $x --> Num) is export(:expint) {
  gsl_sf_Chi($x);
}
sub Chi-e(Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_Chi_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub expint3(Num(Cool) $x where * ≥ 0 --> Num) is export(:expint) {
  gsl_sf_expint_3($x);
}
sub expint3-e(Num(Cool) $x where * ≥ 0 --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_expint_3_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub Si(Num(Cool) $x --> Num) is export(:expint) {
  gsl_sf_Si($x);
}
sub Si-e(Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_Si_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub Ci(Num(Cool) $x where * > 0 --> Num) is export(:expint) {
  gsl_sf_Ci($x);
}
sub Ci-e(Num(Cool) $x where * > 0 --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_Ci_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub atanint(Num(Cool) $x --> Num) is export(:expint) {
  gsl_sf_atanint($x);
}
sub atanint-e(Num(Cool) $x --> List) is export(:expint) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_atanint_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Complete Fermi-Dirac Integrals
sub fd-m1(Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_m1($x);
}
sub fd-m1-e(Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_m1_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub fd0(Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_0($x);
}
sub fd0-e(Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_0_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub fd1(Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_1($x);
}
sub fd1-e(Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_1_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub fd2(Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_2($x);
}
sub fd2-e(Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_2_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub fd-int(Int $j, Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_int($j, $x);
}
sub fd-int-e(Int $j, Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_int_e($j, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub fd-mhalf(Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_mhalf($x);
}
sub fd-mhalf-e(Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_mhalf_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub fd-half(Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_half($x);
}
sub fd-half-e(Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_half_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub fd-half3(Num(Cool) $x --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_3half($x);
}
sub fd-half3-e(Num(Cool) $x --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_3half_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Incomplete Fermi-Dirac Integrals
sub fd-inc0(Num(Cool) $x, Num(Cool) $b --> Num) is export(:fermidirac) {
  gsl_sf_fermi_dirac_inc_0($x.Num, $b);
}
sub fd-inc0-e(Num(Cool) $x, Num(Cool) $b --> List) is export(:fermidirac) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fermi_dirac_inc_0_e($x.Num, $b, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Gamma and Beta Functions
# Gamma Functions
sub gamma(Num(Cool) $x where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> Num) is export(:gammabeta) {
  gsl_sf_gamma($x);
}
sub gamma-e(Num(Cool) $x where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gamma_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lngamma(Num(Cool) $x where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> Num) is export(:gammabeta) {
  gsl_sf_lngamma($x);
}
sub lngamma-e(Num(Cool) $x where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_lngamma_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lngamma-sgn-e(Num(Cool) $x where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my num64 $sgn;
  my $ret = gsl_sf_lngamma_sgn_e($x, $res, $sgn);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err, $sgn;
}
sub gammastar(Num(Cool) $x where * > 0 --> Num) is export(:gammabeta) {
  gsl_sf_gammastar($x);
}
sub gammastar-e(Num(Cool) $x where * > 0 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gammastar_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub gammainv(Num(Cool) $x where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> Num) is export(:gammabeta) {
  gsl_sf_gammainv($x);
}
sub gammainv-e(Num(Cool) $x where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gammainv_e($x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lngamma-complex-e(Num(Cool) $zr where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) }, Num(Cool) $zi where { $_ > 0 || ($_ < 0 && $_ ≠ $_.Int) } --> List) is export(:gammabeta) {
  my gsl_sf_result $lnr .= new;
  my gsl_sf_result $arg .= new;
  my $ret = gsl_sf_lngamma_complex_e($zr.Num, $zi, $lnr, $arg);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $lnr.val, $lnr.err, $arg.val, $arg.err;
}
# Factorials
sub fact(UInt $n where * ≤ GSL_SF_FACT_NMAX --> Num) is export(:gammabeta) {
  gsl_sf_fact($n);
}
sub fact-e(UInt $n where * ≤ GSL_SF_FACT_NMAX --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_fact_e($n, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub doublefact(UInt $n where * ≤ GSL_SF_DOUBLEFACT_NMAX --> Num) is export(:gammabeta) {
  gsl_sf_doublefact($n);
}
sub doublefact-e(UInt $n where * ≤ GSL_SF_DOUBLEFACT_NMAX --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_doublefact_e($n, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lnfact(UInt $n --> Num) is export(:gammabeta) {
  gsl_sf_lnfact($n);
}
sub lnfact-e(UInt $n --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_lnfact_e($n, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lndoublefact(UInt $n --> Num) is export(:gammabeta) {
  gsl_sf_lndoublefact($n);
}
sub lndoublefact-e(UInt $n --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_lndoublefact_e($n, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub choose(UInt $n, UInt $m --> Num) is export(:gammabeta) {
  gsl_sf_choose($n, $m);
}
sub choose-e(UInt $n, UInt $m --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_choose_e($n, $m, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lnchoose(UInt $n, UInt $m --> Num) is export(:gammabeta) {
  gsl_sf_lnchoose($n, $m);
}
sub lnchoose-e(UInt $n, UInt $m --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_lnchoose_e($n, $m, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub taylorcoeff(UInt $n, Num(Cool) $x where * ≥ 0 --> Num) is export(:gammabeta) {
  gsl_sf_taylorcoeff($n, $x);
}
sub taylorcoeff-e(UInt $n, Num(Cool) $x where * ≥ 0 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_taylorcoeff_e($n, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Pochhammer Symbol
sub poch(Num(Cool) $a, Num(Cool) $x --> Num) is export(:gammabeta) {
  gsl_sf_poch($a.Num, $x);
}
sub poch-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_poch_e($a.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lnpoch(Num(Cool) $a, Num(Cool) $x --> Num) is export(:gammabeta) {
  gsl_sf_lnpoch($a.Num, $x);
}
sub lnpoch-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_lnpoch_e($a.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lnpoch-sgn-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my num64 $sgn;
  my $ret = gsl_sf_lnpoch_sgn_e($a.Num, $x, $res, $sgn);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err, $sgn;
}
sub pochrel(Num(Cool) $a, Num(Cool) $x --> Num) is export(:gammabeta) {
  gsl_sf_pochrel($a.Num, $x);
}
sub pochrel-e(Num(Cool) $a, Num(Cool) $x --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_pochrel_e($a.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Incomplete Gamma Functions
sub gamma-inc(Num(Cool) $a where * > 0, Num(Cool) $x where * ≥ 0 --> Num) is export(:gammabeta) {
  gsl_sf_gamma_inc($a.Num, $x);
}
sub gamma-inc-e(Num(Cool) $a, Num(Cool) $x where * ≥ 0 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gamma_inc_e($a.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub gamma-inc-Q(Num(Cool) $a where * > 0, Num(Cool) $x where * ≥ 0 --> Num) is export(:gammabeta) {
  gsl_sf_gamma_inc_Q($a.Num, $x);
}
sub gamma-inc-Q-e(Num(Cool) $a where * > 0, Num(Cool) $x where * ≥ 0 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gamma_inc_Q_e($a.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub gamma-inc-P(Num(Cool) $a where * > 0, Num(Cool) $x where * ≥ 0 --> Num) is export(:gammabeta) {
  gsl_sf_gamma_inc_P($a.Num, $x);
}
sub gamma-inc-P-e(Num(Cool) $a where * > 0, Num(Cool) $x where * ≥ 0 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gamma_inc_P_e($a.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Beta Functions
sub beta(Num(Cool) $a where * > 0, Num(Cool) $b where * > 0 --> Num) is export(:gammabeta) {
  gsl_sf_beta($a.Num, $b);
}
sub beta-e(Num(Cool) $a where * > 0, Num(Cool) $b where * > 0 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_beta_e($a.Num, $b, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub lnbeta(Num(Cool) $a where * > 0, Num(Cool) $b where * > 0 --> Num) is export(:gammabeta) {
  gsl_sf_lnbeta($a.Num, $b);
}
sub lnbeta-e(Num(Cool) $a where * > 0, Num(Cool) $b where * > 0 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_lnbeta_e($a.Num, $b, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Incomplete Beta Functions
sub beta-inc(Num(Cool) $a where * > 0, Num(Cool) $b where * > 0, Num(Cool) $x where 0 ≤ * ≤ 1 --> Num) is export(:gammabeta) {
  gsl_sf_beta_inc($a.Num, $b.Num, $x);
}
sub beta-inc-e(Num(Cool) $a where * > 0, Num(Cool) $b where * > 0, Num(Cool) $x where 0 ≤ * ≤ 1 --> List) is export(:gammabeta) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_beta_inc_e($a.Num, $b.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Gegenbauer Functions
sub gegenpoly1(Num(Cool) $lambda, Num(Cool) $x --> Num) is export(:gegen) {
  gsl_sf_gegenpoly_1($lambda.Num, $x);
}
sub gegenpoly1-e(Num(Cool) $lambda, Num(Cool) $x --> List) is export(:gegen) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gegenpoly_1_e($lambda.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub gegenpoly2(Num(Cool) $lambda, Num(Cool) $x --> Num) is export(:gegen) {
  gsl_sf_gegenpoly_2($lambda.Num, $x);
}
sub gegenpoly2-e(Num(Cool) $lambda, Num(Cool) $x --> List) is export(:gegen) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gegenpoly_2_e($lambda.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub gegenpoly3(Num(Cool) $lambda, Num(Cool) $x --> Num) is export(:gegen) {
  gsl_sf_gegenpoly_3($lambda.Num, $x);
}
sub gegenpoly3-e(Num(Cool) $lambda, Num(Cool) $x --> List) is export(:gegen) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gegenpoly_3_e($lambda.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub gegenpolyn(UInt $n, Num(Cool) $lambda where * > -½, Num(Cool) $x --> Num) is export(:gegen) {
  gsl_sf_gegenpoly_n($n, $lambda.Num, $x);
}
sub gegenpolyn-e(UInt $n, Num(Cool) $lambda where * > -½, Num(Cool) $x --> List) is export(:gegen) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_gegenpoly_n_e($n, $lambda.Num, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub gegenpoly-array(UInt $nmax, Num(Cool) $lambda where * > -½, Num(Cool) $x --> List) is export(:gegen) {
  my $out = CArray[num64].allocate: $nmax + 1;
  my $ret = gsl_sf_gegenpoly_array($nmax, $lambda.Num, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
# Hermite Polynomials and Functions
# Hermite Polynomials
sub hermite(Int $n, Num(Cool) $x --> Num) is export(:hermite) {
  gsl_sf_hermite_phys($n, $x);
}
sub hermite-e(Int $n, Num(Cool) $x --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_hermite_phys_e($n, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub hermite-array(Int $nmax, Num(Cool) $x --> List) is export(:hermite) {
  my $out = CArray[num64].allocate: $nmax + 1;
  my $ret = gsl_sf_hermite_phys_array($nmax, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
sub hermite-series(Int $n, Num(Cool) $x, *@a --> Num) is export(:hermite) {
  my CArray[num64] $a .= new: @a».Num;
  gsl_sf_hermite_phys_series($n, $x, $a);
}
sub hermite-series-e(Int $n, Num(Cool) $x, *@a --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my CArray[num64] $a .= new: @a».Num;
  my $ret = gsl_sf_hermite_phys_series_e($n, $x, $a, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub hermite-prob(Int $n, Num(Cool) $x --> Num) is export(:hermite) {
  gsl_sf_hermite_prob($n, $x);
}
sub hermite-prob-e(Int $n, Num(Cool) $x --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_hermite_prob_e($n, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub hermite-prob-array(Int $nmax, Num(Cool) $x --> List) is export(:hermite) {
  my $out = CArray[num64].allocate: $nmax + 1;
  my $ret = gsl_sf_hermite_prob_array($nmax, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
sub hermite-prob-series(Int $n, Num(Cool) $x, *@a --> Num) is export(:hermite) {
  my CArray[num64] $a .= new: @a».Num;
  gsl_sf_hermite_prob_series($n, $x, $a);
}
sub hermite-prob-series-e(Int $n, Num(Cool) $x, *@a --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my CArray[num64] $a .= new: @a».Num;
  my $ret = gsl_sf_hermite_prob_series_e($n, $x, $a, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Derivatives of Hermite Polynomials
sub hermite-der(Int $n, Int $m, Num(Cool) $x --> Num) is export(:hermite) {
  gsl_sf_hermite_phys_der($n, $m, $x);
}
sub hermite-der-e(Int $n, Int $m, Num(Cool) $x --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_hermite_phys_der_e($n, $m, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub hermite-array-der(Int $m, Int $nmax, Num(Cool) $x --> List) is export(:hermite) {
  my $out = CArray[num64].allocate: $nmax + 1;
  my $ret = gsl_sf_hermite_phys_array_der($m, $nmax, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
sub hermite-der-array(Int $mmax, Int $n, Num(Cool) $x --> List) is export(:hermite) {
  my $out = CArray[num64].allocate: $mmax + 1;
  my $ret = gsl_sf_hermite_phys_der_array($mmax, $n, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
sub hermite-prob-der(Int $m, Int $n, Num(Cool) $x --> Num) is export(:hermite) {
  gsl_sf_hermite_prob_der($m, $n, $x);
}
sub hermite-prob-der-e(Int $m, Int $n, Num(Cool) $x --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_hermite_prob_der_e($m, $n, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub hermite-prob-array-der(Int $m, Int $nmax, Num(Cool) $x --> List) is export(:hermite) {
  my $out = CArray[num64].allocate: $nmax + 1;
  my $ret = gsl_sf_hermite_prob_array_der($m, $nmax, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
sub hermite-prob-der-array(Int $mmax, Int $n, Num(Cool) $x --> List) is export(:hermite) {
  my $out = CArray[num64].allocate: $mmax + 1;
  my $ret = gsl_sf_hermite_prob_der_array($mmax, $n, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
# Hermite Functions
sub hermite-func(Int $n, Num(Cool) $x --> Num) is export(:hermite) {
  gsl_sf_hermite_func($n, $x);
}
sub hermite-func-e(Int $n, Num(Cool) $x --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my $ret = gsl_sf_hermite_func_e($n, $x, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
sub hermite-func-array(Int $nmax, Num(Cool) $x --> List) is export(:hermite) {
  my $out = CArray[num64].allocate: $nmax + 1;
  my $ret = gsl_sf_hermite_func_array($nmax, $x, $out);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $out.list;
}
sub hermite-func-series(Int $n, Num(Cool) $x, *@a --> Num) is export(:hermite) {
  my CArray[num64] $a .= new: @a».Num;
  gsl_sf_hermite_func_series($n, $x, $a);
}
sub hermite-func-series-e(Int $n, Num(Cool) $x, *@a --> List) is export(:hermite) {
  my gsl_sf_result $res .= new;
  my CArray[num64] $a .= new: @a».Num;
  my $ret = gsl_sf_hermite_func_series_e($n, $x, $a, $res);
  fail X::Libgsl.new: errno => $ret if $ret > 0;
  return $res.val, $res.err;
}
# Derivatives of Hermite Functions
sub hermite-func-der(Int $m, Int $n, Num(Cool) $x --> Num) is export(:hermite) {
  gsl_sf_hermite_func_der($m, $n, $x);
}
sub hermite-func-der-e(Int $m, Int $n, Num(Cool) $x --> List)