State of the wrapper

I will slowly build the wrapper as I need different functions in my use cases. If you want to contribute a wrapper, feel free to do so by creating a Pull Request! On the same way, if you want to request a wrapper feel free to create an Issue.

Check below for the list of stuff that has been wrapped!

Usage

With Zig

Usage with Zig is as simple as adding a dependency to your build.zig.zon:

.dependencies = .{
	.zgsl = .{
		.url = "TO BE SPECIFIED",
		.hash = "TO BE SPECIFIED",
	}
},

and including the dependency as needed in your build.zig:

const zgsl = b.dependency("zgsl", .{
	.target = target,
	.optimize = optimize
});

// ... for example, if you generate an executable ... 

const gsl_lib = zgsl.artifact("gsl");
exe.linkLibrary(gsl_lib);
exe.linkLibC();
exe.step.dependOn(&zgsl.namedWriteFiles("gsl_include").step);

Afterwards, depending on whether you want to use the wrapper or the raw functions (or both):

Using the wrapper

To use the Zig wrapper, you will use the module:

exe.root_module.addImport("zgsl", zgsl.module("wrapper"));
exe.step.dependOn(&zgsl.builder.top_level_steps.get("wrap").?.step);

The second line guarantees wrappers are generated, as otherwise you would have to manually run zig build wrap on the downloaded dependency.

Now you have access to the wrapper under the name zgsl. For example, to compute a Bessel function:

const sf = @import("zgsl").sf;

...

const result = try sf.bessel.J0_e(5.0);
std.debug.print("Bessel J0(5.0) = {}, error = {}\n", .{result.val, result.err});

To learn more about the wrapper, check the tests contained in src/test, usage should be intuitive coming from using the GSL library in C or other languages.

It's heavily recommended that you disable the default GSL error handler, as otherwise Zig errors will almost never be useful (GSL will panic before you can handle the errors). To do so use the function:

const gsl = @import("zgsl")
//...
gsl.set_error_handler_off();

Using the "raw" C library

In this case you also have to include the GSL header files and link with the library, which can be done as follows:

exe.addIncludePath(zgsl.namedWriteFiles("gsl_include").getDirectory().path(b, "include"));

Now you can directly call the GSL. The same example as before would be implemented as follows:

const gsl = @cImport({
    @cInclude("gsl/gsl_sf_bessel.h");
    @cInclude("gsl/gsl_errno.h");
});

...

var result_raw: gsl.gsl_sf_result = undefined;
const err = gsl.gsl_sf_bessel_J0_e(5.0, @ptrCast(&result_raw));
if(err != gsl.GSL_SUCCESS) {
	return error.GSL;
}
std.debug.print("Raw Bessel J0(5.0) = {}, error bound = {}\n", .{result_raw.val, result_raw.err});

The convenience of the wrapper, which exploits Zig's errors, should have become evident.

With C / other languages

The wrapper cannot be used on C, but the building of the GSL is straightforward (and multiplatform). Simply run zig build and use the files generated in zig-out (static library and header files) as you typically would.

Wrapper status

(Unwrapped functions may be used directly from the C library, without the comfort of Zig of course!)

Mathematical functions
Polynomials
Special functions
Vectors and Matrices
Permutations
Combinations
Multisets
Sorting
BLAS Support
Linear Algebra
Eigensystems
FFTs
Numerical Integration
RNG
Statistics
Running Statistics
Moving Window Statistics
Digital Filtering
Histograms
N-tuples
Monte Carlo Integration
Simulated Annealing
ODEs
Interpolation
Numerical differentiation
Chebyshev approximations
Series acceleration
Wavelet transforms
Discrete hankel transforms
1D root finding
1D minimization
nD root finding
nD minimization
Linear least squares
Nonlinear least squares
Basis splines
Sparse matrices
Sparse BLAS
Sparse Linear Algebra
Physical constants
IEEE floating point arithmetic