rssn 0.2.9

A comprehensive scientific computing library for Rust, aiming for feature parity with NumPy and SymPy.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Handle-based FFI API for relativity functions.

use crate::symbolic::core::Expr;
use crate::symbolic::relativity;

/// Structure to hold two expressions (e.g., transformed x and t).
#[repr(C)]
pub struct ExprPair {
    /// The first expression in the pair.
    pub first: *mut Expr,
    /// The second expression in the pair.
    pub second: *mut Expr,
}

/// Calculates the Lorentz factor.
///
/// # Safety
///
/// This function is unsafe because it dereferences raw pointers as part of the FFI boundary.
/// The caller must ensure:
/// 1. All pointer arguments are valid and point to initialized memory.
/// 2. The memory layout of passed structures matches the expected C-ABI layout.
/// 3. Any pointers returned by this function are managed according to the API's ownership rules.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn rssn_lorentz_factor(velocity: *const Expr) -> *mut Expr {
    unsafe {
        if velocity.is_null() {
            return std::ptr::null_mut();
        }

        Box::into_raw(Box::new(relativity::lorentz_factor(&*velocity)))
    }
}

/// Performs a Lorentz transformation in the x-direction.
///
/// # Safety
///
/// This function is unsafe because it dereferences raw pointers as part of the FFI boundary.
/// The caller must ensure:
/// 1. All pointer arguments are valid and point to initialized memory.
/// 2. The memory layout of passed structures matches the expected C-ABI layout.
/// 3. Any pointers returned by this function are managed according to the API's ownership rules.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn rssn_lorentz_transformation_x(
    x: *const Expr,
    t: *const Expr,
    v: *const Expr,
) -> ExprPair {
    unsafe {
        if x.is_null() || t.is_null() || v.is_null() {
            return ExprPair {
                first: std::ptr::null_mut(),
                second: std::ptr::null_mut(),
            };
        }

        let (xp, tp) = relativity::lorentz_transformation_x(&*x, &*t, &*v);

        ExprPair {
            first: Box::into_raw(Box::new(xp)),
            second: Box::into_raw(Box::new(tp)),
        }
    }
}

/// Calculates mass-energy equivalence.
///
/// # Safety
///
/// This function is unsafe because it dereferences raw pointers as part of the FFI boundary.
/// The caller must ensure:
/// 1. All pointer arguments are valid and point to initialized memory.
/// 2. The memory layout of passed structures matches the expected C-ABI layout.
/// 3. Any pointers returned by this function are managed according to the API's ownership rules.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn rssn_mass_energy_equivalence(mass: *const Expr) -> *mut Expr {
    unsafe {
        if mass.is_null() {
            return std::ptr::null_mut();
        }

        Box::into_raw(Box::new(relativity::mass_energy_equivalence(&*mass)))
    }
}

/// Calculates Schwarzschild radius.
///
/// # Safety
///
/// This function is unsafe because it dereferences raw pointers as part of the FFI boundary.
/// The caller must ensure:
/// 1. All pointer arguments are valid and point to initialized memory.
/// 2. The memory layout of passed structures matches the expected C-ABI layout.
/// 3. Any pointers returned by this function are managed according to the API's ownership rules.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn rssn_schwarzschild_radius(mass: *const Expr) -> *mut Expr {
    unsafe {
        if mass.is_null() {
            return std::ptr::null_mut();
        }

        Box::into_raw(Box::new(relativity::schwarzschild_radius(&*mass)))
    }
}