Skip to content

Commit

Permalink
Run cargo fmt
Browse files Browse the repository at this point in the history
  • Loading branch information
@Chris00
Chris00 committed Dec 25, 2024
1 parent 849219e commit b33f091
Show file tree
Hide file tree
Showing 9 changed files with 163 additions and 211 deletions.
88 changes: 17 additions & 71 deletions src/blas.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,12 @@

pub mod level1 {
use crate::ffi::FFI;
use crate::{
types,
types::complex::{FromC, ToC},
Value,
};
use crate::{VectorF32, VectorF64};
use crate::{types, types::complex::{ToC, FromC}, Value};
use num_complex::Complex;

/// This function computes the sum \alpha + x^T y for the vectors x and y, returning the result
Expand Down Expand Up @@ -283,13 +287,8 @@ pub mod level1 {
x: &types::VectorComplexF32,
y: &mut types::VectorComplexF32,
) -> Result<(), Value> {
let ret = unsafe {
sys::gsl_blas_caxpy(
alpha.unwrap(),
x.unwrap_shared(),
y.unwrap_unique(),
)
};
let ret =
unsafe { sys::gsl_blas_caxpy(alpha.unwrap(), x.unwrap_shared(), y.unwrap_unique()) };
result_handler!(ret, ())
}

Expand All @@ -300,13 +299,8 @@ pub mod level1 {
x: &types::VectorComplexF64,
y: &mut types::VectorComplexF64,
) -> Result<(), Value> {
let ret = unsafe {
sys::gsl_blas_zaxpy(
alpha.unwrap(),
x.unwrap_shared(),
y.unwrap_unique(),
)
};
let ret =
unsafe { sys::gsl_blas_zaxpy(alpha.unwrap(), x.unwrap_shared(), y.unwrap_unique()) };
result_handler!(ret, ())
}

Expand Down Expand Up @@ -358,14 +352,7 @@ pub mod level1 {
pub fn srotg(mut a: f32, mut b: f32) -> Result<(f32, f32, f32), Value> {
let mut c = 0.;
let mut s = 0.;
let ret = unsafe {
sys::gsl_blas_srotg(
&mut a,
&mut b,
&mut c,
&mut s,
)
};
let ret = unsafe { sys::gsl_blas_srotg(&mut a, &mut b, &mut c, &mut s) };
result_handler!(ret, (c, s, a))
}

Expand All @@ -381,14 +368,7 @@ pub mod level1 {
pub fn drotg(mut a: f64, mut b: f64) -> Result<(f64, f64, f64), Value> {
let mut c = 0.;
let mut s = 0.;
let ret = unsafe {
sys::gsl_blas_drotg(
&mut a,
&mut b,
&mut c,
&mut s,
)
};
let ret = unsafe { sys::gsl_blas_drotg(&mut a, &mut b, &mut c, &mut s) };
result_handler!(ret, (c, s, a))
}

Expand Down Expand Up @@ -420,45 +400,19 @@ pub mod level1 {
/// The modified Givens transformation is defined in the original
/// [Level-1 BLAS specification](https://help.imsl.com/fortran/fnlmath/current/basic-linear-algebra-sub.htm#mch9_1817247609_srotmg).
#[doc(alias = "gsl_blas_srotmg")]
pub fn srotmg(
mut d1: f32,
mut d2: f32,
mut b1: f32,
b2: f32,
) -> Result<[f32; 5], Value> {
pub fn srotmg(mut d1: f32, mut d2: f32, mut b1: f32, b2: f32) -> Result<[f32; 5], Value> {
let mut p = [f32::NAN; 5];
let ret = unsafe {
sys::gsl_blas_srotmg(
&mut d1,
&mut d2,
&mut b1,
b2,
p.as_mut_ptr(),
)
};
let ret = unsafe { sys::gsl_blas_srotmg(&mut d1, &mut d2, &mut b1, b2, p.as_mut_ptr()) };
result_handler!(ret, p)
}

/// Return a modified Givens transformation.
/// The modified Givens transformation is defined in the original
/// [Level-1 BLAS specification](https://help.imsl.com/fortran/fnlmath/current/basic-linear-algebra-sub.htm#mch9_1817247609_srotmg).
#[doc(alias = "gsl_blas_drotmg")]
pub fn drotmg(
mut d1: f64,
mut d2: f64,
mut b1: f64,
b2: f64,
) -> Result<[f64; 5], Value> {
pub fn drotmg(mut d1: f64, mut d2: f64, mut b1: f64, b2: f64) -> Result<[f64; 5], Value> {
let mut p = [f64::NAN; 5];
let ret = unsafe {
sys::gsl_blas_drotmg(
&mut d1,
&mut d2,
&mut b1,
b2,
p.as_mut_ptr(),
)
};
let ret = unsafe { sys::gsl_blas_drotmg(&mut d1, &mut d2, &mut b1, b2, p.as_mut_ptr()) };
result_handler!(ret, p)
}

Expand All @@ -474,11 +428,7 @@ pub mod level1 {
if lenx != leny {
panic!("rgsl::blas::srotm: len(x) = {lenx} != len(y) = {leny}")
}
let ret =
unsafe { sys::gsl_blas_srotm(
x.unwrap_unique(),
y.unwrap_unique(),
p.as_ptr()) };
let ret = unsafe { sys::gsl_blas_srotm(x.unwrap_unique(), y.unwrap_unique(), p.as_ptr()) };
result_handler!(ret, ())
}

Expand All @@ -494,11 +444,7 @@ pub mod level1 {
if lenx != leny {
panic!("rgsl::blas::drotm: len(x) = {lenx} != len(y) = {leny}")
}
let ret =
unsafe { sys::gsl_blas_drotm(
x.unwrap_unique(),
y.unwrap_unique(),
p.as_ptr()) };
let ret = unsafe { sys::gsl_blas_drotm(x.unwrap_unique(), y.unwrap_unique(), p.as_ptr()) };
result_handler!(ret, ())
}

Expand Down
140 changes: 91 additions & 49 deletions src/fft.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -165,10 +165,7 @@ is desirable for better locality of memory accesses).
///
/// The functions return a value of crate::Value::Success if no errors were detected, or Value::Dom if the length n is not a power of two.
pub mod radix2 {
use crate::{
Value,
vector::VectorMut,
};
use crate::{vector::VectorMut, Value};

#[doc(alias = "gsl_fft_complex_radix2_forward")]
pub fn forward(data: &mut [f64], stride: usize, n: usize) -> Result<(), Value> {
Expand All @@ -186,39 +183,55 @@ pub mod radix2 {
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
sign.into())
sign.into(),
)
};
result_handler!(ret, ())
}

#[doc(alias = "gsl_fft_complex_radix2_backward")]
pub fn backward<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_complex_radix2_backward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_complex_radix2_backward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}

#[doc(alias = "gsl_fft_complex_radix2_inverse")]
pub fn inverse<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_complex_radix2_inverse(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_complex_radix2_inverse(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}

/// This is decimation-in-frequency version of the radix-2 FFT function.
#[doc(alias = "gsl_fft_complex_radix2_dif_forward")]
pub fn dif_forward<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_complex_radix2_dif_forward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_complex_radix2_dif_forward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}

Expand All @@ -233,29 +246,41 @@ pub mod radix2 {
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
sign.into()) };
sign.into(),
)
};
result_handler!(ret, ())
}

/// This is decimation-in-frequency version of the radix-2 FFT function.
#[doc(alias = "gsl_fft_complex_radix2_dif_backward")]
pub fn dif_backward<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_complex_radix2_dif_backward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_complex_radix2_dif_backward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}

/// This is decimation-in-frequency version of the radix-2 FFT function.
#[doc(alias = "gsl_fft_complex_radix2_dif_inverse")]
pub fn dif_inverse<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_complex_radix2_dif_inverse(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_complex_radix2_dif_inverse(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}
}
Expand All @@ -264,8 +289,8 @@ pub mod radix2 {
/// are a power of 2.
pub mod real_radix2 {
use crate::{
Value,
vector::{check_equal_len, Vector, VectorMut},
Value,
};

/// This function computes an in-place radix-2 FFT of length n and stride stride on the real array data. The output is a half-complex sequence,
Expand Down Expand Up @@ -300,35 +325,50 @@ pub mod real_radix2 {
/// below.
#[doc(alias = "gsl_fft_real_radix2_transform")]
pub fn transform<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_real_radix2_transform(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_real_radix2_transform(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}

/// This function computes the inverse or backwards in-place radix-2 FFT of length n and stride stride on the half-complex sequence data
/// stored according the output scheme used by gsl_fft_real_radix2. The result is a real array stored in natural order.
#[doc(alias = "gsl_fft_halfcomplex_radix2_inverse")]
pub fn inverse<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_halfcomplex_radix2_inverse(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_halfcomplex_radix2_inverse(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}

/// This function computes the inverse or backwards in-place radix-2 FFT of length n and stride stride on the half-complex sequence data
/// stored according the output scheme used by gsl_fft_real_radix2. The result is a real array stored in natural order.
#[doc(alias = "gsl_fft_halfcomplex_radix2_backward")]
pub fn backward<V>(data: &mut V) -> Result<(), Value>
where V: VectorMut<f64> + ?Sized {
let ret = unsafe { sys::gsl_fft_halfcomplex_radix2_backward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data)) };
where
V: VectorMut<f64> + ?Sized,
{
let ret = unsafe {
sys::gsl_fft_halfcomplex_radix2_backward(
V::as_mut_slice(data).as_mut_ptr(),
V::stride(data),
V::len(data),
)
};
result_handler!(ret, ())
}

Expand Down Expand Up @@ -367,8 +407,10 @@ pub mod real_radix2 {
halfcomplex_coefficient: &V1,
complex_coefficient: &mut V2, // FIXME: Complex
) -> Result<(), Value>
where V1: Vector<f64> + ?Sized,
V2: VectorMut<f64> + ?Sized {
where
V1: Vector<f64> + ?Sized,
V2: VectorMut<f64> + ?Sized,
{
check_equal_len(halfcomplex_coefficient, halfcomplex_coefficient)?;
let ret = unsafe {
sys::gsl_fft_halfcomplex_radix2_unpack(
Expand Down
Loading

0 comments on commit b33f091

Please sign in to comment.