From: Jürg Billeter Date: Thu, 25 Sep 2008 09:16:32 +0000 (+0000) Subject: Add GSL bindings, patch by Matías De la Puente X-Git-Tag: VALA_0_4_0~83 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=684ee40272c5cdf995f01e02f6b010fa0251599b;p=thirdparty%2Fvala.git Add GSL bindings, patch by Matías De la Puente 2008-09-25 Jürg Billeter * vapi/Makefile.am: * vapi/gsl.vapi: Add GSL bindings, patch by Matías De la Puente svn path=/trunk/; revision=1778 --- diff --git a/ChangeLog b/ChangeLog index a48c9abc8..dfa725351 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,10 @@ +2008-09-25 Jürg Billeter + + * vapi/Makefile.am: + * vapi/gsl.vapi: + + Add GSL bindings, patch by Matías De la Puente + 2008-09-16 Jürg Billeter * vapi/glib-2.0.vapi: diff --git a/vapi/Makefile.am b/vapi/Makefile.am index d75cb46a3..bb6d72fc0 100644 --- a/vapi/Makefile.am +++ b/vapi/Makefile.am @@ -33,6 +33,7 @@ dist_vapi_DATA = \ gnome-vfs-2.0.vapi \ goocanvas.deps \ goocanvas.vapi \ + gsl.vapi \ gstreamer-0.10.deps \ gstreamer-0.10.vapi \ gstreamer-audio-0.10.deps \ diff --git a/vapi/gsl.vapi b/vapi/gsl.vapi new file mode 100644 index 000000000..ec1557166 --- /dev/null +++ b/vapi/gsl.vapi @@ -0,0 +1,4594 @@ +/* gsl.vapi + * + * Copyright (C) 2008 Matias De la Puente + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: + * Matias De la Puente + */ + +namespace Gsl +{ + /* + * Physical Constants + */ + [CCode (cprefix="GSL_CONST_NUM_", cheader_filename="gsl/gsl_const_num.h")] + public enum ConstNum + { + FINE_STRUCTURE, + AVOGADRO, + YOTTA, + ZETTA, + EXA, + PETA, + TERA, + GIGA, + MEGA, + KILO, + MILLI, + MICRO, + NANO, + PICO, + FEMTO, + ATTO, + ZEPTO, + YOCTO + } + + [CCode (cprefix="GSL_CONST_CGS_", cheader_filename="gsl/gsl_const_cgs.h")] + public enum ConstCGS + { + SPEED_OF_LIGHT, + GRAVITATIONAL_CONSTANT, + PLANCKS_CONSTANT_H, + PLANCKS_CONSTANT_HBAR, + ASTRONOMICAL_UNIT, + LIGHT_YEAR, + PARSEC, + GRAV_ACCEL, + ELECTRON_VOLT, + MASS_ELECTRON, + MASS_MUON, + MASS_PROTON, + MASS_NEUTRON, + RYDBERG, + BOLTZMANN, + BOHR_MAGNETON, + NUCLEAR_MAGNETON, + ELECTRON_MAGNETIC_MOMENT, + PROTON_MAGNETIC_MOMENT, + MOLAR_GAS, + STANDARD_GAS_VOLUME, + MINUTE, + HOUR, + DAY, + WEEK, + INCH, + FOOT, + YARD, + MILE, + NAUTICAL_MILE, + FATHOM, + MIL, + POINT, + TEXPOINT, + MICRON, + ANGSTROM, + HECTARE, + ACRE, + BARN, + LITER, + US_GALLON, + QUART, + PINT, + CUP, + FLUID_OUNCE, + TABLESPOON, + TEASPOON, + CANADIAN_GALLON, + UK_GALLON, + MILES_PER_HOUR, + KILOMETERS_PER_HOUR, + KNOT, + POUND_MASS, + OUNCE_MASS, + TON, + METRIC_TON, + UK_TON, + TROY_OUNCE, + CARAT, + UNIFIED_ATOMIC_MASS, + GRAM_FORCE, + POUND_FORCE, + KILOPOUND_FORCE, + POUNDAL, + CALORIE, + BTU, + THERM, + HORSEPOWER, + BAR, + STD_ATMOSPHERE, + TORR, + METER_OF_MERCURY, + INCH_OF_MERCURY, + INCH_OF_WATER, + PSI, + POISE, + STOKES, + FARADAY, + ELECTRON_CHARGE, + GAUSS, + STILB, + LUMEN, + LUX, + PHOT, + FOOTCANDLE, + LAMBERT, + FOOTLAMBERT, + CURIE, + ROENTGEN, + RAD, + SOLAR_MASS, + BOHR_RADIUS, + NEWTON, + DYNE, + JOULE, + ERG, + STEFAN_BOLTZMANN_CONSTANT, + THOMSON_CROSS_SECTION + } + + [CCode (cprefix="GSL_CONST_CGSM_", cheader_filename="gsl/gsl_const_cgsm.h")] + public enum ConstCGSM + { + SPEED_OF_LIGHT, + GRAVITATIONAL_CONSTANT, + PLANCKS_CONSTANT_H, + PLANCKS_CONSTANT_HBAR, + ASTRONOMICAL_UNIT, + LIGHT_YEAR, + PARSEC, + GRAV_ACCEL, + ELECTRON_VOLT, + MASS_ELECTRON, + MASS_MUON, + MASS_PROTON, + MASS_NEUTRON, + RYDBERG, + BOLTZMANN, + BOHR_MAGNETON, + NUCLEAR_MAGNETON, + ELECTRON_MAGNETIC_MOMENT, + PROTON_MAGNETIC_MOMENT, + MOLAR_GAS, + STANDARD_GAS_VOLUME, + MINUTE, + HOUR, + DAY, + WEEK, + INCH, + FOOT, + YARD, + MILE, + NAUTICAL_MILE, + FATHOM, + MIL, + POINT, + TEXPOINT, + MICRON, + ANGSTROM, + HECTARE, + ACRE, + BARN, + LITER, + US_GALLON, + QUART, + PINT, + CUP, + FLUID_OUNCE, + TABLESPOON, + TEASPOON, + CANADIAN_GALLON, + UK_GALLON, + MILES_PER_HOUR, + KILOMETERS_PER_HOUR, + KNOT, + POUND_MASS, + OUNCE_MASS, + TON, + METRIC_TON, + UK_TON, + TROY_OUNCE, + CARAT, + UNIFIED_ATOMIC_MASS, + GRAM_FORCE, + POUND_FORCE, + KILOPOUND_FORCE, + POUNDAL, + CALORIE, + BTU, + THERM, + HORSEPOWER, + BAR, + STD_ATMOSPHERE, + TORR, + METER_OF_MERCURY, + INCH_OF_MERCURY, + INCH_OF_WATER, + PSI, + POISE, + STOKES, + FARADAY, + ELECTRON_CHARGE, + GAUSS, + STILB, + LUMEN, + LUX, + PHOT, + FOOTCANDLE, + LAMBERT, + FOOTLAMBERT, + CURIE, + ROENTGEN, + RAD, + SOLAR_MASS, + BOHR_RADIUS, + NEWTON, + DYNE, + JOULE, + ERG, + STEFAN_BOLTZMANN_CONSTANT, + THOMSON_CROSS_SECTION + } + + [CCode (cprefix="GSL_CONST_MKS_", cheader_filename="gsl/gsl_const_mks.h")] + public enum ConstMKS + { + SPEED_OF_LIGHT, + GRAVITATIONAL_CONSTANT, + PLANCKS_CONSTANT_H, + PLANCKS_CONSTANT_HBAR, + ASTRONOMICAL_UNIT, + LIGHT_YEAR, + PARSEC, + GRAV_ACCEL, + ELECTRON_VOLT, + MASS_ELECTRON, + MASS_MUON, + MASS_PROTON, + MASS_NEUTRON, + RYDBERG, + BOLTZMANN, + BOHR_MAGNETON, + NUCLEAR_MAGNETON, + ELECTRON_MAGNETIC_MOMENT, + PROTON_MAGNETIC_MOMENT, + MOLAR_GAS, + STANDARD_GAS_VOLUME, + MINUTE, + HOUR, + DAY, + WEEK, + INCH, + FOOT, + YARD, + MILE, + NAUTICAL_MILE, + FATHOM, + MIL, + POINT, + TEXPOINT, + MICRON, + ANGSTROM, + HECTARE, + ACRE, + BARN, + LITER, + US_GALLON, + QUART, + PINT, + CUP, + FLUID_OUNCE, + TABLESPOON, + TEASPOON, + CANADIAN_GALLON, + UK_GALLON, + MILES_PER_HOUR, + KILOMETERS_PER_HOUR, + KNOT, + POUND_MASS, + OUNCE_MASS, + TON, + METRIC_TON, + UK_TON, + TROY_OUNCE, + CARAT, + UNIFIED_ATOMIC_MASS, + GRAM_FORCE, + POUND_FORCE, + KILOPOUND_FORCE, + POUNDAL, + CALORIE, + BTU, + THERM, + HORSEPOWER, + BAR, + STD_ATMOSPHERE, + TORR, + METER_OF_MERCURY, + INCH_OF_MERCURY, + INCH_OF_WATER, + PSI, + POISE, + STOKES, + FARADAY, + ELECTRON_CHARGE, + GAUSS, + STILB, + LUMEN, + LUX, + PHOT, + FOOTCANDLE, + LAMBERT, + FOOTLAMBERT, + CURIE, + ROENTGEN, + RAD, + SOLAR_MASS, + BOHR_RADIUS, + NEWTON, + DYNE, + JOULE, + ERG, + STEFAN_BOLTZMANN_CONSTANT, + THOMSON_CROSS_SECTION, + VACUUM_PERMITTIVITY, + VACUUM_PERMEABILITY, + DEBYE + } + + [CCode (cprefix="GSL_CONST_MKSA_", cheader_filename="gsl/gsl_const_mksa.h")] + public enum ConstMKSA + { + SPEED_OF_LIGHT, + GRAVITATIONAL_CONSTANT, + PLANCKS_CONSTANT_H, + PLANCKS_CONSTANT_HBAR, + ASTRONOMICAL_UNIT, + LIGHT_YEAR, + PARSEC, + GRAV_ACCEL, + ELECTRON_VOLT, + MASS_ELECTRON, + MASS_MUON, + MASS_PROTON, + MASS_NEUTRON, + RYDBERG, + BOLTZMANN, + BOHR_MAGNETON, + NUCLEAR_MAGNETON, + ELECTRON_MAGNETIC_MOMENT, + PROTON_MAGNETIC_MOMENT, + MOLAR_GAS, + STANDARD_GAS_VOLUME, + MINUTE, + HOUR, + DAY, + WEEK, + INCH, + FOOT, + YARD, + MILE, + NAUTICAL_MILE, + FATHOM, + MIL, + POINT, + TEXPOINT, + MICRON, + ANGSTROM, + HECTARE, + ACRE, + BARN, + LITER, + US_GALLON, + QUART, + PINT, + CUP, + FLUID_OUNCE, + TABLESPOON, + TEASPOON, + CANADIAN_GALLON, + UK_GALLON, + MILES_PER_HOUR, + KILOMETERS_PER_HOUR, + KNOT, + POUND_MASS, + OUNCE_MASS, + TON, + METRIC_TON, + UK_TON, + TROY_OUNCE, + CARAT, + UNIFIED_ATOMIC_MASS, + GRAM_FORCE, + POUND_FORCE, + KILOPOUND_FORCE, + POUNDAL, + CALORIE, + BTU, + THERM, + HORSEPOWER, + BAR, + STD_ATMOSPHERE, + TORR, + METER_OF_MERCURY, + INCH_OF_MERCURY, + INCH_OF_WATER, + PSI, + POISE, + STOKES, + FARADAY, + ELECTRON_CHARGE, + GAUSS, + STILB, + LUMEN, + LUX, + PHOT, + FOOTCANDLE, + LAMBERT, + FOOTLAMBERT, + CURIE, + ROENTGEN, + RAD, + SOLAR_MASS, + BOHR_RADIUS, + NEWTON, + DYNE, + JOULE, + ERG, + STEFAN_BOLTZMANN_CONSTANT, + THOMSON_CROSS_SECTION, + VACUUM_PERMITTIVITY, + VACUUM_PERMEABILITY, + DEBYE + } + + + /* + * Error Handling + */ + [CCode (cprefix="GSL_", cheader_filename="gsl/gsl_errno.h")] + public enum Status + { + SUCCESS, + FAILURE, + CONTINUE, + EDOM, + ERANGE, + EFAULT, + EINVAL, + EFAILED, + EFACTOR, + ESANITY, + ENOMEM, + EBADFUNC, + ERUNAWAY, + EMAXITER, + EZERODIV, + EBADTOL, + ETOL, + EUNDRFLW, + EOVRFLW, + ELOSS, + EROUND, + EBADLEN, + ENOTSQR, + ESING, + EDIVERGE, + EUNSUP, + EUNIMPL, + ECACHE, + ETABLE, + ENOPROG, + ENOPROGJ, + ETOLF, + ETOLX, + ETOLG, + EOF + } + + [CCode (cprefix="GSL_PREC_", cheader_filename="gsl/gsl_mode.h")] + public enum Mode + { + DOUBLE, + SINGLE, + APPROX + } + + public static delegate void ErrorHandler (string reason, string file, int line, int errno); + public static delegate void StreamHandler (string label, string file, int line, string reason); + + [CCode (lower_case_cprefix="gsl_", cheader_filename="gsl/gsl_errno.h")] + namespace Error + { + public static void error (string reason, string file, int line, int errno); + public static weak string strerror (int errno); + public static ErrorHandler set_error_handler (ErrorHandler new_handler); + public static ErrorHandler set_error_handler_off (); + } + + [CCode (lower_case_cprefix="gsl_", cheader_filename="gsl/gsl_errno.h")] + namespace Stream + { + [CCode (cname="gsl_stream_printf")] + public static void printf (string label, string file, int line, string reason); + public static StreamHandler set_stream_handler (StreamHandler new_handler); + public static GLib.FileStream set_stream (GLib.FileStream new_stream); + } + + + /* + * Mathematical Functions + */ + [CCode (cprefix="", cheader_filename="gsl/gsl_math.h")] + public enum MathConst + { + M_E, + M_LOG2E, + M_LOG10E, + M_SQRT2, + M_SQRT1_2, + M_SQRT3, + M_PI, + M_PI_2, + M_PI_4, + M_2_SQRTPI, + M_1_PI, + M_2_PI, + M_LN10, + M_LN2, + M_LNPI, + M_EULER + } + + /* The isnan, isinf and finite are define in the double type. The elementary functions are in GLib.Math */ + + static delegate double _Function (double x, void* params); + static delegate void _FunctionFdf (double x, void* params, out double f, out double df); + + [SimpleType] + [CCode (cname="gsl_function", cheader_filename="gsl/gsl_math.h")] + public struct Function + { + public _Function function; + public void* params; + } + + [SimpleType] + [CCode (cname="gsl_function_fdf", cheader_filename="gsl/gsl_math.h")] + public struct FunctionFdf + { + public _Function f; + public _Function df; + public _FunctionFdf fdf; + public void* params; + } + + + /* + * Complex Numbers + */ + [SimpleType] + [CCode (cname="gsl_complex", cheader_filename="gsl/gsl_complex.h,gsl/gsl_complex_math.h")] + public struct Complex + { + [CCode (cname="dat[0]")] + public double real; + [CCode (cname="dat[1]")] + public double imag; + public static Complex rect (double x, double y); + public static Complex polar (double r, double theta); + + public static double arg (Complex z); + public static double abs (Complex z); + public static double abs2 (Complex z); + public static double logabs (Complex z); + + public static Complex add (Complex a, Complex b); + public static Complex sub (Complex a, Complex b); + public static Complex mul (Complex a, Complex b); + public static Complex div (Complex a, Complex b); + public static Complex add_real (Complex a, double x); + public static Complex sub_real (Complex a, double x); + public static Complex mul_real (Complex a, double x); + public static Complex div_real (Complex a, double x); + public static Complex add_imag (Complex a, double y); + public static Complex sub_imag (Complex a, double y); + public static Complex mul_imag (Complex a, double y); + public static Complex div_imag (Complex a, double y); + public static Complex conjugate (Complex z); + public static Complex inverse (Complex z); + public static Complex negative (Complex z); + + public static Complex sqrt (Complex z); + public static Complex sqrt_real (double x); + public static Complex pow (Complex z, Complex a); + public static Complex pow_real (Complex z, double x); + public static Complex exp (Complex z); + public static Complex log (Complex z); + public static Complex log10 (Complex z); + public static Complex log_b (Complex z, Complex b); + + public static Complex sin (Complex z); + public static Complex cos (Complex z); + public static Complex tan (Complex z); + public static Complex sec (Complex z); + public static Complex csc (Complex z); + public static Complex cot (Complex z); + + public static Complex arcsin (Complex z); + public static Complex arcsin_real (double z); + public static Complex arccos (Complex z); + public static Complex arccos_real (double z); + public static Complex arctan (Complex z); + public static Complex arcsec (Complex z); + public static Complex arcsec_real (double z); + public static Complex arccsc (Complex z); + public static Complex arccsc_real (double z); + public static Complex arccot (Complex z); + + public static Complex sinh (Complex z); + public static Complex cosh (Complex z); + public static Complex tanh (Complex z); + public static Complex sech (Complex z); + public static Complex csch (Complex z); + public static Complex coth (Complex z); + + public static Complex arcsinh (Complex z); + public static Complex arccosh (Complex z); + public static Complex arccosh_real (double z); + public static Complex arctanh (Complex z); + public static Complex arctanh_real (double z); + public static Complex arcsech (Complex z); + public static Complex arccsch (Complex z); + public static Complex arccoth (Complex z); + } + + + /* + * Polynomials + */ + [CCode (lower_case_cprefix="gsl_poly_", cheader_filename="gsl/gsl_poly.h")] + namespace Poly + { + public static double eval (double[] c, double x); + public static Complex complex_eval (double[] c, Complex z); + [CCode (cname="gsl_complex_poly_complex_eval")] + public static Complex poly_complex_eval (Complex[] c, Complex z); + + [NoArrayLength] + public static int dd_init (double[] dd, double[] xa, double[] ya, size_t size); + [NoArrayLength] + public static double dd_eval (double[] dd, double[] xa, size_t size, double x); + [NoArrayLength] + public static int dd_taylor (double[] c, double xp, double[] dd, double[] xa, size_t size, double[] w); + + public static int solve_quadratic (double a, double b, double c, out double x0, out double x1); + public static int complex_solve_quadratic (double a, double b, double c, out Complex z0, out Complex z1); + + public static int solve_cubic (double a, double b, double c, out double x0, out double x1, out double x2); + public static int complex_solve_cubic (double a, double b, double c, out Complex z0, out Complex z1, out Complex z2); + } + + [Compact] + [CCode (cname="gsl_poly_complex_workspace", cheader_filename="gsl/gsl_poly.h")] + public class PolyComplexWorkspace + { + public size_t nc; + public double* matrix; + + [CCode (cname="gsl_poly_complex_workspace_alloc")] + public PolyComplexWorkspace (size_t n); + [CCode (cname="gsl_poly_complex_solve")] + public static int solve (double[]a, PolyComplexWorkspace w, out double z); + } + + + /* + * Special Functions + */ + [SimpleType] + [CCode (cname="gsl_sf_result", cheader_filename="gsl/gsl_sf_result.h")] + public struct Result + { + public double val; + public double err; + } + + [SimpleType] + [CCode (cname="gsl_sf_result_e10", cheader_filename="gsl/gsl_sf_result.h")] + public struct ResultE10 + { + public double val; + public double err; + public int e10; + } + + [CCode (lower_case_cprefix="gsl_sf_airy_", cheader_filename="gsl/gsl_sf_airy.h")] + namespace Airy + { + public static double Ai (double x, Mode mode); + public static int Ai_e (double x, Mode mode, out Result result); + public static double Bi (double x, Mode mode); + public static int Bi_e (double x, Mode mode, out Result result); + public static double Ai_scaled (double x, Mode mode); + public static int Ai_scaled_e (double x, Mode mode, out Result result); + public static double Bi_scaled (double x, Mode mode); + public static int Bi_scaled_e (double x, Mode mode, out Result result); + + public static double Ai_deriv (double x, Mode mode); + public static int Ai_deriv_e (double x, Mode mode, out Result result); + public static double Bi_deriv (double x, Mode mode); + public static int Bi_deriv_e (double x, Mode mode, out Result result); + public static double Ai_deriv_scaled (double x, Mode mode); + public static int Ai_deriv_scaled_e (double x, Mode mode, out Result result); + public static double Bi_deriv_scaled (double x, Mode mode); + public static int Bi_deriv_scaled_e (double x, Mode mode, out Result result); + + public static double zero_Ai (uint s); + public static int zero_Ai_e (uint s, out Result result); + public static double zero_Bi (uint s); + public static int zero_Bi_e (uint s, out Result result); + + public static double zero_Ai_deriv (uint s); + public static int zero_Ai_deriv_e (uint s, out Result result); + public static double zero_Bi_deriv (uint s); + public static int zero_Bi_deriv_e (uint s, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_bessel_", cheader_filename="gsl/gsl_sf_bessel.h")] + namespace Bessel + { + public static double J0 (double x); + public static int J0_e (double x, out Result result); + public static double J1 (double x); + public static int J1_e (double x, out Result result); + public static double Jn (int n, double x); + public static int Jn_e (int n, double x, out Result result); + [NoArrayLength] + public static int Jn_array (int nmin, int nmax, double x, double[] result_array); + + public static double Y0 (double x); + public static int Y0_e (double x, out Result result); + public static double Y1 (double x); + public static int Y1_e (double x, out Result result); + public static double Yn (int n, double x); + public static int Yn_e (int n, double x, out Result result); + [NoArrayLength] + public static int Yn_array (int nmin, int nmax, double x, double[] result_array); + + public static double I0 (double x); + public static int I0_e (double x, out Result result); + public static double I1 (double x); + public static int I1_e (double x, out Result result); + public static double In (int n, double x); + public static int In_e (int n, double x, out Result result); + [NoArrayLength] + public static int In_array (int nmin, int nmax, double x, double[] result_array); + public static double I0_scaled (double x); + public static int I0_scaled_e (double x, out Result result); + public static double I1_scaled (double x); + public static int I1_scaled_e (double x, out Result result); + public static double In_scaled (int n, double x); + public static int In_scaled_e (int n, double x, out Result result); + [NoArrayLength] + public static int In_scaled_array (int nmin, int nmax, double x, double[] result_array); + + public static double K0 (double x); + public static int K0_e (double x, out Result result); + public static double K1 (double x); + public static int K1_e (double x, out Result result); + public static double Kn (int n, double x); + public static int Kn_e (int n, double x, out Result result); + [NoArrayLength] + public static int Kn_array (int nmin, int nmax, double x, double[] result_array); + public static double K0_scaled (double x); + public static int K0_scaled_e (double x, out Result result); + public static double K1_scaled (double x); + public static int K1_scaled_e (double x, out Result result); + public static double Kn_scaled (int n, double x); + public static int Kn_scaled_e (int n, double x, out Result result); + [NoArrayLength] + public static int Kn_scaled_array (int nmin, int nmax, double x, double[] result_array); + + public static double j0 (double x); + public static int j0_e (double x, out Result result); + public static double j1 (double x); + public static int j1_e (double x, out Result result); + public static double j2 (double x); + public static int j2_e (double x, out Result result); + public static double jl (int l, double x); + public static int jl_e (int l, double x, out Result result); + [NoArrayLength] + public static int jl_array (int lmax, double x, double[] result_array); + [NoArrayLength] + public static int jl_steed_array (int lmax, double x, double[] jl_x_array); + + public static double y0 (double x); + public static int y0_e (double x, out Result result); + public static double y1 (double x); + public static int y1_e (double x, out Result result); + public static double y2 (double x); + public static int y2_e (double x, out Result result); + public static double yl (int l, double x); + public static int yl_e (int l, double x, out Result result); + [NoArrayLength] + public static int yl_array (int lmax, double x, double[] result_array); + + public static double i0_scaled (double x); + public static int i0_scaled_e (double x, out Result result); + public static double i1_scaled (double x); + public static int i1_scaled_e (double x, out Result result); + public static double i2_scaled (double x); + public static int i2_scaled_e (double x, out Result result); + public static double il_scaled (int l, double x); + public static int il_scaled_e (int l, double x, out Result result); + [NoArrayLength] + public static int il_scaled_array (int lmax, double x, double[] result_array); + + public static double k0_scaled (double x); + public static int k0_scaled_e (double x, out Result result); + public static double k1_scaled (double x); + public static int k1_scaled_e (double x, out Result result); + public static double k2_scaled (double x); + public static int k2_scaled_e (double x, out Result result); + public static double kl_scaled (int l, double x); + public static int kl_scaled_e (int l, double x, out Result result); + [NoArrayLength] + public static int kl_scaled_array (int lmax, double x, double[] result_array); + + public static double Jnu (double nu, double x); + public static int Jnu_e (double nu, double x, out Result result); + [NoArrayLength] + public static int sequence_Jnu_e (double nu, Mode mode, size_t size, double[] v); + + public static double Ynu (double nu, double x); + public static int Ynu_e (double nu, double x, out Result result); + + public static double Inu (double nu, double x); + public static int Inu_e (double nu, double x, out Result result); + public static double Inu_scaled (double nu, double x); + public static int Inu_scaled_e (double nu, double x, out Result result); + + public static double Knu (double nu, double x); + public static int Knu_e (double nu, double x, out Result result); + public static double lnKnu (double nu, double x); + public static int lnKnu_e (double nu, double x, out Result result); + public static double Knu_scaled (double nu, double x); + public static int Knu_scaled_e (double nu, double x, out Result result); + + public static double zero_J0 (uint s); + public static int zero_J0_e (uint s, out Result result); + public static double zero_J1 (uint s); + public static int zero_J1_e (uint s, out Result result); + public static double zero_Jnu (double nu, uint s); + public static int zero_Jnu_e (double nu, uint s, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_clausen.h")] + namespace Clausen + { + public static double clausen (double x); + public static int clausen_e (double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_coulomb.h")] + namespace Hydrogenic + { + public static double hydrogenicR_1 (double z, double r); + public static int hydrogenicR_1_e (double z, double r, out Result result); + public static double hydrogenicR (int n, int l, double z, double r); + public static int hydrogenicR_e (int n, int l, double z, double r, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_coulomb_wave_", cheader_filename="gsl/gsl_sf_coulomb.h")] + namespace CoulombWave + { + public static int FG_e (double eta, double x, double l_f, int k, out Result f, out Result fp, out Result g, out Result gp, out double exp_f, out double exp_g); + [NoArrayLength] + public static int F_array (double l_min, int kmax, double eta, double x, double[] fc_array, out double f_exponent); + [NoArrayLength] + public static int FG_array (double l_min, int kmax, double eta, double x, double[] fc_array, double[] gc_array, out double f_exponent, out double g_exponent); + [NoArrayLength] + public static int FGp_array (double l_min, int kmax, double eta, double x, double[] fc_array, double[] fcp_array, double[] gc_array, double[] gcp_array, out double f_exponent, out double g_exponent); + [NoArrayLength] + public static int sphF_array (double l_min, int kmax, double eta, double x, double[] fc_array, double[] f_exponent); + } + + [CCode (lower_case_cprefix="gsl_sf_coulomb_", cheader_filename="gsl/gsl_sf_coulomb.h")] + namespace Coulomb + { + public static int CL_e (double l, double eta, out Result result); + [NoArrayLength] + public static int CL_array (double lmin, int kmax, double eta, double[] cl); + } + + [CCode (lower_case_cprefix="gsl_sf_coupling_", cheader_filename="gsl/gsl_coupling.h")] + namespace Coupling + { + public static double 3j (int two_ja, int two_jb, int two_jc, int two_ma, int two_mb, int two_mc); + public static int 3j_e (int two_ja, int two_jb, int two_jc, int two_ma, int two_mb, int two_mc, out Result result); + + public static double 6j (int two_ja, int two_jb, int two_jc, int two_jd, int two_je, int two_jf); + public static int 6j_e (int two_ja, int two_jb, int two_jc, int two_jd, int two_je, int two_jf, out Result result); + + public static double 9j (int two_ja, int two_jb, int two_jc, int two_jd, int two_je, int two_jf, int two_jg, int two_jh, int two_ji); + public static int 9j_e (int two_ja, int two_jb, int two_jc, int two_jd, int two_je, int two_jf, int two_jg, int two_jh, int two_ji, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_dawson.h")] + namespace Dawson + { + public static double dawson (double x); + public static int dawson_e (double x, out Result result); + } + + [CCode (cheader_filename="gsl/gsl_sf_debye.h")] + namespace Debye + { + [CCode (cname="gsl_sf_debye_1")] + public static double D1 (double x); + [CCode (cname="gsl_sf_debye_1_e")] + public static int D1_e (double x, out Result result); + [CCode (cname="gsl_sf_debye_2")] + public static double D2 (double x); + [CCode (cname="gsl_sf_debye_2_e")] + public static int D2_e (double x, out Result result); + [CCode (cname="gsl_sf_debye_3")] + public static double D3 (double x); + [CCode (cname="gsl_sf_debye_3_e")] + public static int D3_e (double x, out Result result); + [CCode (cname="gsl_sf_debye_4")] + public static double D4 (double x); + [CCode (cname="gsl_sf_debye_4_e")] + public static int D4_e (double x, out Result result); + [CCode (cname="gsl_sf_debye_5")] + public static double D5 (double x); + [CCode (cname="gsl_sf_debye_5_e")] + public static int D5_e (double x, out Result result); + [CCode (cname="gsl_sf_debye_6")] + public static double D6 (double x); + [CCode (cname="gsl_sf_debye_6_e")] + public static int D6_e (double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_dilog.h")] + namespace Dilog + { + public static double dilog (double x); + public static int dilog_e (double x, out Result result); + public static int complex_dilog_e (double r, double theta, out Result result_re, out Result result_im); + } + + [CCode (lower_case_cprefix="gsl_sf_multiply_", cheader_filename="gsl/gsl_sf_elementary.h")] + namespace Multiply + { + public static int e (double x, double y, out Result result); + public static int err_e (double x, double dx, double y, double dy, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_ellint_", cheader_filename="gsl/gsl_sf_ellint.h")] + namespace EllInt + { + public static double Kcomp (double k, Mode mode); + public static int Kcomp_e (double k, Mode mode, out Result result); + public static double Ecomp (double k, Mode mode); + public static int Ecomp_e (double k, Mode mode, out Result result); + public static double Pcomp (double k, double n, Mode mode); + public static int Pcomp_e (double k, double n, Mode mode, out Result result); + + public static double F (double phi, double k, Mode mode); + public static int F_e (double phi, double k, Mode mode, out Result result); + public static double E (double phi, double k, Mode mode); + public static int E_e (double phi, double k, Mode mode, out Result result); + public static double P (double phi, double k, double n, Mode mode); + public static int P_e (double phi, double k, double n, Mode mode, out Result result); + public static double D (double phi, double k, double n, Mode mode); + public static int D_e (double phi, double k, double n, Mode mode, out Result result); + + public static double RC (double x, double y, Mode mode); + public static int RC_e (double x, double y, Mode mode, out Result result); + public static double RD (double x, double y, double z, Mode mode); + public static int RD_e (double x, double y, double z, Mode mode, out Result result); + public static double RF (double x, double y, double z, Mode mode); + public static int RF_e (double x, double y, double z, Mode mode, out Result result); + public static double RJ (double x, double y, double z, double p, Mode mode); + public static int RJ_e (double x, double y, double z, double p, Mode mode, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_elljac_", cheader_filename="gsl/gsl_elljac.h")] + namespace EllJac + { + public static int e (double u, double m, out double sn, out double cn, out double dn); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_erf.h")] + namespace Erf + { + public static double erf (double x); + public static int erf_e (double x, out Result result); + public static double erf_Z (double x); + public static int erf_Z_e (double x, out Result result); + public static double erf_Q (double x); + public static int erf_Q_e (double x, out Result result); + public static double erfc (double x); + public static int erfc_e (double x, out Result result); + public static double log_erfc (double x); + public static int log_erfc_e (double x, out Result result); + public static double hazard (double x); + public static int hazard_e (double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_exp.h")] + namespace Exp + { + public static double exp (double x); + public static int exp_e (double x, out Result result); + public static int exp_e10_e (double x, out ResultE10 result); + public static double exp_mult (double x, double y); + public static int exp_mult_e (double x, double y, out Result result); + public static int exp_mult_e10_e (double x, double y, out ResultE10 result); + public static int exp_err_e (double x, double dx, out Result result); + public static int exp_err_e10_e (double x, double dx, out ResultE10 result); + public static int exp_mul_err_e (double x, double dx, double y, double dy, out Result result); + public static int exp_mul_err_e10_e (double x, double dx, double y, double dy, out ResultE10 result); + public static double expm1 (double x); + public static int expm1_e (double x, out Result result); + public static double exprel (double x); + public static int exprel_e (double x, out Result result); + public static double exprel_2 (double x); + public static int exprel_2_e (double x, out Result result); + public static double exprel_n (int n, double x); + public static int exprel_n_e (int n, double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_expint.h")] + namespace Expint + { + public static double expint_E1 (double x); + public static int expint_E1_e (double x, out Result result); + public static double expint_E2 (double x); + public static int expint_E2_e (double x, out Result result); + public static double expint_En (int n, double x); + public static int expint_En_e (int n, double x, out Result result); + public static double expint_Ei (double x); + public static int expint_Ei_e (double x, out Result result); + public static double expint_Ei_3 (double x); + public static int expint_Ei_3_e (double x, out Result result); + public static double Shi (double x); + public static int Shi_e (double x, out Result result); + public static double Chi (double x); + public static int Chi_e (double x, out Result result); + public static double Si (double x); + public static int Si_e (double x, out Result result); + public static double Ci (double x); + public static int Ci_e (double x, out Result result); + public static double atanint (double x); + public static double atanint_e (double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_fermi_dirac_", cheader_filename="gsl/gsl_sf_fermi_dirach.h")] + namespace FermiDirac + { + public static double m1 (double x); + public static int m1_e (double x, out Result result); + [CCode (cname="gsl_sf_fermi_dirac_0")] + public static double F0 (double x); + [CCode (cname="gsl_sf_fermi_dirac_0_e")] + public static int F0_e (double x, out Result result); + [CCode (cname="gsl_sf_fermi_dirac_1")] + public static double F1 (double x); + [CCode (cname="gsl_sf_fermi_dirac_1_e")] + public static int F1_e (double x, out Result result); + [CCode (cname="gsl_sf_fermi_dirac_2")] + public static double F2 (double x); + [CCode (cname="gsl_sf_fermi_dirac_2_e")] + public static int F2_e (double x, out Result result); + [CCode (cname="gsl_sf_fermi_dirac_int")] + public static double Fint (int j, double x); + [CCode (cname="gsl_sf_fermi_dirac_int_e")] + public static int Fint_e (int j, double x, out Result result); + public static double mhalf (double x); + public static int mhalf_e (double x, out Result result); + public static double half (double x); + public static int half_e (double x, out Result result); + public static double 3half (double x); + public static int 3half_e (double x, out Result result); + public static double inc_0 (double x, double b); + public static int inc_0_e (double x, double b, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_gamma.h")] + namespace GammaBeta + { + public static double gamma (double x); + public static int gamma_e (double x, out Result result); + public static double lngamma (double x); + public static int lngamma_e (double x, out Result result); + public static int lngamma_sgn_e (double x, out Result result, out double sgn); + public static double gammastar (double x); + public static int gammastar_e (double x, out Result result); + public static double gammainv (double x); + public static int gammainv_e (double x, out Result result); + public static int lngamma_complex_e (double zr, double zi, out Result lnr, out Result arg); + + public static double fact (uint n); + public static int fact_e (uint n, out Result result); + public static double doublefact (uint n); + public static int doublefact_e (uint n, out Result result); + public static double lnfact (uint n); + public static int lnfact_e (uint n, out Result result); + public static double lndoublefact (uint n); + public static int lndoublefact_e (uint n, out Result result); + public static double choose (uint n, uint m); + public static int choose_e (uint n, uint m, out Result result); + public static double lnchoose (uint n, uint m); + public static int lnchoose_e (uint n, uint m, out Result result); + public static double taylorcoeff (int n, double x); + public static int taylorcoeff_e (int n, double x, out Result result); + + public static double poch (double a, double x); + public static int poch_e (double a, double x, out Result result); + public static double lnpoch (double a, double x); + public static int lnpoch_e (double a, double x, out Result result); + public static int lnpoch_sgn_e (double a, double x, out Result result, out double sgn); + public static double pochrel (double a, double x); + public static int pochrel_e (double a, double x, out Result result); + + public static double gamma_inc (double a, double x); + public static int gamma_inc_e (double a, double x, out Result result); + public static double gamma_inc_Q (double a, double x); + public static int gamma_inc_Q_e (double a, double x, out Result result); + public static double gamma_inc_P (double a, double x); + public static int gamma_inc_P_e (double a, double x, out Result result); + + public static double beta (double a, double b); + public static int beta_e (double a, double b, out Result result); + public static double lnbeta (double a, double b); + public static int lnbeta_e (double a, double b, out Result result); + + public static double beta_inc (double a, double b, double x); + public static int beta_inc_e (double a, double b, double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_gegenpoly_", cheader_filename="gsl/gsl_sf_gegenbauer.h")] + namespace GegenPoly + { + [CCode (cname="gsl_sf_gegenpoly_1")] + public static double C1 (double lambda, double x); + [CCode (cname="gsl_sf_gegenpoly_1_e")] + public static double C1_e (double lambda, double x, out Result result); + [CCode (cname="gsl_sf_gegenpoly_2")] + public static double C2 (double lambda, double x); + [CCode (cname="gsl_sf_gegenpoly_2_e")] + public static double C2_e (double lambda, double x, out Result result); + [CCode (cname="gsl_sf_gegenpoly_3")] + public static double C3 (double lambda, double x); + [CCode (cname="gsl_sf_gegenpoly_3_e")] + public static double C3_e (double lambda, double x, out Result result); + [CCode (cname="gsl_sf_gegenpoly_n")] + public static double Cn (double lambda, double x); + [CCode (cname="gsl_sf_gegenpoly_n_e")] + public static double Cn_e (double lambda, double x, out Result result); + public static int array (int nmax, double lambda, double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_hyperg_", cheader_filename="gsl/gsl_sf_hyperg.h")] + namespace Hyperg + { + public static double 0F1 (double c, double x); + public static int 0F1_e (double c, double x, out Result result); + public static double 1F1_int (int m, int n, double x); + public static int 1F1_int_e (int m, int n, double x, out Result result); + public static double 1F1 (double a, double b, double x); + public static int 1F1_e (double a, double b, double x, out Result result); + public static double U_int (int m, int n, double x); + public static int U_int_e (int m, int n, double x, out Result result); + public static int U_int_e10_e (int m, int n, double x, out ResultE10 result); + public static double U (double a, double b, double x); + public static int U_e (double a, double b, double x, out Result result); + public static int U_e10_e (double a, double b, double x, out ResultE10 result); + public static double 2F1 (double a, double b, double c, double x); + public static int 2F1_e (double a, double b, double c, double x, out Result result); + public static double 2F1_conj (double aR, double aI, double c, double x); + public static int 2F1_conj_e (double aR, double aI, double c, double x, out Result result); + public static double 2F1_renorm (double a, double b, double c, double x); + public static int 2F1_renorm_e (double a, double b, double c, double x, out Result result); + public static double 2F1_conj_renorm (double aR, double aI, double c, double x); + public static int 2F1_conj_renorm_e (double aR, double aI, double c, double x, out Result result); + public static double 2F0 (double a, double b, double x); + public static int 2F0_e (double a, double b, double x, out Result result); + } + + [CCode (cheader_filename="gsl/gsl_sf_laguerre.h")] + namespace Laguerre + { + [CCode (cname="gsl_sf_laguerre_1")] + public static double L1 (double a, double x); + [CCode (cname="gsl_sf_laguerre_1_e")] + public static double L1_e (double a, double x, out Result result); + [CCode (cname="gsl_sf_laguerre_2")] + public static double L2 (double a, double x); + [CCode (cname="gsl_sf_laguerre_2_e")] + public static double L2_e (double a, double x, out Result result); + [CCode (cname="gsl_sf_laguerre_3")] + public static double L3 (double a, double x); + [CCode (cname="gsl_sf_laguerre_3_e")] + public static double L3_e (double a, double x, out Result result); + [CCode (cname="gsl_sf_laguerre_n")] + public static double Ln (int n, double a, double x); + [CCode (cname="gsl_sf_laguerre_n_e")] + public static double Ln_e (int n, double a, double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_lambert_", cheader_filename="gsl/gsl_sf_lambert.h")] + namespace Lambert + { + public static double W0 (double x); + public static int W0_e (double x, out Result result); + public static double Wm1 (double x); + public static int Wm1_e (double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_legendre_", cheader_filename="gsl/gsl_sf_legendre.h")] + namespace LegendrePoly + { + public static double P1 (double x); + public static int P1_e (double x, out Result result); + public static double P2 (double x); + public static int P2_e (double x, out Result result); + public static double P3 (double x); + public static int P3_e (double x, out Result result); + public static double Pl (int l, double x); + public static int Pl_e (int l, double x, out Result result); + [NoArrayLength] + public static int Pl_array (int lmax, double x, double[] result_array); + [NoArrayLength] + public static int Pl_deriv_array (int lmax, double x, double[] result_array, double[] result_deriv_array); + public static double Q0 (double x); + public static int Q0_e (double x, out Result result); + public static double Q1 (double x); + public static int Q1_e (double x, out Result result); + public static double Ql (int l, double x); + public static int Ql_e (int l, double x, out Result result); + + public static double Plm (int l, int m, double x); + public static int Plm_e (int l, int m, double x, out Result result); + [NoArrayLength] + public static int Plm_array (int lmax, int m, double x, double[] result_array); + [NoArrayLength] + public static int Plm_deriv_array (int lmax, int m, double x, double[] result_array, double[] result_deriv_array); + public static double sphPlm (int l, int m, double x); + public static int sphPlm_e (int l, int m, double x, out Result result); + [NoArrayLength] + public static int sphPlm_array (int lmax, int m, double x, double[] result_array); + [NoArrayLength] + public static int sphPlm_deriv_array (int lmax, int m, double x, double[] result_array, double[] result_deriv_array); + public static int array_size (int lmax, int m); + + [CCode (cname="gsl_sf_conicalP_half")] + public static double conicalP_half (double lambda, double x); + [CCode (cname="gsl_sf_conicalP_half_e")] + public static int conicalP_half_e (double lambda, double x, out Result result); + [CCode (cname="gsl_sf_conicalP_mhalf")] + public static double conicalP_mhalf (double lambda, double x); + [CCode (cname="gsl_sf_conicalP_mhalf_e")] + public static int conicalP_mhalf_e (double lambda, double x, out Result result); + [CCode (cname="gsl_sf_conicalP_0")] + public static double conicalP_0 (double lambda, double x); + [CCode (cname="gsl_sf_conicalP_0_e")] + public static int conicalP_0_e (double lambda, double x, out Result result); + [CCode (cname="gsl_sf_conicalP_1")] + public static double conicalP_1 (double lambda, double x); + [CCode (cname="gsl_sf_conicalP_1_e")] + public static int conicalP_1_e (double lambda, double x, out Result result); + [CCode (cname="gsl_sf_conicalP_sph_reg")] + public static double conicalP_sph_reg (int l, double lambda, double x); + [CCode (cname="gsl_sf_conicalP_sph_reg_e")] + public static int conicalP_sph_reg_e (int l, double lambda, double x, out Result result); + [CCode (cname="gsl_sf_conicalP_cyl_reg")] + public static double conicalP_cyl_reg (int m, double lambda, double x); + [CCode (cname="gsl_sf_conicalP_cyl_reg_e")] + public static int conicalP_cyl_reg_e (int m, double lambda, double x, out Result result); + + public static double H3d_0 (double lambda, double eta); + public static int H3d_0_e (double lambda, double eta, out Result result); + public static double H3d_1 (double lambda, double eta); + public static int H3d_1_e (double lambda, double eta, out Result result); + public static double H3d (int l, double lambda, double eta); + public static int H3d_e (int l, double lambda, double eta, out Result result); + [NoArrayLength] + public static int H3d_array (int lmax, double lambda, double eta, double[] result_array); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_log.h")] + namespace Log + { + public static double log (double x); + public static int log_e (double x, out Result result); + public static double log_abs (double x); + public static int log_abs_e (double x, out Result result); + public static int complex_log_e (double zr, double zi, out Result result, out Result theta); + public static double log_1plusx (double x); + public static int log_1plusx_e (double x, out Result result); + public static double log_1plusx_mx (double x); + public static int log_1plusx_mx_e (double x, out Result result); + } + + [Compact] + [CCode (cname="gsl_sf_mathieu_workspace", cprefix="gsl_sf_mathieu_", cheader_filename="gsl/gsl_sf_mathieu.h")] + public class MathieuWorkspace + { + public size_t size; + public size_t even_order; + public size_t odd_order; + public int extra_values; + public double qa; + public double qb; + public double* aa; + public double* bb; + public double* dd; + public double* ee; + public double* tt; + public double* e2; + public double* zz; + public Vector eval; + public Matrix evec; + public EigenSymmvWorkspace wmat; + + [NoArrayLength] + public static int a_array (int order_min, int order_max, double qq, MathieuWorkspace work, double[] result_array); + [NoArrayLength] + public static int b_array (int order_min, int order_max, double qq, MathieuWorkspace work, double[] result_array); + public static int a (int order, double qq, out Result result); + public static int b (int order, double qq, out Result result); + [NoArrayLength] + public static int a_coeff (int order, double qq, double aa, double[] coeff); + [NoArrayLength] + public static int b_coeff (int order, double qq, double aa, double[] coeff); + + [CCode (cname="gsl_sf_mathieu_alloc")] + public MathieuWorkspace (size_t nn, double qq); + + public static int ce (int order, double qq, double zz, out Result result); + public static int se (int order, double qq, double zz, out Result result); + [NoArrayLength] + public static int ce_array (int nmin, int nmax, double qq, double zz, MathieuWorkspace work, double[] result_array); + [NoArrayLength] + public static int se_array (int nmin, int nmax, double qq, double zz, MathieuWorkspace work, double[] result_array); + + public static int Mc (int kind, int order, double qq, double zz, out Result result); + public static int Ms (int kind, int order, double qq, double zz, out Result result); + [NoArrayLength] + public static int Mc_array (int kind, int nmin, int nmax, double qq, double zz, MathieuWorkspace work, double[] result_array); + [NoArrayLength] + public static int Ms_array (int kind, int nmin, int nmax, double qq, double zz, MathieuWorkspace work, double[] result_array); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_pow_int.h")] + namespace Pow + { + public static double pow_int (double x, int n); + public static int pow_int_e (double x, int n, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_psi.h")] + namespace Psi + { + public static double psi_int (int n); + public static int psi_int_e (int n, out Result result); + public static double psi (double x); + public static int psi_e (double x, out Result result); + public static double psi_1piy (double y); + public static int psi_1piy_e (double y, out Result result); + + public static double psi_1_int (int n); + public static int psi_1_int_e (int n, out Result result); + public static double psi_1 (double x); + public static int psi_1_e (double x, out Result result); + + public static double psi_n (int n, double x); + public static int psi_e_n (int n, double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_synchrotron.h")] + namespace Synchrotron + { + public static double synchrotron_1 (double x); + public static int synchrotron_1_e (double x, out Result result); + public static double synchrotron_2 (double x); + public static double synchrotron_2_e (double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_transport.h")] + namespace Transport + { + public static double transport_2 (double x); + public static int transport_2_e (double x, out Result result); + public static double transport_3 (double x); + public static int transport_3_e (double x, out Result result); + public static double transport_4 (double x); + public static int transport_4_e (double x, out Result result); + public static double transport_5 (double x); + public static int transport_5_e (double x, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_trig.h")] + namespace Trig + { + public static double sin (double x); + public static int sin_e (double x, out Result result); + public static double cos (double x); + public static int cos_e (double x, out Result result); + public static double hypot (double x, double y); + public static int hypot_e (double x, double y, out Result result); + public static double sinc (double x); + public static int sinc_e (double x, out Result result); + public static double complex_sin_e (double zr, double zi, out Result szr, out Result szi); + public static double complex_cos_e (double zr, double zi, out Result czr, out Result czi); + public static double complex_logsin_e (double zr, double zi, out Result lszr, out Result lszi); + public static double lnsinh (double x); + public static int lnsinh_e (double x, out Result result); + public static double lncosh (double x); + public static int lncosh_e (double x, out Result result); + public static int polar_to_rect (double r, double theta, out Result x, out Result y); + public static int rect_to_polar (double x, double y, out Result r, out Result theta); + public static double angle_restrict_symm (double theta); + public static int angle_restrict_symm_e (out double theta); + public static double angle_restrict_pos (double theta); + public static int angle_restrict_pos_e (out double theta); + public static int sin_err_e (double x, double dx, out Result result); + public static int cos_err_e (double x, double dx, out Result result); + } + + [CCode (lower_case_cprefix="gsl_sf_", cheader_filename="gsl/gsl_sf_zeta.h")] + namespace Zeta + { + public static double zeta_int (int n); + public static int zeta_int_e (int n, out Result result); + public static double zeta (double s); + public static int zeta_e (double s, out Result result); + public static double zetam1_int (int n); + public static int zetam1_int_e (int n, out Result result); + public static double zetam1 (double s); + public static int zetam1_e (double s, out Result result); + public static double hzeta (double s, double q); + public static int hzeta_e (double s, double q, out Result result); + public static double eta_int (int n); + public static int eta_int_e (int n, out Result result); + public static double eta (double s); + public static int eta_e (double s, out Result result); + } + + + /* + * Blocks, Vectors and Matrices + */ + [Compact] + [CCode (cname="gsl_block", cheader_filename="gsl/gsl_block_double.h")] + public class Block + { + public size_t size; + public double* data; + + [CCode (cname="gsl_block_alloc")] + public Block (size_t n); + [CCode (cname="gsl_block_calloc")] + public Block.with_zeros (size_t n); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, Block b, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + } + + [Compact] + [CCode (cname="gsl_block_complex", cheader_filename="gsl/gsl_block_complex_double.h")] + public class BlockComplex + { + public size_t size; + public double* data; + + [CCode (cname="gsl_block_complex_alloc")] + public BlockComplex (size_t n); + [CCode (cname="gsl_block_complex_calloc")] + public BlockComplex.with_zeros (size_t n); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, BlockComplex b, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + } + + [SimpleType] + [CCode (cname="gsl_vector_view", cheader_filename="gsl/gsl_vector_double.h")] + public struct VectorView + { + public Vector vector; + + public static VectorView array (double[] v); + [NoArrayLength] + public static VectorView array_with_stride (double[] v, size_t stride, size_t n); + } + + [Compact] + [CCode (cname="gsl_vector", cheader_filename="gsl/gsl_vector_double.h")] + public class Vector + { + public size_t size; + public size_t stride; + public double* data; + public Block block; + public int owner; + + [CCode (cname="gsl_vector_alloc")] + public Vector (size_t n); + [CCode (cname="gsl_vector_calloc")] + public Vector.with_zeros (size_t n); + [CCode (cname="gsl_vector_alloc_from_block")] + public Vector.from_block (Block b, size_t offset, size_t n, size_t stride); + [CCode (cname="gsl_vector_alloc_from_vector")] + public Vector.from_vector (Vector v, size_t offset, size_t n, size_t stride); + + public double @get (size_t i); + public void @set (size_t i, double x); + public double* ptr (size_t i); + + public void set_all (double x); + public void set_zero (); + public void set_basis (size_t i); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, Vector v, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + + public VectorView subvector (size_t offset, size_t n); + public VectorView subvector_with_stride (size_t offset, size_t stride, size_t n); + + public int memcpy (Vector src); + public int swap (Vector w); + + public int swap_elements (size_t i, size_t j); + public int reverse (); + + public int add (Vector b); + public int sub (Vector b); + public int mul (Vector b); + public int div (Vector b); + public int scale (double x); + public int add_constant (double x); + + public double max (); + public double min (); + public void minmax (out double min_out, out double max_out); + public size_t max_index (); + public size_t min_index (); + public void minmax_index (out size_t imin, out size_t imax); + + public bool isnull (); + public bool ispos (); + public bool isneg (); + public bool isnonneg (); + } + + [SimpleType] + [CCode (cname="gsl_vector_complex_view", cheader_filename="gsl/gsl_vector_complex_double.h")] + public struct VectorComplexView + { + public VectorComplex vector; + + public static VectorComplexView array (double[] v); + [NoArrayLength] + public static VectorComplexView array_with_stride (double[] v, size_t stride, size_t n); + } + + [Compact] + [CCode (cname="gsl_vector_complex", cheader_filename="gsl/gsl_vector_complex_double.h")] + public class VectorComplex + { + public size_t size; + public size_t stride; + public double* data; + public BlockComplex block; + public int owner; + + [CCode (cname="gsl_vector_complex_alloc")] + public VectorComplex (size_t n); + [CCode (cname="gsl_vector_complex_calloc")] + public VectorComplex.with_zeros (size_t n); + [CCode (cname="gsl_vector_complex_alloc_from_block")] + public VectorComplex.from_block (BlockComplex b, size_t offset, size_t n, size_t stride); + [CCode (cname="gsl_vector_complex_alloc_from_vector")] + public VectorComplex.from_vector (VectorComplex v, size_t offset, size_t n, size_t stride); + + public Complex @get (size_t i); + public void @set (size_t i, Complex x); + public Complex* ptr (size_t i); + + public void set_all (Complex x); + public void set_zero (); + public void set_basis (size_t i); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, VectorComplex v, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + + public VectorComplexView subvector (size_t i, size_t n); + public VectorComplexView subvector_with_stride (size_t i, size_t stride, size_t n); + public VectorView complex_real (); + public VectorView complex_imag (); + + public int memcpy (VectorComplex src); + public int swap (VectorComplex w); + + public int swap_elements (size_t i, size_t j); + public int reverse (); + + public int add (VectorComplex b); + public int sub (VectorComplex b); + public int mul (VectorComplex b); + public int div (VectorComplex b); + public int scale (double x); + public int add_constant (double x); + + public double max (); + public double min (); + public void minmax (out double min_out, out double max_out); + public size_t max_index (); + public size_t min_index (); + public void minmax_index (out size_t imin, out size_t imax); + + public bool isnull (); + public bool ispos (); + public bool isneg (); + public bool isnonneg (); + } + + [SimpleType] + [CCode (cname="gsl_matrix_view", cheader_filename="gsl/gsl_matrix_double.h")] + public struct MatrixView + { + public Matrix matrix; + + [NoArrayLength] + public static MatrixView array (double[] v, size_t n1, size_t n2); + [NoArrayLength] + public static MatrixView array_with_tda (double[] v, size_t n1, size_t n2, size_t tda); + public static MatrixView vector (Vector v, size_t n1, size_t n2); + public static MatrixView vectr_with_tda (Vector v, size_t n1, size_t n2, size_t tda); + } + + [Compact] + [CCode (cname="gsl_matrix", cheader_filename="gsl/gsl_matrix_double.h")] + public class Matrix + { + public size_t size1; + public size_t size2; + public size_t tda; + public double* data; + public Block block; + public int owner; + + [CCode (cname="gsl_matrix_alloc")] + public Matrix (size_t n1, size_t n2); + [CCode (cname="gsl_matrix_calloc")] + public Matrix.with_zeros (size_t n1, size_t n2); + [CCode (cname="gsl_matrix_alloc_from_block")] + public Matrix.from_block (Block b, size_t offset, size_t n1, size_t n2, size_t d2); + [CCode (cname="gsl_matrix_alloc_from_matrix")] + public Matrix.from_matrix (Matrix m, size_t k1, size_t k2, size_t n1, size_t n2); + + public Vector alloc_row_from_matrix (size_t i); + public Vector alloc_col_from_matrix (size_t j); + + public double @get (size_t i, size_t j); + public void @set (size_t i, size_t j, double x); + public double* ptr (size_t i, size_t j); + + public void set_all (double x); + public void set_zero (); + public void set_identity (); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, Matrix m, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + + public MatrixView submatrix (size_t k, size_t k2, size_t n1, size_t n2); + public VectorView row (size_t i); + public VectorView column (size_t j); + public VectorView subrow (size_t i, size_t offset, size_t n); + public VectorView subcolumn (size_t i, size_t offset, size_t n); + public VectorView diagonal (); + public VectorView subdiagonal (size_t k); + public VectorView superdiagonal (size_t k); + + public int memcpy (Matrix src); + public int swap (Matrix m2); + + public static int get_row (Vector v, Matrix m, size_t i); + public static int get_col (Vector v, Matrix m, size_t j); + public int set_row (size_t i, Vector v); + public int set_col (size_t j, Vector v); + + public int swap_rows (size_t i, size_t j); + public int swap_columns (size_t i, size_t j); + public int swap_rowcol (size_t i, size_t j); + public int transpose_memcpy (Matrix src); + public int transpose (); + + public int add (Matrix b); + public int sub (Matrix b); + public int mul_elements (Matrix b); + public int div_elements (Matrix b); + public int scale (double x); + public int add_constant (double x); + public int add_diagonal (double x); + + public double max (); + public double min (); + public void minmax (out double min_out, out double max_out); + public void max_index (out size_t imax, out size_t jmax); + public void min_index (out size_t imin, out size_t jmin); + public void minmax_index (out size_t imin, out size_t jmin, out size_t imax, out size_t jmax); + + public bool isnull (); + public bool ispos (); + public bool isneg (); + public bool isnonneg (); + } + + [SimpleType] + [CCode (cname="gsl_matrix_complex_view", cheader_filename="gsl/gsl_matrix_complex_double.h")] + public struct MatrixComplexView + { + public MatrixComplex matrix; + + [NoArrayLength] + public static MatrixComplexView array (double[] v, size_t n1, size_t n2); + [NoArrayLength] + public static MatrixComplexView array_with_tda (double[] v, size_t n1, size_t n2, size_t tda); + public static MatrixComplexView vector (VectorComplex v, size_t n1, size_t n2); + public static MatrixComplexView vectr_with_tda (VectorComplex v, size_t n1, size_t n2, size_t tda); + } + + [Compact] + [CCode (cname="gsl_matrix_complex", cheader_filename="gsl/gsl_matrix_complex_double.h")] + public class MatrixComplex + { + public size_t size1; + public size_t size2; + public size_t tda; + public double* data; + public BlockComplex block; + public int owner; + + [CCode (cname="gsl_matrix_complex_alloc")] + public MatrixComplex (size_t n1, size_t n2); + [CCode (cname="gsl_matrix_complex_calloc")] + public MatrixComplex.with_zeros (size_t n1, size_t n2); + [CCode (cname="gsl_matrix_complex_alloc_from_block")] + public MatrixComplex.from_block (BlockComplex b, size_t offset, size_t n1, size_t n2, size_t d2); + [CCode (cname="gsl_matrix_complex_alloc_from_matrix")] + public MatrixComplex.from_matrix (MatrixComplex m, size_t k1, size_t k2, size_t n1, size_t n2); + + public VectorComplex alloc_row_from_matrix (size_t i); + public VectorComplex alloc_col_from_matrix (size_t j); + + public double @get (size_t i, size_t j); + public void @set (size_t i, size_t j, double x); + public double* ptr (size_t i, size_t j); + + public void set_all (double x); + public void set_zero (); + public void set_identity (); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, MatrixComplex m, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + + public MatrixComplexView submatrix (size_t k, size_t k2, size_t n1, size_t n2); + public VectorComplexView row (size_t i); + public VectorComplexView column (size_t j); + public VectorComplexView subrow (size_t i, size_t offset, size_t n); + public VectorComplexView subcolumn (size_t i, size_t offset, size_t n); + public VectorComplexView diagonal (); + public VectorComplexView subdiagonal (size_t k); + public VectorComplexView superdiagonal (size_t k); + + public int memcpy (MatrixComplex src); + public int swap (MatrixComplex m2); + + public static int get_row (VectorComplex v, MatrixComplex m, size_t i); + public static int get_col (VectorComplex v, MatrixComplex m, size_t j); + public int set_row (size_t i, VectorComplex v); + public int set_col (size_t j, VectorComplex v); + + public int swap_rows (size_t i, size_t j); + public int swap_columns (size_t i, size_t j); + public int swap_rowcol (size_t i, size_t j); + public int transpose_memcpy (MatrixComplex src); + public int transpose (); + + public int add (MatrixComplex b); + public int sub (MatrixComplex b); + public int mul_elements (MatrixComplex b); + public int div_elements (MatrixComplex b); + public int scale (double x); + public int add_constant (double x); + public int add_diagonal (double x); + + public double max (); + public double min (); + public void minmax (out double min_out, out double max_out); + public void max_index (out size_t imax, out size_t jmax); + public void min_index (out size_t imin, out size_t jmin); + public void minmax_index (out size_t imin, out size_t jmin, out size_t imax, out size_t jmax); + + public bool isnull (); + public bool ispos (); + public bool isneg (); + public bool isnonneg (); + } + + + /* + * Permutations + */ + [Compact] + [CCode (cname="gsl_permutation", cheader_filename="gsl/gsl_permutation.h")] + public class Permutation + { + public size_t size; + public size_t* data; + + [CCode (cname="gsl_permutation_alloc")] + public Permutation (size_t n); + [CCode (cname="gsl_permutation_calloc")] + public Permutation.with_zeros (size_t n); + + public void init (); + public int memcpy (Permutation src); + + public size_t @get (size_t i); + public int swap (size_t i, size_t j); + + public int valid (); + + public void reverse (); + public int inverse (Permutation p); + public int next (); + public int prev (); + + public int mul (Permutation pa, Permutation pb); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, Permutation p, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + + public int linear_to_canonical (Permutation p); + public int canonical_to_linear (Permutation q); + public size_t inversions (); + public size_t linear_cycles (); + public size_t canonical_cycles (); + } + + [CCode (lower_case_cprefix="gsl_", cheader_filename="gsl/gsl_permute_double.h")] + namespace Permute + { + [NoArrayLength] + public static int permute (size_t* p, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int permute_inverse (size_t* p, double[] data, size_t stride, size_t n); + } + + [CCode (cheader_filename="gsl/gsl_permute_complex_double.h")] + namespace PermuteComplex + { + [NoArrayLength] + [CCode (cname="gsl_permute_complex")] + public static int permute (size_t* p, double[] data, size_t stride, size_t n); + [NoArrayLength] + [CCode (cname="gsl_permute_complex_inverse")] + public static int permute_inverse (size_t* p, double[] data, size_t stride, size_t n); + } + + [CCode (cheader_filename="gsl/gsl_permute_vector_double.h")] + namespace PermuteVector + { + [CCode (cname="gsl_permute_vector")] + public static int permute (Permutation p, Vector v); + [CCode (cname="gsl_permute_vector_inverse")] + public static int permute_inverse (Permutation p, Vector v); + } + + [CCode (cheader_filename="gsl/gsl_permute_vector_complex_double.h")] + namespace PermuteVectorComplex + { + [CCode (cname="gsl_permute_vector_complex")] + public static int permute (Permutation p, Vector v); + [CCode (cname="gsl_permute_vector_complex_inverse")] + public static int permute_inverse (Permutation p, Vector v); + } + + + /* + * Combinations + */ + [Compact] + [CCode (cname="gsl_combination", cheader_filename="gsl/gsl_combination.h")] + public class Combination + { + public size_t n; + public size_t k; + public size_t* data; + + [CCode (cname="gsl_combination_alloc")] + public Combination (size_t n, size_t k); + [CCode (cname="gsl_combination_calloc")] + public Combination.with_zeros (size_t n, size_t k); + + public void init_first (); + public void init_last (); + public int memcpy (Combination src); + + public size_t @get (size_t i); + + public int valid (); + + public int next (); + public int prev (); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, Combination c, string format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + } + + + /* + * Sorting + */ + [CCode (lower_case_cprefix="gsl_sort_", cheader_filename="gsl/gsl_sort_double.h")] + namespace Sort + { + [NoArrayLength] + [CCode (cname="gsl_sort")] + public static void sort (double[] data, size_t stride, size_t n); + [NoArrayLength] + [CCode (cname="gsl_sort_index")] + public static void sort_index (size_t[] p, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int smallest (double[] dest, size_t k, double[] src, size_t stride, size_t n); + [NoArrayLength] + public static int smallest_index (size_t[] p, size_t k, double[] src, size_t stride, size_t n); + [NoArrayLength] + public static int largest (double[] dest, size_t k, double[] src, size_t stride, size_t n); + [NoArrayLength] + public static int largest_index (size_t[] p, size_t k, double[] src, size_t stride, size_t n); + } + + [CCode (lower_case_cprefix="gsl_sort_vector_", cheader_filename="gsl/gsl_sort_vector_double.h")] + namespace SortVector + { + [CCode (cname="gsl_sort_vector")] + public static void sort (Vector v); + [CCode (cname="gsl_sort_vector_index")] + public static int sort_index (Permutation p, Vector v); + [NoArrayLength] + public static int smallest (double[] dest, size_t k, Vector v); + [NoArrayLength] + public static int smallest_index (size_t[] p, size_t k, Vector v); + [NoArrayLength] + public static int largest (double[] dest, size_t k, Vector v); + [NoArrayLength] + public static int largest_index (size_t[] p, size_t k, Vector v); + } + + + /* + * Linear Algebra + */ + [CCode (lower_case_cprefix="gsl_linalg_", cheader_filename="gsl/gsl_linalg.h")] + namespace LinAlg + { + public static int LU_decomp (Matrix A, Permutation p, out int signum); + public static int complex_LU_decomp (MatrixComplex A, Permutation p, out int signum); + public static int LU_solve (Matrix LU, Permutation p, Vector b, Vector x); + public static int complex_LU_solve (MatrixComplex LU, Permutation p, VectorComplex b, VectorComplex x); + public static int LU_svx (Matrix LU, Permutation p, Vector x); + public static int complex_LU_svx (MatrixComplex LU, Permutation p, VectorComplex x); + public static int LU_refine (Matrix A, Matrix LU, Permutation p, Vector b, Vector x, Vector residual); + public static int complex_LU_refine (MatrixComplex A, MatrixComplex LU, Permutation p, VectorComplex b, VectorComplex x, VectorComplex residual); + public static int LU_invert (Matrix LU, Permutation p, Matrix inverse); + public static int complex_LU_invert (MatrixComplex LU, Permutation p, Matrix inverse); + public static double LU_det (Matrix LU, int signum); + public static Complex complex_LU_det (MatrixComplex LU, int signum); + public static double LU_lndet (Matrix LU); + public static double complex_LU_lndet (MatrixComplex LU); + public static int LU_sgndet (Matrix LU, int signum); + public static Complex complex_LU_sgndet (MatrixComplex LU, int signum); + + public static int QR_decomp (Matrix A, Vector tau); + public static int QR_solve (Matrix QR, Vector tau, Vector b, Vector x); + public static int QR_svx (Matrix QR, Vector tau, Vector x); + public static int QR_lssolve (Matrix QR, Vector tau, Vector b, Vector x, Vector residual); + public static int QR_QTvec (Matrix QR, Vector tau, Vector v); + public static int QR_Qvec (Matrix QR, Vector tau, Vector v); + public static int QR_QTmat (Matrix QR, Vector tau, Matrix A); + public static int QR_Rsolve (Matrix QR, Vector b, Vector x); + public static int QR_Rsvx (Matrix QR, Vector x); + public static int QR_unpack (Matrix QR, Vector tau, Matrix Q, Matrix R); + public static int QR_QRsolve (Matrix Q, Matrix R, Vector b, Vector x); + public static int QR_update (Matrix Q, Matrix R, Vector w, Vector v); + public static int R_solve (Matrix R, Vector b, Vector x); + public static int R_svx (Matrix R, Vector x); + + public static int QRPT_decomp (Matrix A, Vector tau, Permutation p, out int signum, Vector norm); + public static int QRPT_decomp2 (Matrix A, Matrix q, Matrix r, Vector tau, Permutation p, out int signum, Vector norm); + public static int QRPT_solve (Matrix QR, Vector tau, Permutation p, Vector b, Vector x); + public static int QRPT_svx (Matrix QR, Vector tau, Permutation p, Vector x); + public static int QRPT_QRsolve (Matrix Q, Matrix R, Permutation p, Vector b, Vector x); + public static int QRPT_update (Matrix Q, Matrix R, Permutation p, Vector u, Vector v); + public static int QRPT_Rsolve (Matrix QR, Permutation p, Vector b, Vector x); + public static int QRPT_Rsvx (Matrix QR, Permutation p, Vector x); + + public static int SV_decomp (Matrix A, Matrix V, Vector S, Vector work); + public static int SV_decomp_mod (Matrix A, Matrix X, Matrix V, Vector S, Vector work); + public static int SV_decomp_jacobi (Matrix A, Matrix V, Vector S); + public static int SV_solve (Matrix U, Matrix V, Vector S, Vector b, Vector x); + + public static int cholesky_decomp (Matrix A); + public static int complex_cholesky_decomp (MatrixComplex A); + public static int cholesky_solve (Matrix cholesky, Vector b, Vector x); + public static int complex_cholesky_solve (MatrixComplex cholesky, VectorComplex b, VectorComplex x); + public static int cholesky_svx (Matrix cholesky, Vector x); + public static int complex_cholesky_svx (MatrixComplex cholesky, VectorComplex x); + + public static int symmtd_decomp (Matrix A, Vector tau); + public static int symmtd_unpack (Matrix A, Vector tau, Matrix Q, Vector diag, Vector subdiag); + public static int symmtd_unpack_T (Matrix A, Vector diag, Vector subdiag); + + public static int hermtd_decomp (MatrixComplex A, VectorComplex tau); + public static int hermtd_unpack (MatrixComplex A, VectorComplex tau, MatrixComplex Q, Vector diag, Vector subdiag); + public static int hermtd_unpack_T (MatrixComplex A, Vector diag, Vector subdiag); + + public static int hessenberg_decomp (Matrix A, Vector tau); + public static int hessenberg_unpack (Matrix H, Vector tau, Matrix U); + public static int hessenberg_unpack_accum (Matrix H, Vector tau, Matrix V); + public static int hessenberg_set_zero (Matrix H); + + public static int hesstri_decomp (Matrix A, Matrix B, Matrix U, Matrix V, Vector work); + + public static int bidiag_decomp (Matrix A, Vector tau_U, Vector tau_V); + public static int bidiag_unpack (Matrix A, Vector tau_U, Matrix U, Vector tau_V, Matrix V, Vector diag, Vector superdiag); + public static int bidiag_unpack2 (Matrix A, Vector tau_U, Vector tau_V, Matrix V); + public static int bidiag_unpack_B (Matrix A, Vector diag, Vector superdiag); + + public static int householder_tansform (Vector v); + public static Complex complex_householder_transform (VectorComplex V); + public static int householder_hm (double tau, Vector v, Matrix A); + public static int complex_householder_hm (Complex tau, VectorComplex V, MatrixComplex A); + public static int householder_mh (double tau, Vector v, Matrix A); + public static int complex_householder_mh (Complex tau, VectorComplex V, MatrixComplex A); + public static int householder_hv (double tau, Vector v, Vector w); + public static int complex_householder_hv (Complex tau, VectorComplex V, VectorComplex w); + + public static int HH_solve (Matrix A, Vector b, Vector x); + public static int HH_svx (Matrix A, Vector x); + + public static int solve_tridiag (Vector diag, Vector e, Vector f, Vector b, Vector x); + public static int solve_symm_tridiag (Vector diag, Vector e, Vector b, Vector x); + public static int solve_cyc_tridiag (Vector diag, Vector e, Vector f, Vector b, Vector x); + public static int solve_symm_cyc_tridiag (Vector diag, Vector e, Vector b, Vector x); + + public static int balance_matrix (Matrix A, Vector D); + } + + + /* + * Eigensystems + */ + [CCode (cname="gsl_eigen_sort_t", cprefix="GSL_EIGEN_SORT_", cheader_filename="gsl/gsl_eigen.h")] + public enum EigenSortType + { + VAL_ASC, + VAL_DESC, + ABS_ASC, + ABS_DESC + } + + [Compact] + [CCode (cname="gsl_eigen_symm_workspace", free_function="gsl_eigen_symm_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenSymmWorkspace + { + public size_t size; + public double* d; + public double* sd; + + [CCode (cname="gsl_eigen_symm_alloc")] + public EigenSymmWorkspace (size_t n); + [CCode (cname="gsl_eigen_symm", instance_pos=-1)] + public int init (Matrix A, Vector eval); + } + + [Compact] + [CCode (cname="gsl_eigen_symmv_workspace", free_function="gsl_eigen_symmv_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenSymmvWorkspace + { + public size_t size; + public double* d; + public double* sd; + public double* gc; + public double* gs; + + [CCode (cname="gsl_eigen_symmv_alloc")] + public EigenSymmvWorkspace (size_t n); + [CCode (cname="gsl_eigen_symmv", instance_pos=-1)] + public int init (Matrix A, Vector eval, Matrix evec); + } + + [Compact] + [CCode (cname="gsl_eigen_herm_workspace", free_function="gsl_eigen_herm_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenHermWorkspace + { + public size_t size; + public double* d; + public double* sd; + public double* tau; + + [CCode (cname="gsl_eigen_herm_alloc")] + public EigenHermWorkspace (size_t n); + [CCode (cname="gsl_eigen_herm", instance_pos=-1)] + public int init (MatrixComplex A, VectorComplex eval); + } + + [Compact] + [CCode (cname="gsl_eigen_hermv_workspace", free_function="gsl_eigen_hermv_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenHermvWorkspace + { + public size_t size; + public double* d; + public double* sd; + public double* tau; + public double* gc; + public double* gs; + + [CCode (cname="gsl_eigen_hermv_alloc")] + public EigenHermvWorkspace (size_t n); + [CCode (cname="gsl_eigen_hermv", instance_pos=-1)] + public int init (MatrixComplex A, VectorComplex eval, MatrixComplex evec); + } + + [Compact] + [CCode (cname="gsl_eigen_nonsymm_workspace", free_function="gsl_eigen_nonsymm_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenNonsymmWorkspace + { + public size_t size; + public Vector diag; + public Vector tau; + public Matrix Z; + public int do_balance; + size_t n_evals; + + [CCode (cname="gsl_eigen_nonsymm_alloc")] + public EigenNonsymmWorkspace (size_t n); + [CCode (cname="gsl_eigen_nonsymm_params", instance_pos=-1)] + public void params (int compute_t, int balance); + [CCode (cname="gsl_eigen_nonsymm", instance_pos=-1)] + public int init (Matrix A, VectorComplex eval); + [CCode (cname="gsl_eigen_nonsymm_Z", instance_pos=-1)] + public int init_Z (Matrix A, VectorComplex eval, Matrix Z); + } + + [Compact] + [CCode (cname="gsl_eigen_nonsymmv_workspace", free_function="gsl_eigen_nonsymmv_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenNonsymmvWorkspace + { + public size_t size; + public Vector work; + public Vector work2; + public Vector work3; + public Matrix Z; + public EigenNonsymmWorkspace nonsymm_workspace_p; + + [CCode (cname="gsl_eigen_nonsymmv_alloc")] + public EigenNonsymmvWorkspace (size_t n); + [CCode (cname="gsl_eigen_nonsymmv", instance_pos=-1)] + public int init (Matrix A, VectorComplex eval, MatrixComplex evec); + [CCode (cname="gsl_eigen_nonsymmv_Z", instance_pos=-1)] + public int init_Z (Matrix A, VectorComplex eval, MatrixComplex evec, Matrix Z); + } + + [Compact] + [CCode (cname="gsl_eigen_gensymm_workspace", free_function="gsl_eigen_gensymm_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenGensymmWorkspace + { + public size_t size; + public EigenSymmWorkspace symm_workspace_p; + + [CCode (cname="gsl_eigen_gensymm_alloc")] + public EigenGensymmWorkspace (size_t n); + [CCode (cname="gsl_eigen_gensymm", instance_pos=-1)] + public int init (Matrix A, Matrix B, Vector eval); + } + + [Compact] + [CCode (cname="gsl_eigen_gensymmv_workspace", free_function="gsl_eigen_gensymmv_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenGensymmvWorkspace + { + public size_t size; + public EigenSymmvWorkspace symmv_workspace_p; + + [CCode (cname="gsl_eigen_gensymmv_alloc")] + public EigenGensymmvWorkspace (size_t n); + [CCode (cname="gsl_eigen_gensymmv", instance_pos=-1)] + public int init (Matrix A, Matrix B, Vector eval, Matrix evec); + } + + [Compact] + [CCode (cname="gsl_eigen_genherm_workspace", free_function="gsl_eigen_genherm_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenGenhermWorkspace + { + public size_t size; + public EigenHermWorkspace herm_workspace_p; + + [CCode (cname="gsl_eigen_genherm_alloc")] + public EigenGenhermWorkspace (size_t n); + [CCode (cname="gsl_eigen_genherm", instance_pos=-1)] + public int init (MatrixComplex A, MatrixComplex B, Vector eval); + } + + [Compact] + [CCode (cname="gsl_eigen_genhermv_workspace", free_function="gsl_eigen_genhermv_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenGenhermvWorkspace + { + public size_t size; + public EigenHermvWorkspace hermv_workspace_p; + + [CCode (cname="gsl_eigen_genhermv_alloc")] + public EigenGenhermvWorkspace (size_t n); + [CCode (cname="gsl_eigen_genhermv", instance_pos=-1)] + public int init (MatrixComplex A, MatrixComplex B, Vector eval, MatrixComplex evec); + } + + [Compact] + [CCode (cname="gsl_eigen_gen_workspace", free_function="gsl_eigen_gen_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenGenWorkspace + { + public size_t size; + public Vector work; + public size_t n_evals; + public size_t max_iterations; + public size_t n_iter; + public double eshift; + public int needtop; + public double atol; + public double btol; + public double ascale; + public double bscale; + public Matrix H; + public Matrix R; + public int compute_s; + public int compute_t; + public Matrix Q; + public Matrix Z; + + [CCode (cname="gsl_eigen_gen_alloc")] + public EigenGenWorkspace (size_t n); + [CCode (cname="gsl_eigen_gen_params", instance_pos=-1)] + public void params (int compute_s, int compute_t, int balance); + [CCode (cname="gsl_eigen_gen", instance_pos=-1)] + public int init (Matrix A, Matrix B, VectorComplex alpha, Vector beta); + [CCode (cname="gsl_eigen_gen_QZ", instance_pos=-1)] + public int init_QZ (Matrix A, Matrix B, VectorComplex alpha, Vector beta, Matrix Q, Matrix Z); + } + + [Compact] + [CCode (cname="gsl_eigen_genv_workspace", free_function="gsl_eigen_genv_free", cheader_filename="gsl/gsl_eigen.h")] + public class EigenGenvWorkspace + { + public size_t size; + public Vector work1; + public Vector work2; + public Vector work3; + public Vector work4; + public Vector work5; + public Vector work6; + public Matrix Q; + public Matrix Z; + public EigenGenWorkspace gen_workspace_p; + + [CCode (cname="gsl_eigen_genv_alloc")] + public EigenGenvWorkspace (size_t n); + [CCode (cname="gsl_eigen_genv", instance_pos=-1)] + public int init (Matrix A, Matrix B, VectorComplex alpha, Vector beta, MatrixComplex evec); + [CCode (cname="gsl_eigen_genv_QZ", instance_pos=-1)] + public int init_QZ (Matrix A, Matrix B, VectorComplex alpha, Vector beta, MatrixComplex evec, Matrix Q, Matrix Z); + } + + [CCode (lower_case_cprefix="gsl_eigen_", cheader_filename="gsl/gsl_eigen.h")] + namespace EigenSort + { + public static int symmv_sort (Vector eval, Matrix evec, EigenSortType sort_type); + public static int hermv_sort (Vector eval, MatrixComplex evec, EigenSortType sort_type); + public static int nonsymmv_sort (VectorComplex eval, MatrixComplex evec, EigenSortType sort_type); + public static int gensymmv_sort (Vector eval, Matrix evec, EigenSortType sort_type); + public static int genhermv_sort (Vector eval, MatrixComplex evec, EigenSortType sort_type); + public static int genv_sort (VectorComplex alpha, Vector beta, MatrixComplex evec, EigenSortType sort_type); + } + + + /* + * Fast Fourier Transforms (FFTs) + */ + [CCode (cname="gsl_fft_direction", cheader_filename="gsl/gsl_fft.h")] + public enum FFTDirection + { + forward = -1, + backward = 1 + } + + [Compact] + [CCode (cname="gsl_fft_complex_wavetable", cheader_filename="gsl/gsl_fft_complex.h")] + public class FFTComplexWavetable + { + public size_t n; + public size_t nf; + public size_t[64] factor; + public Complex[64] twiddle; + public Complex trig; + + [CCode (cname="gsl_fft_complex_wavetable_alloc")] + public FFTComplexWavetable (size_t n); + public int memcpy (FFTComplexWavetable src); + } + + [Compact] + [CCode (cname="gsl_fft_complex_workspace", cheader_filename="gsl/gsl_fft_complex.h")] + public class FFTComplexWorkspace + { + size_t n; + double *scratch; + + [CCode (cname="gsl_fft_complex_workspace_alloc")] + public FFTComplexWorkspace (size_t n); + } + + [Compact] + [CCode (lower_case_cprefix="gsl_fft_complex_", cheader_filename="gsl/gsl_fft_complex.h")] + namespace FFTComplex + { + [NoArrayLength] + public static int radix2_forward (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_transform (double[] data, size_t stride, size_t n, FFTDirection sign); + [NoArrayLength] + public static int radix2_backward (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_inverse (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_dif_forward (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_dif_transform (double[] data, size_t stride, size_t n, FFTDirection sign); + [NoArrayLength] + public static int radix2_dif_backward (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_dif_inverse (double[] data, size_t stride, size_t n); + + [NoArrayLength] + public static int forward (double[] data, size_t stride, size_t n, FFTComplexWavetable wavetable, FFTComplexWorkspace work); + [NoArrayLength] + public static int transform (double[] data, size_t stride, size_t n, FFTComplexWavetable wavetable, FFTComplexWorkspace work, FFTDirection sign); + [NoArrayLength] + public static int backward (double[] data, size_t stride, size_t n, FFTComplexWavetable wavetable, FFTComplexWorkspace work); + [NoArrayLength] + public static int inverse (double[] data, size_t stride, size_t n, FFTComplexWavetable wavetable, FFTComplexWorkspace work); + } + + [Compact] + [CCode (cname="gsl_fft_real_wavetable", cheader_filename="gsl/gsl_fft_real.h")] + public class FFTRealWavetable + { + public size_t n; + public size_t nf; + public size_t[64] factor; + public Complex[64] twiddle; + public Complex trig; + + [CCode (cname="gsl_fft_real_wavetable_alloc")] + public FFTRealWavetable (size_t n); + } + + [Compact] + [CCode (cname="gsl_fft_real_workspace", cheader_filename="gsl/gsl_fft_real.h")] + public class FFTRealWorkspace + { + size_t n; + double *scratch; + + [CCode (cname="gsl_fft_real_workspace_alloc")] + public FFTRealWorkspace (size_t n); + } + + [Compact] + [CCode (lower_case_cprefix="gsl_fft_real_", cheader_filename="gsl/gsl_fft_real.h")] + namespace FFTReal + { + [NoArrayLength] + public static int radix2_forward (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int transform (double[] data, size_t stride, size_t n, FFTRealWavetable wavetable, FFTRealWorkspace work); + [NoArrayLength] + public static int unpack (double[] real_coefficient, double[] complex_coeficient, size_t stride, size_t n); + } + + [Compact] + [CCode (cname="gsl_fft_halfcomplex_wavetable", cheader_filename="gsl/gsl_fft_halfcomplex.h")] + public class FFTHalfcomplexWavetable + { + public size_t n; + public size_t nf; + public size_t[64] factor; + public Complex[64] twiddle; + public Complex trig; + + [CCode (cname="gsl_fft_halfcomplex_wavetable_alloc")] + public FFTHalfcomplexWavetable (size_t n); + } + + [CCode (lower_case_cprefix="gsl_fft_halfcomplex_", cheader_filename="gsl/gsl_fft_halfcomplex.h")] + namespace FFTHalfcomplex + { + [NoArrayLength] + public static int radix2_inverse (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_backward (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_transform (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static int backward (double[] data, size_t stride, size_t n, FFTHalfcomplexWavetable wavetable, FFTRealWorkspace work); + [NoArrayLength] + public static int inverse (double[] data, size_t stride, size_t n, FFTHalfcomplexWavetable wavetable, FFTRealWorkspace work); + [NoArrayLength] + public static int transform (double[] data, size_t stride, size_t n, FFTHalfcomplexWavetable wavetable, FFTRealWorkspace work); + [NoArrayLength] + public static int unpack (double[] halfcomplex_coefficient, double[] complex_coefficient, size_t stride, size_t n); + [NoArrayLength] + public static int radix2_unpack (double[] halfcomplex_coefficient, double[] complex_coefficient, size_t stride, size_t n); + } + + + /* + * Numerical Integration + */ + [CCode (cprefix="GSL_INTEG_", cheader_filename="gsl/gsl_integration.h")] + public enum QAWO + { + COSINE, + SINE + } + + [CCode (cprefix="GSL_INTEG_", cheader_filename="gsl/gsl_integration.h")] + public enum GaussRules + { + GAUSS15, + GAUSS21, + GAUSS31, + GAUSS41, + GAUSS51, + GAUSS61 + } + + [Compact] + [CCode (cname="gsl_integration_workspace", cheader_filename="gsl/gsl_integration.h")] + public class IntegrationWorkspace + { + public size_t limit; + public size_t size; + public size_t nrmax; + public size_t i; + public size_t maximum_level; + public double* alist; + public double* blist; + public double* rlist; + public double* elist; + public size_t* order; + public size_t* level; + + [CCode (cname="gsl_integration_workspace_alloc")] + public IntegrationWorkspace (size_t n); + } + + [Compact] + [CCode (cname="gsl_integration_qaws_table", cheader_filaname="gsl/gsl_integration.h")] + public class IntegrationQAWSTable + { + public double alpha; + public double beta; + public int mu; + public int nu; + public double[25] ri; + public double[25] rj; + public double[25] rg; + public double[25] rh; + + [CCode (cname="gsl_integration_qaws_table_alloc")] + public IntegrationQAWSTable (double alpha, double beta, int mu, int nu); + public int @set (double alpha, double beta, int mu, int nu); + } + + [Compact] + [CCode (cname="gsl_integration_qawo_table", unref="gsl_integration_qawo_table_free", cheader_filename="gsl/gsl_integration.h")] + public class IntegrationQAWOTable + { + public size_t n; + public double omega; + public double L; + public double par; + public QAWO sine; + public double* chebmo; + + [CCode (cname="gsl_integration_qawo_table_alloc")] + public IntegrationQAWOTable (double omega, double L, QAWO sine, size_t n); + public int @set (double omega, double L, QAWO sine); + public int set_length (double L); + } + + [CCode (cname="gsl_integration", cheader_filename="gsl/gsl_integration.h")] + namespace Integration + { + public static void qk15 (Function* f, double a, double b, out double result, out double abserr, out double resabs, out double resasc); + public static void qk21 (Function* f, double a, double b, out double result, out double abserr, out double resabs, out double resasc); + public static void qk31 (Function* f, double a, double b, out double result, out double abserr, out double resabs, out double resasc); + public static void qk41 (Function* f, double a, double b, out double result, out double abserr, out double resabs, out double resasc); + public static void qk51 (Function* f, double a, double b, out double result, out double abserr, out double resabs, out double resasc); + public static void qk61 (Function* f, double a, double b, out double result, out double abserr, out double resabs, out double resasc); + public static void qcheb (Function* f, double a, double b, out double cheb12, out double cheb24); + + [NoArrayLength] + public static void qk (int n, double[] xgk, double[] wg, double[] wgk, double[] fv1, double[] fv2, Function* f, double a, double b, out double result, out double abserr, out double resabs, double resasc); + public static int qng (Function* f, double a, double b, double epsabs, double epsrel, out double result, out double abserr, out size_t neval); + public static int qag (Function* f, double a, double b, double epsabs, double epsrel, size_t limit, int key, IntegrationWorkspace workspace, out double result, out double abserr); + public static int qagi (Function* f, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, out double result, out double abserr); + public static int qagiu (Function* f, double a, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, out double result, out double abserr); + public static int qagil (Function* f, double b, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, out double result, out double abserr); + public static int qags (Function* f, double a, double b, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, out double result, out double abserr); + [NoArrayLength] + public static int qagp (Function* f, double[] pts, size_t npts, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, out double result, out double abserr); + public static int qawc (Function* f, double a, double b, double c, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, out double result, out double abserr); + public static int qaws (Function* f, double a, double b, IntegrationQAWSTable t, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, out double result, out double abserr); + public static int qawo (Function* f, double a, double epsabs, double epsrel, size_t limit, IntegrationWorkspace workspace, IntegrationQAWOTable wf, out double result, out double abserr); + public static int qawf (Function* f, double a, double epsabs, size_t limit, IntegrationWorkspace workspace, IntegrationWorkspace cycle_workspace, IntegrationQAWOTable wf, out double result, out double abserr); + } + + + /* + * Random Number Generation + */ + static delegate void RNGSetState (void *state, ulong seed); + static delegate ulong RNGGetState (void* state); + static delegate double RNGGetDouble (void* state); + + [SimpleType] + [CCode (cname="gsl_rng_type", cheader_filename="gsl/gsl_rng.h")] + public struct RNGType + { + public string name; + public ulong max; + public ulong min; + public size_t size; + public RNGSetState @set; + public RNGGetState @get; + public RNGGetDouble get_double; + } + + [CCode (lower_case_cprefix="gsl_rng_", cheader_filename="gsl/gsl_rng.h")] + namespace RNGTypes + { + public static RNGType* borosh13; + public static RNGType* coveyou; + public static RNGType* cmrg; + public static RNGType* fishman18; + public static RNGType* fishman20; + public static RNGType* fishman2x; + public static RNGType* gfsr4; + public static RNGType* knuthran; + public static RNGType* knuthran2; + public static RNGType* knuthran2002; + public static RNGType* lecuyer21; + public static RNGType* minstd; + public static RNGType* mrg; + public static RNGType* mt19937; + public static RNGType* mt19937_1999; + public static RNGType* mt19937_1998; + public static RNGType* r250; + public static RNGType* ran0; + public static RNGType* ran1; + public static RNGType* ran2; + public static RNGType* ran3; + public static RNGType* rand; + public static RNGType* rand48; + public static RNGType* random128_bsd; + public static RNGType* random128_glibc2; + public static RNGType* random128_libc5; + public static RNGType* random256_bsd; + public static RNGType* random256_glibc2; + public static RNGType* random256_libc5; + public static RNGType* random32_bsd; + public static RNGType* random32_glibc2; + public static RNGType* random32_libc5; + public static RNGType* random64_bsd; + public static RNGType* random64_glibc2; + public static RNGType* random64_libc5; + public static RNGType* random8_bsd; + public static RNGType* random8_glibc2; + public static RNGType* random8_libc5; + public static RNGType* random_bsd; + public static RNGType* random_glibc2; + public static RNGType* random_libc5; + public static RNGType* randu; + public static RNGType* ranf; + public static RNGType* ranlux; + public static RNGType* ranlux389; + public static RNGType* ranlxd1; + public static RNGType* ranlxd2; + public static RNGType* ranlxs0; + public static RNGType* ranlxs1; + public static RNGType* ranlxs2; + public static RNGType* ranmar; + public static RNGType* slatec; + public static RNGType* taus; + public static RNGType* taus2; + public static RNGType* taus113; + public static RNGType* transputer; + public static RNGType* tt800; + public static RNGType* uni; + public static RNGType* uni32; + public static RNGType* vax; + public static RNGType* waterman14; + public static RNGType* zuf; + public static RNGType* @default; + public static ulong default_seed; + } + + [Compact] + [CCode (cname="gsl_rng", cheader_filename="gsl/gsl_rng.h")] + public class RNG + { + public RNGType* type; + public void* state; + + [CCode (cname="gsl_rng_alloc")] + public RNG (RNGType* T); + public void @set (ulong s); + public ulong @get (); + public double uniform (); + public double uniform_pos (); + public ulong uniform_int (ulong n); + public string name (); + public ulong max (); + public ulong min (); + public size_t size (); + public static RNGType* env_setup (); + public int memcpy (RNG src); + public RNG clone (); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + + public void print_state (); + } + + [CCode (lower_case_cprefix="gsl_cdf_", cheader_filename="gsl/gsl_cdf.h")] + namespace CDF + { + public static double ugaussian_P (double x); + public static double ugaussian_Q (double x); + + public static double ugaussian_Pinv (double P); + public static double ugaussian_Qinv (double Q); + + public static double gaussian_P (double x, double sigma); + public static double gaussian_Q (double x, double sigma); + + public static double gaussian_Pinv (double P, double sigma); + public static double gaussian_Qinv (double Q, double sigma); + + public static double gamma_P (double x, double a, double b); + public static double gamma_Q (double x, double a, double b); + + public static double gamma_Pinv (double P, double a, double b); + public static double gamma_Qinv (double Q, double a, double b); + + public static double cauchy_P (double x, double a); + public static double cauchy_Q (double x, double a); + + public static double cauchy_Pinv (double P, double a); + public static double cauchy_Qinv (double Q, double a); + + public static double laplace_P (double x, double a); + public static double laplace_Q (double x, double a); + + public static double laplace_Pinv (double P, double a); + public static double laplace_Qinv (double Q, double a); + + public static double rayleigh_P (double x, double sigma); + public static double rayleigh_Q (double x, double sigma); + + public static double rayleigh_Pinv (double P, double sigma); + public static double rayleigh_Qinv (double Q, double sigma); + + public static double chisq_P (double x, double nu); + public static double chisq_Q (double x, double nu); + + public static double chisq_Pinv (double P, double nu); + public static double chisq_Qinv (double Q, double nu); + + public static double exponential_P (double x, double mu); + public static double exponential_Q (double x, double mu); + + public static double exponential_Pinv (double P, double mu); + public static double exponential_Qinv (double Q, double mu); + + public static double exppow_P (double x, double a, double b); + public static double exppow_Q (double x, double a, double b); + + public static double tdist_P (double x, double nu); + public static double tdist_Q (double x, double nu); + + public static double tdist_Pinv (double P, double nu); + public static double tdist_Qinv (double Q, double nu); + + public static double fdist_P (double x, double nu1, double nu2); + public static double fdist_Q (double x, double nu1, double nu2); + + public static double fdist_Pinv (double P, double nu1, double nu2); + public static double fdist_Qinv (double Q, double nu1, double nu2); + + public static double beta_P (double x, double a, double b); + public static double beta_Q (double x, double a, double b); + + public static double beta_Pinv (double P, double a, double b); + public static double beta_Qinv (double Q, double a, double b); + + public static double flat_P (double x, double a, double b); + public static double flat_Q (double x, double a, double b); + + public static double flat_Pinv (double P, double a, double b); + public static double flat_Qinv (double Q, double a, double b); + + public static double lognormal_P (double x, double zeta, double sigma); + public static double lognormal_Q (double x, double zeta, double sigma); + + public static double lognormal_Pinv (double P, double zeta, double sigma); + public static double lognormal_Qinv (double Q, double zeta, double sigma); + + public static double gumbel1_P (double x, double a, double b); + public static double gumbel1_Q (double x, double a, double b); + + public static double gumbel1_Pinv (double P, double a, double b); + public static double gumbel1_Qinv (double Q, double a, double b); + + public static double gumbel2_P (double x, double a, double b); + public static double gumbel2_Q (double x, double a, double b); + + public static double gumbel2_Pinv (double P, double a, double b); + public static double gumbel2_Qinv (double Q, double a, double b); + + public static double weibull_P (double x, double a, double b); + public static double weibull_Q (double x, double a, double b); + + public static double weibull_Pinv (double P, double a, double b); + public static double weibull_Qinv (double Q, double a, double b); + + public static double pareto_P (double x, double a, double b); + public static double pareto_Q (double x, double a, double b); + + public static double pareto_Pinv (double P, double a, double b); + public static double pareto_Qinv (double Q, double a, double b); + + public static double logistic_P (double x, double a); + public static double logistic_Q (double x, double a); + + public static double logistic_Pinv (double P, double a); + public static double logistic_Qinv (double Q, double a); + + public static double binomial_P (uint k, double p, uint n); + public static double binomial_Q (uint k, double p, uint n); + + public static double poisson_P (uint k, double mu); + public static double poisson_Q (uint k, double mu); + + public static double geometric_P (uint k, double p); + public static double geometric_Q (uint k, double p); + + public static double negative_binomial_P (uint k, double p, double n); + public static double negative_binomial_Q (uint k, double p, double n); + + public static double pascal_P (uint k, double p, uint n); + public static double pascal_Q (uint k, double p, uint n); + + public static double hypergeometric_P (uint k, uint n1, uint n2, uint t); + public static double hypergeometric_Q (uint k, uint n1, uint n2, uint t); + } + + + /* + * Quasi-Random Sequences + */ + static delegate size_t QRNGStateSize (uint dimension); + static delegate int QRNGInitState (void* state, uint dimension); + static delegate int QRNGGetState2 (void* state, uint dimension, out double x); + + [SimpleType] + [CCode (cname="gsl_qrng_type", cheader_filename="gsl/gsl_qrng.h")] + public struct QRNGType + { + public string name; + public uint max_dimension; + public QRNGStateSize state_size; + public QRNGInitState init_state; + public QRNGGetState2 @get; + } + + [CCode (lower_case_cprefix="gsl_qrng_", cheader_filename="gsl/gsl_qrng.h")] + namespace QRNGAlgorithms + { + public static QRNGType* niederreiter_2; + public static QRNGType* sobol; + public static QRNGType* halton; + public static QRNGType* reversehalton; + } + + [Compact] + [CCode (cname="gsl_qrng", cheader_filename="gsl/gsl_qrng.h")] + public class QRNG + { + public QRNGType* type; + public uint dimension; + size_t state_size; + void* state; + + [CCode (cname="gsl_qrng_alloc")] + public QRNG (QRNGType* T, uint d); + public void init (); + public int memcpy (QRNG src); + public QRNG clone (); + public string name (); + public size_t size (); + [NoArrayLength] + public int @get (double[] x); + } + + + /* + * Random Number Distributions + */ + [CCode (lower_case_cprefix="gsl_ran_", cheader_filename="gsl/gsl_randist.h")] + namespace Randist + { + public static uint bernoulli (RNG r, double p); + public static double bernoulli_pdf (uint k, double p); + + public static double beta (RNG r, double a, double b); + public static double beta_pdf (double x, double a, double b); + + public static uint binomial (RNG r, double p, uint n); + public static uint binomial_knuth (RNG r, double p, uint n); + public static uint binomial_tpe (RNG r, double p, uint n); + public static double binomial_pdf (uint k, double p, uint n); + + public static double exponential (RNG r, double mu); + public static double exponential_pdf (double x, double mu); + + public static double exppow (RNG r, double a, double b); + public static double exppow_pdf (double x, double a, double b); + + public static double cauchy (RNG r, double a); + public static double cauchy_pdf (double x, double a); + + public static double chisq (RNG r, double nu); + public static double chisq_pdf (double x, double nu); + + public static void dirichlet (RNG r, size_t K, out double alpha, out double theta); + public static double dirichlet_pdf (size_t K, out double alpha, out double theta); + public static double dirichlet_lnpdf (size_t K, out double alpha, out double theta); + + public static double erlang (RNG r, double a, double n); + public static double erlang_pdf (double x, double a, double n); + + public static double fdist (RNG r, double nu1, double nu2); + public static double fdist_pdf (double x, double nu1, double nu2); + + public static double flat (RNG r, double a, double b); + public static double flat_pdf (double x, double a, double b); + + public static double gamma (RNG r, double a, double b); + public static double gamma_int (RNG r, uint a); + public static double gamma_pdf (double x, double a, double b); + public static double gamma_mt (RNG r, double a, double b); + public static double gamma_knuth (RNG r, double a, double b); + + public static double gaussian (RNG r, double sigma); + public static double gaussian_ratio_method (RNG r, double sigma); + public static double gaussian_ziggurat (RNG r, double sigma); + public static double gaussian_pdf (double x, double sigma); + + public static double ugaussian (RNG r); + public static double ugaussian_ratio_method (RNG r); + public static double ugaussian_pdf (double x); + + public static double gaussian_tail (RNG r, double a, double sigma); + public static double gaussian_tail_pdf (double x, double a, double sigma); + + public static double ugaussian_tail (RNG r, double a); + public static double ugaussian_tail_pdf (double x, double a); + + public static void bivariate_gaussian (RNG r, double sigma_x, double sigma_y, double rho, out double x, out double y); + public static double bivariate_gaussian_pdf (double x, double y, double sigma_x, double sigma_y, double rho); + + public static double landau (RNG r); + public static double landau_pdf (double x); + + public static uint geometric (RNG r, double p); + public static double geometric_pdf (uint k, double p); + + public static uint hypergeometric (RNG r, uint n1, uint n2, uint t); + public static double hypergeometric_pdf (uint k, uint n1, uint n2, uint t); + + public static double gumbel1 (RNG r, double a, double b); + public static double gumbel1_pdf (double x, double a, double b); + + public static double gumbel2 (RNG r, double a, double b); + public static double gumbel2_pdf (double x, double a, double b); + + public static double logistic (RNG r, double a); + public static double logistic_pdf (double x, double a); + + public static double lognormal (RNG r, double zeta, double sigma); + public static double lognormal_pdf (double x, double zeta, double sigma); + + public static uint logarithmic (RNG r, double p); + public static double logarithmic_pdf (uint k, double p); + + [NoArrayLength] + public static void multinomial (RNG r, size_t K, uint N, double[] p, uint[] n); + [NoArrayLength] + public static double multinomial_pdf (size_t K, double[] p, uint[] n); + [NoArrayLength] + public static double multinomial_lnpdf (size_t K, double[] p, uint[] n); + + public static uint negative_binomial (RNG r, double p, double n); + public static double negative_binomial_pdf (uint k, double p, double n); + + public static uint pascal (RNG r, double p, uint n); + public static double pascal_pdf (uint k, double p, uint n); + + public static double pareto (RNG r, double a, double b); + public static double pareto_pdf (double x, double a, double b); + + public static uint poisson (RNG r, double mu); + [NoArrayLength] + public static void poisson_array (RNG r, size_t n, uint[] array, double mu); + public static double poisson_pdf (uint k, double mu); + + public static double rayleigh (RNG r, double sigma); + public static double rayleigh_pdf (double x, double sigma); + + public static double rayleigh_tail (RNG r, double a, double sigma); + public static double rayleigh_tail_pdf (double x, double a, double sigma); + + public static double tdist (RNG r, double nu); + public static double tdist_pdf (double x, double nu); + + public static double laplace (RNG r, double a); + public static double laplace_pdf (double x, double a); + + public static double levy (RNG r, double c, double alpha); + public static double levy_skew (RNG r, double c, double alpha, double beta); + + public static double weibull (RNG r, double a, double b); + public static double weibull_pdf (double x, double a, double b); + + public static void dir_2d (RNG r, out double x, out double y); + public static void dir_2d_trig_method (RNG r, out double x, out double y); + public static void dir_3d (RNG r, out double x, out double y, out double z); + public static void dir_nd (RNG r, size_t n, out double x); + + public static void shuffle (RNG r, void* b, size_t nmembm, size_t size); + public static int choose (RNG r, void* dest, size_t k, void* src, size_t n, size_t size); + public static void sample (RNG r, void* dest, size_t k, void* src, size_t n, size_t size); + } + + [Compact] + [CCode (cname="gsl_ran_discrete_t", cprefix="gsl_ran_discrete_", cheader_filename="gsl/gsl_randist.h")] + public class RanDiscrete + { + public size_t K; + public size_t* A; + public double* F; + + [CCode (cname="gsl_ran_discrete_preproc")] + public RanDiscrete (size_t K, double* P); + [CCode (cname="gsl_ran_discrete")] + public size_t discrete (RNG g); + [CCode (instance_pos=-1)] + public double pdf (size_t k); + } + + + /* + * Statistics + */ + [CCode (lower_case_cprefix="gsl_stats_", cheader_filename="gsl/gsl_statistics.h")] + namespace Stats + { + [NoArrayLength] + public static double mean (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double variance (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double variance_m (double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double sd (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double sd_m (double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double tss (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double tss_m (double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double variance_with_fixed_mean (double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double sd_with_fixed_mean (double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double absdev (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double absdev_m (double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double skew (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double skew_m_sd (double[] data, size_t stride, size_t n, double mean, double sd); + [NoArrayLength] + public static double kurtosis (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double kurtosis_m_sd (double[] data, size_t stride, size_t n, double mean, double sd); + [NoArrayLength] + public static double lag1_autocorrelation (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double lag1_autocorrelation_m (double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double covariance (double[] data1, size_t stride1, double[] data2, size_t stride2, size_t n); + [NoArrayLength] + public static double covariance_m (double[] data1, size_t stride1, double[] data2, size_t stride2, size_t n, double mean1, double mean2); + [NoArrayLength] + public static double correlation (double[] data1, size_t stride1, double[] data2, size_t stride2, size_t n); + + [NoArrayLength] + public static double wmean (double[] w, size_t wstride, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double wvariance (double[] w, size_t wstride, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double wvariance_m (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double wmean); + [NoArrayLength] + public static double wsd (double[] w, size_t wstride, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double wsd_m (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double wmean); + [NoArrayLength] + public static double wtss (double[] w, size_t wstride, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double wtss_m (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double mean); + [NoArrayLength] + public static double wvariance_with_fixed_mean (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double wmean); + [NoArrayLength] + public static double wsd_with_fixed_mean (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double wmean); + [NoArrayLength] + public static double wabsdev (double[] w, size_t wstride, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double wabsdev_m (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double wmean); + [NoArrayLength] + public static double wskew (double[] w, size_t wstride, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double wskew_m_sd (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double wmean, double wsd); + [NoArrayLength] + public static double wkurtosis (double[] w, size_t wstride, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double wkurtosis_m_sd (double[] w, size_t wstride, double[] data, size_t stride, size_t n, double wmean, double wsd); + + [NoArrayLength] + public static double max (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static double min (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static void minmax (out double min, out double max, double[] data, size_t stride, size_t n); + [NoArrayLength] + public static size_t max_index (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static size_t min_index (double[] data, size_t stride, size_t n); + [NoArrayLength] + public static void minmax_index (out size_t min, out size_t max, double[] data, size_t stride, size_t n); + + [NoArrayLength] + public static double median_from_sorted_data (double[] sorted_data, size_t stride, size_t n); + [NoArrayLength] + public static double quantile_from_sorted_data (double[] sorted_data, size_t stride, size_t n, double f); + } + + + /* + * Histograms + */ + [Compact] + [CCode (cname="gsl_histogram", cheader_filename="gsl/gsl_histogram.h")] + public class Histogram + { + public size_t n; + public double* range; + public double* bin; + + [CCode (cname="gsl_histogram_alloc")] + public Histogram (size_t n); + [CCode (cname="gsl_histogram_calloc")] + public Histogram.with_zeros (size_t n); + [CCode (cname="gsl_histogram_calloc_uniform")] + public Histogram.uniform (size_t n, double xmin, double xmax); + [NoArrayLength] + [CCode (cname="gsl_histogram_calloc_range")] + public Histogram.range (size_t n, double[] range); + + public int increment (double x); + public int accumulate (double x, double weight); + public int find (double x, out size_t i); + public double @get (size_t i); + public int get_range (size_t i, out double lower, out double upper); + public double max (); + public double min (); + public size_t bins (); + + public void reset (); + + public int set_ranges (double[] range); + public int set_ranges_uniform (double xmin, double xmax); + + public int memcpy (Histogram source); + public Histogram clone(); + + public double max_val (); + public size_t max_bin (); + public double min_val (); + public size_t min_bin (); + + public int equal_bins_p (Histogram h2); + public int add (Histogram h2); + public int sub (Histogram h2); + public int mul (Histogram h2); + public int div (Histogram h2); + public int scale (double scale); + public int shift (double shift); + + public double sigma (); + public double mean (); + public double sum (); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, Histogram h, string range_format, string bin_format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + } + + [Compact] + [CCode (cname="gsl_histogram_pdf", cheader_filename="gsl/gsl_histogram.h")] + public class HistogramPDF + { + public size_t n; + public double* range; + public double* sum ; + + [CCode (cname="gsl_histogram_pdf_alloc")] + public HistogramPDF (size_t n); + public int init (Histogram h); + public double sample (double r); + } + + [Compact] + [CCode (cname="gsl_histogram2d", cheader_filename="gsl/gsl_histogram2d.h")] + public class Histogram2d + { + public size_t nx; + public size_t ny; + public double* xrange; + public double* yrange; + public double* bin; + + [CCode (cname="gsl_histogram2d_alloc")] + public Histogram2d (size_t nx, size_t ny); + [CCode (cname="gsl_histogram2d_calloc")] + public Histogram2d.with_zeros (size_t nx, size_t ny); + [CCode (cname="gsl_histogram2d_calloc_uniform")] + public Histogram2d.uniform (size_t nx, size_t ny, double xmin, double xmax, double ymin, double ymax); + [CCode (cname="gsl_histogram2d_calloc_range")] + public Histogram2d.range (size_t nx, size_t ny, out double xrange, out double yrange); + + public int increment (double x, double y); + public int accumulate (double x, double y, double weight); + public int find (double x, double y, out size_t i, out size_t j); + public double @get (size_t i, size_t j); + public int get_xrange (size_t i, out double xlower, out double xupper); + public int get_yrange (size_t j, out double ylower, out double yupper); + + public double xmax (); + public double xmin (); + public double ymax (); + public double ymin (); + + public void reset (); + + public int set_ranges_uniform (double xmin, double xmax, double ymin, double ymax); + public int set_ranges (double[] xrange, double[] yrange); + + public int memcpy (Histogram2d source); + public Histogram2d clone (); + + public double max_val(); + public void max_bin (out size_t i, out size_t j); + public double min_val(); + public void min_bin (out size_t i, out size_t j); + + public double xmean (); + public double ymean (); + public double xsigma (); + public double ysigma (); + public double cov (); + + public double sum (); + public int equal_bins_p (Histogram h2) ; + public int add (Histogram h2); + public int sub (Histogram h2); + public int mul (Histogram2d h2); + public int div (Histogram2d h2); + public int scale (double scale); + public int shift (double shift); + + [CCode (instance_pos=-1)] + public int fwrite (GLib.FileStream stream); + [CCode (instance_pos=-1)] + public int fread (GLib.FileStream stream); + public static int fprintf (GLib.FileStream stream, Histogram h, string range_format, string bin_format); + [CCode (instance_pos=-1)] + public int fscanf (GLib.FileStream stream); + } + + [Compact] + [CCode (cname="gsl_histogram2d_pdf", cheader_filename="gsl/gsl_histogram2d.h")] + public class Histogram2dPDF + { + public size_t nx; + public size_t ny; + public double* xrange; + public double* yrange; + public double* sum; + + [CCode (cname="gsl_histogram2d_pdf_alloc")] + public Histogram2dPDF (size_t nx, size_t ny); + public int init (Histogram2d h); + public int sample (double r1, double r2, out double x, out double y); + } + + + /* + * N-Tuples + */ + static delegate int NTupleFunc (void* ntuple_data, void* params); + + [SimpleType] + [CCode (cname="gsl_ntuple_select_fn", cheader_filename="gsl/gsl_ntuple.h")] + public struct NTupleSelectFn + { + public NTupleFunc function; + public void* params; + } + + [SimpleType] + [CCode (cname="gsl_ntuple_value_fn", cheader_filename="gsl/gsl_ntuple.h")] + public struct NTupleValueFn + { + public NTupleFunc function; + public void* params; + } + + [Compact] + [CCode (cname="gsl_ntuple", free_function="gsl_ntuple_close", cheader_filename="gsl/gsl_ntuple.h")] + public class NTuple + { + public GLib.FileStream file; + public void* ntrupel_data; + public size_t size; + + public static NTuple open (string filename, void* ntuple_data, size_t size); + public static NTuple create (string filename, void* ntuple_data, size_t size); + public int write (); + public int read (); + public int bookdata (); + + public static int project (Histogram h, NTuple ntuple, NTupleValueFn* value_func, NTupleSelectFn* select_func); + } + + + /* + * Monte Carlo Integration + */ + [CCode (cprefix="GSL_VEGAS_MODE_", cheader_filename="gsl/gsl_monte_vegas.h")] + public enum MonteVegasMode + { + IMPORTANCE, + IMPORTANCE_ONLY, + STRATIFIED + } + + [NoArrayLength] + static delegate double MonteFunc (double[] x_array, size_t dim, void* params); + + [SimpleType] + [CCode (cname="gsl_monte_function", cheader_filanema="gsl/gsl_monte.h")] + public struct MonteFunction + { + public MonteFunc f; + public size_t dim; + public void* params; + } + + [Compact] + [CCode (cname="gsl_monte_plain_state", cprefix="gsl_monte_plain_", cheader_filename="gsl/gsl_monte_plain.h")] + public class MontePlainState + { + public size_t dim; + public double* x; + + [CCode (cname="gsl_monte_plain_alloc")] + public MontePlainState (size_t dim); + public int init (); + [NoArrayLength] + public static int integrate (MonteFunction* f, double[] xl, double[] xu, size_t dim, size_t calls, RNG r, MontePlainState state, out double result, out double abserr); + } + + [Compact] + [CCode (cname="gsl_monte_miser_state", cprefix="gsl_monte_miser_", cheader_filename="gsl/gsl_monte_miser.h")] + public class MonteMiserState + { + public size_t min_calls; + public size_t min_calls_per_bisection; + public double dither; + public double estimate_frac; + public double alpha; + public size_t dim; + public int estimate_style; + public int depth; + public int verbose; + public double* x; + public double* xmid; + public double* sigma_l; + public double* sigma_r; + public double* fmax_l; + public double* fmax_r; + public double* fmin_l; + public double* fmin_r; + public double* fsum_l; + public double* fsum_r; + public double* fsum2_l; + public double* fsum2_r; + public size_t* hits_l; + public size_t* hits_r; + + [CCode (cname="gsl_monte_miser_alloc")] + public MonteMiserState (size_t dim); + public int init (); + [NoArrayLength] + public static int integrate (MonteFunction* f, double[] xl, double[] xh, size_t dim, size_t calls, RNG r, MonteMiserState state, out double result, out double abserr); + } + + [Compact] + [CCode (cname="gsl_monte_vegas_state", cprefix="gsl_monte_vegas_", cheader_filename="gsl/gsl_monte_vegas.h")] + public class MonteVegasState + { + public size_t dim; + public size_t bins_max; + public uint bins; + public uint boxes; + public double* xi; + public double* xin; + public double* delx; + public double* weight; + public double vol; + public double* x; + public int* bin; + public int* box; + public double* d; + public double alpha; + public int mode; + public int verbose; + public uint iterations; + public int stage; + public double jac; + public double wtd_int_sum; + public double sum_wgts; + public double chi_sum; + public double chisq; + public double result; + public double sigma; + public uint it_start; + public uint it_num; + public uint samples; + public uint calls_per_box; + public GLib.FileStream ostream; + + [CCode (cname="gsl_monte_vegas_alloc")] + public MonteVegasState (size_t dim); + public int init (); + [NoArrayLength] + public static int integrate (MonteFunction* f, double[] xl, double[] xu, size_t dim, size_t calls, RNG r, MonteVegasState state, out double result, out double abserr); + } + + + /* + * Simulated Annealing + */ + [SimpleType] + [CCode (cname="gsl_siman_params_t", cheader_filename="gsl/gsl_siman.h")] + public struct SimanParams + { + public int n_tries; + public int iters_fixed_T; + public double step_size; + public double k; + public double t_initial; + public double mu_t; + public double t_min; + } + + [CCode (lower_case_cprefix="gsl_siman_", cheader_filename="gsl/gsl_siman.h")] + namespace Siman + { + public static delegate double Efunc_t (void *xp); + public static delegate void step_t (RNG r, void *xp, double step_size); + public static delegate double metric_t (void *xp, void* yp); + public static delegate void print_t (void* xp); + public static delegate void copy_t (void* source, void* dest); + public static delegate void copy_construct_t (void* xp); + public static delegate void destroy_t (void* xp); + + public static void solve(RNG r, void *x0_p, Efunc_t Ef, step_t take_step, metric_t distance, print_t print_position, copy_t copyfunc, copy_construct_t copy_constructor, destroy_t destructor, size_t element_size, SimanParams params); + public static void solve_many (RNG r, void *x0_p, Efunc_t Ef, step_t take_step, metric_t distance, print_t print_position, size_t element_size, SimanParams params); + } + + + /* + * Ordinary Differential Equations + */ + [CCode (cprefix="GSL_ODEIV_HADJ_", cheader_filename="gsl/gsl_odeiv.h")] + public enum OdeivHadjustTypes + { + INC, + NIL, + DEC + } + + [NoArrayLength] + static delegate int OdeivFunction (double t, double[] y, double[] dydt, void* params); + [NoArrayLength] + static delegate int OdeivJacobian (double t, double[] y, double[] dfdy, double[] dfdt, void* params); + static delegate void* OdeivStepAlloc (size_t dim); + [NoArrayLength] + static delegate int OdeivStepApply (void* state, size_t dim, double t, double h, double[] y, double[] yerr, double[] dydt_in, double[] dydt_out, OdeivSystem* dydt); + static delegate int OdeivStepReset (void* state, size_t dim); + static delegate uint OdeivStepOrder (void* state); + static delegate void OdeivStepFree (void* state); + static delegate void* OdeivControlAlloc (); + static delegate int OdeivControlInit (void* state, double eps_abs, double eps_rel, double a_y, double a_dydt); + [NoArrayLength] + static delegate int OdeivControlHadjust (void* state, size_t dim, uint ord, double[] y, double[] yerr, double[] yp, double[] h); + static delegate void OdeivControlFree (void* state); + + [SimpleType] + [CCode (cname="gsl_odeiv_system", cheader_filename="gsl/gsl_odeiv.h")] + public struct OdeivSystem + { + public OdeivFunction function; + public OdeivJacobian jacobian; + public size_t dimension; + public void* params; + } + + [SimpleType] + [CCode (cname="gsl_odeiv_step_type", cheader_filename="gsl/gsl_odeiv.h")] + public struct OdeivStepType + { + public string name; + public int can_use_dydt_in; + public int gives_exact_dydt_out; + public OdeivStepAlloc alloc; + public OdeivStepApply apply; + public OdeivStepReset reset; + public OdeivStepOrder order; + public OdeivStepFree free; + } + + [CCode (lower_case_cprefix="gsl_odeiv_step_", cheader_filename="gsl/gsl_odeiv.h")] + namespace OdeivStepTypes + { + public static OdeivStepType* rk2; + public static OdeivStepType* rk4; + public static OdeivStepType* rkf45; + public static OdeivStepType* rkck; + public static OdeivStepType* rk8pd; + public static OdeivStepType* rk2imp; + public static OdeivStepType* rk2simp; + public static OdeivStepType* rk4imp; + public static OdeivStepType* bsimp; + public static OdeivStepType* gear1; + public static OdeivStepType* gear2; + } + + [Compact] + [CCode (cname="gsl_odeiv_step", cheader_filename="gsl/gsl_odeiv.h")] + public class OdeivStep + { + public OdeivStepType* type; + public size_t dimension; + public void* state; + + [CCode (cname="gsl_odeiv_step_alloc")] + public OdeivStep (OdeivStepType* T, size_t dim); + public int reset (); + public string name (); + public uint order (); + + [NoArrayLength] + public int apply (double t, double h, double[] y, double[] yerr, double[] dydt_in, double[] dydt_out, OdeivSystem* dydt); + } + + [SimpleType] + [CCode (cname="gsl_odeiv_control_type", cheader_filename="gsl/gsl_odeiv.h")] + public struct OdeivControlType + { + public string name; + public OdeivControlAlloc alloc; + public OdeivControlInit init; + public OdeivControlHadjust hadjust; + public OdeivControlFree free; + } + + [Compact] + [CCode (cname="gsl_odeiv_control", cheader_filename="gsl/gsl_odeiv.h")] + public class OdeivControl + { + public OdeivControlType* type; + public void* state; + + [CCode (cname="gsl_odeiv_control_alloc")] + public OdeivControl (OdeivControlType* T); + [CCode (cname="gsl_odeiv_control_standard_new")] + public OdeivControl.standard (double eps_abs, double eps_rel, double a_y, double a_dydt); + [CCode (cname="gsl_odeiv_control_y_new")] + public OdeivControl.y (double eps_abs, double eps_rel); + [CCode (cname="gsl_odeiv_control_yp_new")] + public OdeivControl.yp (double eps_abs, double eps_rel); + [CCode (cname="gsl_odeiv_control_scaled_new")] + public OdeivControl.scaled (double eps_abs, double eps_rel, double a_y, double a_dydt, double[] scale_abs); + + public int init (double eps_abs, double eps_rel, double a_y, double a_dydt); + public int hadjust (OdeivStep s, out double y, out double yerr, out double dydt, out double h); + public string name (); + } + + [Compact] + [CCode (cname="gsl_odeiv_evolve", cheader_filename="gsl/gsl_odeiv.h")] + public class OdeivEvolve + { + public size_t dimension; + public double* y0; + public double* yerr; + public double* dydt_in; + public double* dydt_out; + public double last_step; + public ulong count; + public ulong failed_steps; + + [CCode (cname="gsl_odeiv_evolve_alloc")] + public OdeivEvolve (size_t dim); + [NoArrayLength] + public int apply (OdeivControl con, OdeivStep step, OdeivSystem* dydt, double[] t, double t1, double[] h, double[] y); + public int reset (); + } + + + /* + * Interpolation + */ + static delegate void* InterpAlloc (size_t size); + [NoArrayLength] + static delegate int InterpInit (void* t, double[] xa, double[] ya, size_t size); + [NoArrayLength] + static delegate int InterpEval (void* t, double[] xa, double[] ya, size_t size, double x, InterpAccel* i, out double y); + [NoArrayLength] + static delegate int InterpEvalDeriv (void* t, double[] xa, double[] ya, size_t size, double x, InterpAccel* i, out double y_p); + [NoArrayLength] + static delegate int InterpEvalDeriv2 (void* t, double[] xa, double[] ya, size_t size, double x, InterpAccel* i, out double y_pp); + [NoArrayLength] + static delegate int InterpEvalInteg (void* t, double[] xa, double[] ya, size_t size, InterpAccel* i, double a, double b, out double result); + static delegate void InterpFree (void* t); + + [Compact] + [CCode (cname="gsl_interp_accel", cheader_filname="gsl/gsl_interp.h")] + public class InterpAccel + { + public size_t cache; + public size_t miss_count; + public size_t hit_count; + + [CCode (cname="gsl_interp_accel_alloc")] + public InterpAccel (); + public size_t find (double[] x_array, double x); + public int reset (); + } + + [SimpleType] + [CCode (cname="gsl_interp_type", cheader_filename="gsl/gsl_interp.h")] + public struct InterpType + { + public string name; + public uint min_size; + public InterpAlloc alloc; + public InterpInit init; + public InterpEval eval; + public InterpEvalDeriv eval_deriv; + public InterpEvalDeriv2 eval_deriv2; + public InterpEvalInteg eval_integ; + public InterpFree free; + } + + [CCode (lower_case_cprefix="gsl_interp_", cheader_filename="gsl/gsl_interp.h")] + namespace InterpTypes + { + public static InterpType* linear; + public static InterpType* polynomial; + public static InterpType* cspline; + public static InterpType* cspline_periodic; + public static InterpType* akima; + public static InterpType* akima_periodic; + } + + [Compact] + [CCode (cname="gsl_interp", cheader_filename="gsl/gsl_interp.h")] + public class Interp + { + InterpType* type; + public double xmin; + public double xmax; + public size_t size; + public void* state; + + [CCode (cname="gsl_interp_alloc")] + public Interp (InterpType T, size_t n); + [NoArrayLength] + public int init (double[] xa, double[] ya, size_t size); + public string name (); + public uint min_size (); + [NoArrayLength] + public int eval_e (double[] xa, double[] ya, double x, InterpAccel a, out double y); + [NoArrayLength] + public double eval (double[] xa, double[] ya, double x, InterpAccel a); + [NoArrayLength] + public int eval_deriv_e (double[] xa, double[] ya, double x, InterpAccel a, out double d); + [NoArrayLength] + public double eval_deriv (double[] xa, double[] ya, double x, InterpAccel a); + [NoArrayLength] + public int eval_deriv2_e (double[] xa, double[] ya, double x, InterpAccel a, out double d2); + [NoArrayLength] + public double eval_deriv2 (double[] xa, double[] ya, double x, InterpAccel a); + [NoArrayLength] + public int eval_integ_e (double[] xa, double[] ya, double a, double b, InterpAccel acc, out double result); + [NoArrayLength] + public double eval_integ (double[] xa, double[] ya, double a, double b, InterpAccel acc); + [NoArrayLength] + public static size_t bsearch(double[] x_array, double x, size_t index_lo, size_t index_hi); + } + + [Compact] + [CCode (cname="gsl_spline", cheader_filename="gsl/gsl_spline.h")] + public class Spline + { + public Interp interp; + public double* x; + public double* y; + public size_t size; + + [CCode (cname="gsl_spline_alloc")] + public Spline (InterpType* T, size_t size); + [NoArrayLength] + public int init (double[] xa, double[] ya, size_t size); + public string name (); + public uint min_size (); + public int eval_e (double x, InterpAccel a, out double y); + public double eval (double x, InterpAccel a); + public int eval_deriv_e (double x, InterpAccel a, out double y); + public double eval_deriv (double x, InterpAccel a); + public int eval_deriv2_e (double x, InterpAccel a, out double y); + public double eval_deriv2 (double x, InterpAccel a); + public int eval_integ_e (double a, double b, InterpAccel acc, out double y); + public double eval_integ (double a, double b, InterpAccel acc); + } + + /* + * Numerical Differentiation + */ + [CCode (lower_case_cprefix="gsl_deriv_", cheader_fileame="gsl/gsl_deriv.h")] + namespace Deriv + { + public static int central (Function* f, double x, double h, out double result, out double abserr); + public static int backward (Function* f, double x, double h, out double result, out double abserr); + public static int forward (Function* f, double x, double h, out double result, out double abserr); + } + + + /* + * Chebyshev Approximations + */ + [Compact] + [CCode (cname="gsl_cheb_series", cprefix="gsl_cheb_", cheader_filename="gsl/gsl_chebyshev.h")] + public class ChebSeries + { + public double* c; + public size_t order; + public double a; + public double b; + public size_t order_sp; + public double *f; + + [CCode (cname="gsl_cheb_alloc")] + public ChebSeries (size_t order); + public int init (Function* func, double a, double b); + public double eval (double x); + public int eval_err (double x, out double result, out double abserr); + public double eval_n (size_t order, double x); + public int eval_n_err (size_t order, double x, out double result, out double abserr); + public double eval_mode (double x, Mode mode); + public int eval_mode_e (double x, Mode mode, out double result, out double abserr); + public int calc_deriv (ChebSeries cs); + public int calc_integ (ChebSeries cs); + } + + + /* + * Series Acceleration + */ + [Compact] + [CCode (cname="gsl_sum_levin_u_workspace", free_function="gsl_sum_levin_u_free", cheader_filename="gsl/gsl_sum.h")] + public class SumLevinUWorkspace + { + public size_t size; + public size_t i; + public size_t terms_used; + public double sum_plain; + public double* q_num; + public double* q_den; + public double* dq_num; + public double* dq_den; + public double* dsum; + + [CCode (cname="gsl_sum_levin_u_alloc")] + public SumLevinUWorkspace (size_t n); + } + + [CCode (lower_case_cprefix="gsl_sum_levin_u_", cheader_filename="gsl/gsl_sum.h")] + namespace SumLevinU + { + public static int accel (double[] array, SumLevinUWorkspace w, out double sum_accel, out double abserr); + public static int minmax (double[] array, size_t min_terms, size_t max_terms, SumLevinUWorkspace w, out double sum_accel, out double abserr); + public static int step (double term, size_t n, size_t nmax, SumLevinUWorkspace w, out double sum_accel); + } + + [Compact] + [CCode (cname="gsl_sum_levin_utrunc_workspace", free_function="gsl_sum_levin_utrunc_free", cheader_filename="gsl/gsl_sum.h")] + public class SumLevinUtruncWorkspace + { + public size_t size; + public size_t i; + public size_t terms_used; + public double sum_plain; + public double* q_num; + public double* q_den; + public double* dsum; + + [CCode (cname="gsl_sum_levin_utrunc_alloc")] + public SumLevinUtruncWorkspace (size_t n); + } + + [CCode (lower_case_cprefix="gsl_sum_levin_utrunc_", cheader_filename="gsl/gsl_sum.h")] + namespace SumLevinUtrunc + { + public static int accel (double[] array, SumLevinUtruncWorkspace w, out double sum_accel, out double abserr_trunc); + public static int minmax (double[] array, size_t min_terms, size_t max_terms, SumLevinUtruncWorkspace w, out double sum_accel, out double abserr_trunc); + public static int step (double term, size_t n, SumLevinUtruncWorkspace w, out double sum_accel); + } + + + /* + * Wavelet Transforms + */ + public enum WaveletDirection + { + forward = 1, + backward = -1 + } + + static delegate int WaveletInit (double** h1, double** g1, double** h2, double** g2, size_t* nc, size_t* offset, size_t member); + + [SimpleType] + [CCode (cname="gsl_wavelet_type", cheader_filename="gsl/gsl_wavelet.h")] + public struct WaveletType + { + public string name; + public WaveletInit init; + } + + [CCode (lower_case_cprefix="gsl_wavelet_", cheader_filename="gsl/gsl_wavelet.h")] + namespace WaveletTypes + { + public static WaveletType* daubechies; + public static WaveletType* daubechies_centered; + public static WaveletType* haar; + public static WaveletType* haar_centered; + public static WaveletType* bspline; + public static WaveletType* bspline_centered; + } + + [Compact] + [CCode (cname="gsl_wavelet_workspace", cheader_filename="gsl/gsl_wavelet.h")] + public class WaveletWorkspace + { + public double* scratch; + public size_t n; + + [CCode (cname="gsl_wavelet_workspace_alloc")] + public WaveletWorkspace (size_t n); + } + + [Compact] + [CCode (cname="gsl_wavelet", cheader_filename="gsl/gsl_wavelet.h,gsl/gsl_wavelet2d.h")] + public class Wavelet + { + public WaveletType* type; + public double* h1; + public double* g1; + public double* h2; + public double* g2; + public size_t nc; + public size_t offset; + + [CCode (cname="gsl_wavelet_alloc")] + public Wavelet (WaveletType* T, size_t k); + public string name (); + [NoArrayLength] + public int transform (double[] data, size_t stride, size_t n, WaveletDirection dir, WaveletWorkspace work); + [NoArrayLength] + public int transform_forward (double[] data, size_t stride, size_t n, WaveletWorkspace work); + [NoArrayLength] + public int transform_inverse (double[] data, size_t stride, size_t n, WaveletWorkspace work); + + [NoArrayLength] + [CCode (cname="gsl_wavelet2d_transform")] + public int transform_2d (double[] data, size_t tda, size_t size1, size_t size2, WaveletDirection dir, WaveletWorkspace work); + [NoArrayLength] + [CCode (cname="gsl_wavelet2d_transform_forward")] + public int transform_forward_2d (double[] data, size_t tda, size_t size1, size_t size2, WaveletWorkspace work); + [NoArrayLength] + [CCode (cname="gsl_wavelet2d__transform_inverse")] + public int transform_inverse_2d (double[] data, size_t tda, size_t size1, size_t size2, WaveletWorkspace work); + [NoArrayLength] + [CCode (cprefix="gsl_wavelet2d_")] + public int nstransform (double[] data, size_t tda, size_t size1, size_t size2, WaveletDirection dir,WaveletWorkspace work); + [NoArrayLength] + [CCode (cprefix="gsl_wavelet2d_")] + public int nstransform_forward (double[] data, size_t tda, size_t size1, size_t size2, WaveletWorkspace work); + [NoArrayLength] + [CCode (cprefix="gsl_wavelet2d_")] + public int nstransform_inverse (double[] data, size_t tda, size_t size1, size_t size2, WaveletWorkspace * work); + [CCode (cprefix="gsl_wavelet2d_")] + public int transform_matrix (Matrix a, WaveletDirection dir, WaveletWorkspace work); + [CCode (cprefix="gsl_wavelet2d_")] + public int transform_matrix_forward (Matrix a, WaveletWorkspace work); + [CCode (cprefix="gsl_wavelet2d_")] + public int transform_matrix_inverse (Matrix a, WaveletWorkspace work); + [CCode (cprefix="gsl_wavelet2d_")] + public int nstransform_matrix (Matrix a, WaveletDirection dir, WaveletWorkspace work); + [CCode (cprefix="gsl_wavelet2d_")] + public int nstransform_matrix_forward (Matrix a, WaveletWorkspace work); + [CCode (cprefix="gsl_wavelet2d_")] + public int nstransform_matrix_inverse (Matrix a, WaveletWorkspace work); + } + + + /* + * Discrete Hankel Transforms + */ + [Compact] + [CCode (cname="gsl_dht", cheader_filename="gsl/gsl_dht.h")] + public class DHT + { + public size_t size; + public double nu; + public double xmax; + public double kmax; + public double* j; + public double* Jjj; + public double* J2; + + [CCode (cname="gsl_dht_alloc")] + public DHT (size_t size); + [CCode (cname="gsl_dht_new")] + public DHT.recalc (size_t size, double nu, double xmax); + public int init (double nu, double xmax); + public double x_sample (int n); + public double k_sample (int n); + [NoArrayLength] + public int apply (double[] f_in, double[] f_out); + } + + + /* + * One dimensional Root-Finding + */ + static delegate int RootFsolverSet (void* state, Function* f, double* root, double x_lower, double x_upper); + static delegate int RootFsolverIterate (void* state, Function* f, double* root, double* x_lower, double* x_upper); + static delegate int RootFdfsolverSet (void* state, FunctionFdf* f, double* root); + static delegate int RootFdfsolverIterate (void* state, FunctionFdf* d, double* root); + + [SimpleType] + [CCode (cname="gsl_root_fsolver_type", cheader_filename="gsl/gsl_roots.h")] + public struct RootFsolverType + { + public string name; + public size_t size; + public RootFsolverSet @set; + public RootFsolverIterate iterate; + } + + [Compact] + [CCode (cname="gsl_root_fsolver", cheader_filename="gsl/gsl_roots.h")] + public class RootFsolver + { + public RootFsolverType* type; + public Function* function; + public double root; + public double x_lower; + public double x_upper; + public void* state; + + [CCode (cname="gsl_root_fsolver_alloc")] + public RootFsolver (RootFsolverType* T); + public int @set (Function* f, double x_lower, double x_upper); + public int iterate (); + public weak string name (); + } + + [SimpleType] + [CCode (cname="gsl_root_fdfsolver_type", cheader_filename="gsl/gsl_roots.h")] + public struct RootFdfsolverType + { + public string name; + public size_t size; + public RootFdfsolverSet @set; + public RootFdfsolverIterate iterate; + } + + [Compact] + [CCode (cname="gsl_root_fdfsolver", cheader_filename="gsl/gsl_roots.h")] + public class RootFdfsolver + { + public RootFdfsolverType* type; + public FunctionFdf* fdf; + public double root; + public void* state; + + [CCode (cname="gsl_root_fdfsolver_alloc")] + public RootFdfsolver (RootFdfsolverType* T); + public int @set (FunctionFdf* fdf, double root); + public int iterate (); + public weak string name (); + } + + [CCode (lower_case_cprefix="gsl_root_test_", cheader_filename="gsl/gsl_roots.h")] + namespace RootTest + { + public static int interval (double x_lower, double x_upper, double epsabs, double epsrel); + public static int residual (double f, double epsabs); + public static int delta (double x1, double x0, double epsabs, double epsrel); + } + + [CCode (lower_case_cprefix="gsl_root_fsolver_", cheader_filename="gsl/gsl_roots.h")] + namespace RootFsolverTypes + { + public static RootFsolverType* bisection; + public static RootFsolverType* brent; + public static RootFsolverType* falsepos; + } + + [CCode (lower_case_cprefix="gsl_root_fdfsolver_", cheader_filename="gsl/gsl_roots.h")] + namespace RootFdfsolverTypes + { + public static RootFdfsolverType* newton; + public static RootFdfsolverType* secant; + public static RootFdfsolverType* steffenson; + } + + + /* + * One dimensional Minimization + */ + static delegate int MinSet (void* state, Function* f, double xminimun, double f_minimum, double x_lower, double f_lower, double x_upper, double f_upper); + static delegate int MinIterate (void *state, Function* f, double* x_minimum, double* f_minimum, double* x_lower, double* f_lower, double* x_upper, double* f_upper); + public static delegate int MinBracketingFunction (Function* f, double* x_minimum, double* f_minimum, double* x_lower, double* f_lower, double* x_upper, double* f_upper, size_t eval_max); + + [SimpleType] + [CCode (cname="gsl_min_fminimizer_type", cheader_filename="gsl/gsl_min.h")] + public struct MinFminimizerType + { + public string name; + public size_t size; + public MinSet @set; + public MinIterate iterate; + } + + [Compact] + [CCode (cname="gsl_min_fminimizer", cheader_filename="gsl/gsl_min.h")] + public class MinFminimizer + { + public MinFminimizerType* type; + public Function* function; + public double x_minimum; + public double x_lower; + public double x_upper; + public double f_minimum; + public double f_lower; + public double f_upper; + public void* state; + + [CCode (cname="gsl_min_fminimizer_alloc")] + public MinFminimizer (MinFminimizerType* T) ; + public int @set (Function* f, double x_minimum, double x_lower, double x_upper); + public int set_with_values (Function* f, double x_minimum, double f_minimum, double x_lower, double f_lower, double x_upper, double f_upper); + public int iterate (); + public weak string name (); + } + + [CCode (lower_case_cprefix="gsl_min_test_", cheader_filename="gsl/gsl_min.h")] + namespace MinTest + { + public static int interval (double x_lower, double x_upper, double epsabs, double epsrel); + } + + [CCode (lower_case_cprefix="gsl_min_fminimizer_", cheader_filename="gsl/gsl_min.h")] + namespace MinFminimizerTypes + { + public static MinFminimizerType* goldensection; + public static MinFminimizerType* brent; + } + + [CCode (cname="gsl_min_find_bracket", cheader_filename="gsl/gsl_min.h")] + public static int find_bracket (Function* f, double* x_minimum, double* f_minimum, double* x_lower, double* f_lower, double* x_upper, double* f_upper, size_t eval_max); + + + /* + * Multidimensional Root-Finding + */ + static delegate int MultirootF (Vector x, void* params, Vector f); + static delegate int MultirootFAlloc (void* state, size_t n); + static delegate int MultirootFSet (void* state, MultirootFunction* function, Vector x, Vector f, Vector dx); + static delegate int MultirootFIterate (void* state, MultirootFunction* function, Vector x, Vector f, Vector dx); + static delegate void MultirootFFree (void* state); + static delegate int MultirootDF (Vector x, void* params, Matrix df); + static delegate int MultirootFDF (Vector x, void* params, Vector f, Matrix df); + static delegate int MultirootFdfAlloc (void* state, size_t n); + static delegate int MultirootFdfSet (void* state, MultirootFunctionFdf* fdf, Vector x, Vector f, Matrix J, Vector dx); + static delegate int MultirootFdfIterate (void* state, MultirootFunctionFdf* fdf, Vector x, Vector f, Matrix J, Vector dx); + static delegate int MultirootFdfFree (void* state); + + [SimpleType] + [CCode (cname="gsl_multiroot_function", cheaer_filename="gsl/gsl_multiroots.h")] + public struct MultirootFunction + { + public MultirootF f; + public size_t n; + public void* params; + } + + [CCode (cname="gsl_multiroot_fdjacobian", cheader_filename="gsl/gsl_multiroots.h")] + public static int multiroot_fdjacobian (MultirootFunction* F, Vector x, Vector f, double epsrel, Matrix jacobian); + + [SimpleType] + [CCode (cname="gsl_multiroot_fsolver_type", cheader_filename="gsl/gsl_multiroots.h")] + public struct MultirootFsolverType + { + public string name; + public size_t size; + public MultirootFAlloc alloc; + public MultirootFSet @set; + public MultirootFIterate iterate; + public MultirootFFree free; + } + + [Compact] + [CCode (cname="gsl_multiroot_fsolver", cheader_filename="gsl/gsl_multiroots.h")] + public class MultirootFsolver + { + public MultirootFsolverType* type; + public MultirootFunction* function; + public Vector x; + public Vector f; + public Vector dx; + public void* state; + + [CCode (cname="gsl_multiroot_fsolver_alloc")] + public MultirootFsolver (MultirootFsolverType* T, size_t n); + public int @set (MultirootFunction* f, Vector x); + public int iterate (); + public weak string name (); + public Vector root (); + } + + [SimpleType] + [CCode (cname="gsl_multiroot_function_fdf", cheader_filename="gsl/gsl_multiroots.h")] + public struct MultirootFunctionFdf + { + public MultirootF f; + public MultirootDF df; + public MultirootFDF fdf; + public size_t n; + public void* params; + } + + [SimpleType] + [CCode (cname="gsl_multiroot_fdfsolver_type", cheader_filename="gsl/gsl_multiroots.h")] + public struct MultirootFdfsolverType + { + public string name; + public size_t size; + public MultirootFdfAlloc alloc; + public MultirootFdfSet @set; + public MultirootFdfIterate iterate; + public MultirootFdfFree free; + } + + [Compact] + [CCode (cname="gsl_multiroot_fdfsolver", cheader_filename="gsl/gsl_multiroots.h")] + public class MultirootFdfsolver + { + public MultirootFdfsolverType* type; + public MultirootFunctionFdf* fdf; + public Vector x; + public Vector f; + public Matrix J; + public Vector dx; + public void* state; + + [CCode (cname="gsl_multiroot_fdfsolver_alloc")] + public MultirootFdfsolver (MultirootFdfsolverType* T, size_t n); + public int @set (MultirootFunctionFdf* fdf, Vector x); + public int iterate (); + public weak string name (); + public Vector root (); + } + + [CCode (lower_case_cprefix="gsl_multiroot_test_", cheader_filename="gsl/gsl_multiroots.h")] + namespace MultirootTest + { + public static int delta (Vector dx, Vector x, double epsabs, double epsrel); + public static int residual (Vector f, double epsabs); + } + + [CCode (lower_case_cprefix="gsl_multiroot_fsolver_", cheader_filename="gsl/gsl_multiroots.h")] + namespace MultirootFsolverTypes + { + public static MultirootFsolverType* dnewton; + public static MultirootFsolverType* broyden; + public static MultirootFsolverType* hybrid; + public static MultirootFsolverType* hybrids; + } + + [CCode (lower_case_cprefix="gsl_multiroot_fdfsolver_", cheader_filename="gsl/gsl_multiroots.h")] + namespace MultirootFdfsolverTypes + { + public static MultirootFdfsolverType* newton; + public static MultirootFdfsolverType* gnewton; + public static MultirootFdfsolverType* hybridj; + public static MultirootFdfsolverType* hybridsj; + } + + + /* + * Multidimensional Minimization + */ + static delegate double MultiminF (Vector x, void* params); + static delegate void MultiminDf (Vector x, void* params, Vector df); + static delegate void MultiminFdf (Vector x, void* params, double* f, Vector df); + static delegate int MultiminFAlloc (void *state, size_t n); + static delegate int MultiminFSet (void* state, MultiminFunction* f, Vector x, double* size); + static delegate int MultiminFIterate (void* state, MultiminFunction* f, Vector x, double* size, double* fval); + static delegate int MultiminFFree (void* state); + + [SimpleType] + [CCode (cname="gsl_multimin_function", cheader_filename="gsl/gsl_multimin.h")] + public struct MultiminFunction + { + public MultiminF f; + public size_t n; + public void* params; + } + + [SimpleType] + [CCode (cname="gsl_multimin_function_fdf", cheader_filename="gsl/gsl_multimin.h")] + public struct MultiminFunctionFdf + { + public MultiminF f; + public MultiminDf df; + public MultiminFdf fdf; + public size_t n; + public void* params; + } + + [CCode (cname="gsl_multimin_diff", cheader_filename="gsl/gsl_multimin.h")] + public static int multimin_diff (MultiminFunction* f, Vector x, Vector g); + + [SimpleType] + [CCode (cname="gsl_multimin_fminimizer_type", cheader_filename="gsl/gsl_multimin.h")] + public struct MultiminFminimizerType + { + public string name; + public size_t size; + public MultiminFAlloc alloc; + public MultiminFSet @set; + public MultiminFIterate iterate; + public MultiminFFree free; + } + + [Compact] + [CCode (cname="gsl_multimin_fminimizer", cheader_filename="gsl/gsl_multimin.h")] + public class MultiminFminimizer + { + public MultiminFminimizerType* type; + public MultiminFunction* f; + public double fval; + public Vector x; + public double size; + public void* state; + + [CCode (cname="gsl_multimin_fminimizer_alloc")] + public MultiminFminimizer (MultiminFminimizerType* T, size_t n); + public int @set (MultiminFunction* f, Vector x, Vector step_size); + public weak string name (); + public int iterate (); + public double minimum (); + } + + [CCode (lower_case_cprefix="gsl_multimin_test_", cheader_filename="gsl/gsl_multimin.h")] + namespace MultiminTest + { + public static int gradient(Vector g, double epsabs); + public static int size (double size, double epsabs); + } + + static delegate int MultiminFdfAlloc (void *state, size_t n); + static delegate int MultiminFdfSet (void* state, MultiminFunctionFdf* fdf, Vector x, double* f, Vector gradient, double step_size, double tol); + static delegate int MultiminFdfIterate (void* state, MultiminFunctionFdf* fdf, Vector x, double* f, Vector gradient, Vector dx); + static delegate int MultiminFdfRestart (void* state); + static delegate int MultiminFdfFree (void* state); + + [SimpleType] + [CCode (cname="gsl_multimin_fdfminimizer_type", cheader_filename="gsl/gsl_multimin.h")] + public struct MultiminFdfminimizerType + { + public string name; + public size_t size; + public MultiminFdfAlloc alloc; + public MultiminFdfSet @set; + public MultiminFdfIterate iterate; + public MultiminFdfRestart restart; + public MultiminFdfFree free; + } + + [Compact] + [CCode (cname="gsl_multimin_fdfminimizer", cheader_filename="gsl/gsl_multimin.h")] + public class MultiminFdfminimizer + { + public MultiminFdfminimizerType* type; + public MultiminFunctionFdf* fdf; + public double f; + public Vector x; + public Vector gradient; + public Vector dx; + public void* state; + + [CCode (cname="gsl_multimin_fdfminimizer_alloc")] + public MultiminFdfminimizer (MultiminFdfminimizerType* T, size_t n); + public int @set (MultiminFunctionFdf* fdf, Vector x, double step_size, double tol); + public weak string name (); + public int iterate (); + public int restart (); + public double minimum (); + } + + [CCode (lower_case_cprefix="gsl_multimin_fdfminimizer_", cheader_filename="gsl/gsl_multimin.h")] + namespace MultiminFdfminimizerTypes + { + public static MultiminFdfminimizerType* steepest_descent; + public static MultiminFdfminimizerType* conjugate_pr; + public static MultiminFdfminimizerType* conjugate_fr; + public static MultiminFdfminimizerType* vector_bfgs; + public static MultiminFdfminimizerType* vector_bfgs2; + } + + [CCode (lower_case_cprefix="gsl_multimin_fminimizer_", cheader_filename="gsl/gsl_multimin.h")] + namespace MultiminFminimizerTypes + { + public static MultiminFminimizerType* nmsimplex; + } + + + /* + * Least-Squares Fitting + */ + [CCode (lower_case_cprefix="gsl_fit_", cheader_filename="gsl/gsl_fit.h")] + namespace Fit + { + [NoArrayLength] + public static int linear (double[] x, size_t xstride, double[] y, size_t ystride, size_t n, out double c0, out double c1, out double cov00, out double cov01, out double cov11, out double sumsq); + [NoArrayLength] + public static int wlinear (double[] x, size_t xstride, double[] w, size_t wstride, double[] y, size_t ystride, size_t n, out double c0, out double c1, out double cov00, out double cov01, out double cov11, double chisq); + [NoArrayLength] + public static int linear_est (double x, double c0, double c1, double cov00, double cov01, double cov11, out double y, out double y_err); + [NoArrayLength] + public static int mul (double[] x, size_t xstride, double[] y, size_t ystride, size_t n, out double c1, out double cov11, out double sumsq); + [NoArrayLength] + public static int wmul (double[] x, size_t xstride, double[] w, size_t wstride, double[] y, size_t ystride, size_t n, out double c1, out double cov11, out double sumsq); + public static int mul_est (double x, double c1, double cov11, out double y, out double y_err); + } + + [Compact] + [CCode (cname="gsl_multifit_linear_workspace", cheader_filename="gsl/gsl_multifit.h")] + public class MultifitLinearWorkspace + { + public size_t n; + public size_t p; + public Matrix A; + public Matrix Q; + public Matrix QSI; + public Vector S; + public Vector t; + public Vector xt; + public Vector D; + + [CCode (cname="gsl_multifit_linear_workspace_alloc")] + public MultifitLinearWorkspace (size_t n, size_t p); + } + + [CCcode (lower_case_cprefix="gsl_multifit_", cheader_filename="gsl/gsl_multifit.h")] + namespace Multifit + { + public static int linear (Matrix X, Vector y, Vector c, Matrix cov, out double chisq, MultifitLinearWorkspace work); + public static int linear_svd (Matrix X, Vector y, double tol, out size_t rank, Vector c, Matrix cov, out double chisq, MultifitLinearWorkspace work); + public static int wlinear (Matrix X, Vector w, Vector y, Vector c, Matrix cov, out double chisq, MultifitLinearWorkspace work); + public static int wlinear_svd (Matrix X, Vector w, Vector y, double tol, out size_t rank, Vector c, Matrix cov, out double chisq, MultifitLinearWorkspace work); + public static int linear_est (Vector x, Vector c, Matrix cov, out double y, out double y_err); + public int linear_residuals (Matrix X, Vector y, Vector c, Vector r); + } + + + /* + * Nonlinear Least-Squares Fitting + */ + static delegate int MultifitF (Vector x, void* params, Vector f); + static delegate int MultifitFAlloc (void* state, size_t n, size_t p); + static delegate int MultifitFSet (void* state, MultifitFunction* function, Vector x, Vector f, Vector dx); + static delegate int MultifitFIterate (void* state, MultifitFunction* function, Vector x, Vector f, Vector dx); + static delegate void MultifitFFree (void* state); + static delegate int MultifitDf (Vector x, void* params, Matrix df); + static delegate int MultifitFdf (Vector x, void* params, Vector f, Matrix df); + static delegate int MultifitFdfAlloc (void* state, size_t n, size_t p); + static delegate int MultifitFdfSet (void* state, MultifitFunctionFdf fdf, Vector x, Vector f, Matrix J, Vector dx); + static delegate int MultifitFdfIterate (void* state, MultifitFunctionFdf fdf, Vector x, Vector f, Matrix J, Vector dx); + static delegate void MultifitFdfFree (void* state); + + [CCode (lower_case_cprefix="gsl_multifit_", cheader_filename="gsl/gsl_multifit_nlin.h")] + namespace Multifit + { + public static int gradient (Matrix J, Vector f, Vector g); + public static int covar (Matrix J, double epsrel, Matrix covar); + } + + [SimpleType] + [CCode (cname="gsl_multifit_function", cheader_filename="gls/gsl_multifit_nlin.h")] + public struct MultifitFunction + { + public MultifitF f; + public size_t n; + public size_t p; + public void* params; + } + + [SimpleType] + [CCode (cname="gsl_multifit_fsolver_type", cheader_filename="gsl/gsl_multifit_nlin.h")] + public struct MultifitFsolverType + { + public string name; + public size_t size; + public MultifitFAlloc alloc; + public MultifitFSet @set; + public MultifitFIterate iterate; + public MultifitFFree free; + } + + [Compact] + [CCode (cname="gsl_multifit_fsolver", cheader_filename="gsl/gsl_multifit_nlin.h")] + public class MultifitFsolver + { + public MultifitFsolverType* type; + public MultifitFunction* function; + public Vector x; + public Vector f; + public Vector dx; + public void* state; + + [CCode (cname="gsl_multifit_fsolver_alloc")] + public MultifitFsolver (MultifitFsolverType* T, size_t n, size_t p); + public int @set (MultifitFunction* f, Vector x); + public int iterate (); + public weak string name (); + public Vector position (); + } + + [SimpleType] + [CCode (cname="gsl_multifit_function_fdf", cheader_filename="gsl/gsl_multifit_nlin.h")] + public struct MultifitFunctionFdf + { + public MultifitF f; + public MultifitDf df; + public MultifitFdf fdf; + public size_t n; + public size_t p; + public void* params; + } + + [SimpleType] + [CCode (cname="gsl_multifit_fdfsolver_type", cheader_filename="gsl/gsl_multifit_nlin.h")] + public struct MultifitFdfsolverType + { + public string name; + public size_t size; + public MultifitFdfAlloc alloc; + public MultifitFdfSet @set; + public MultifitFdfIterate iterate; + public MultifitFdfFree free; + } + + [Compact] + [CCode (cname="gsl_multifit_fdfsolver", cheader_filename="gsl/gsl_multifit_nlin.h")] + public class MultifitFdfsolver + { + public MultifitFdfsolverType* type; + public MultifitFunctionFdf* fdf; + public Vector x; + public Vector f; + public Vector J; + public Vector dx; + public void* state; + + [CCode (cname="gsl_multifit_fdfsolver_alloc")] + public MultifitFdfsolver (MultifitFdfsolverType* T, size_t n, size_t p); + public int @set (MultifitFunctionFdf* fdf, Vector x); + public int iterate (); + public weak string name (); + public Vector position (); + } + + [CCode (lower_case_cprefix="gsl_multifit_test_", cheader_filename="gsl/gsl_multifit_nlin.h")] + namespace MultifitTest + { + public static int delta (Vector dx, Vector x, double epsabs, double epsrel); + public static int gradient (Vector g, double epsabs); + } + + [CCode (lower_case_cprefix="gsl_multifit_fdfsolver_", cheader_filename="gsl/gsl_multifit_nlin.h")] + namespace MultifitFdfsolverTypes + { + public static MultifitFdfsolverType* lmder; + public static MultifitFdfsolverType* lmsder; + } + + + /* + * Basis Splines + */ + [Compact] + [CCode (cname="gsl_bspline_workspace", cprefix="gsl_bspline_", cheader_filename="gsl/gsl_bspline.h")] + public class BsplineWorkspace + { + public size_t k; + public size_t km1; + public size_t l; + public size_t nbreak; + public size_t n; + public Vector knots; + public Vector deltal; + public Vector deltar; + public Vector B; + + [CCode (cname="gsl_bspline_alloc")] + public BsplineWorkspace (size_t k, size_t nbreak); + public size_t ncoeffs (); + public size_t order (); + [CCode (instance_pos=-1)] + public double breakpoint (size_t i); + [CCode (instance_pos=-1)] + public int knots_uniform (double a, double b); + [CCode (instance_pos=-1)] + public int eval (double x, Vector B); + } +} +