pharmsol 0.26.1

Rust library for solving analytic and ode-defined pharmacometric models.
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

use libloading::{Library, Symbol};
use std::path::PathBuf;

use crate::{EqnKind, Equation, Meta};

pub unsafe fn get_kind(model_path: PathBuf) -> EqnKind {
    let lib = unsafe { Library::new(model_path).expect("Failed to load library") };
    let get_kind: Symbol<unsafe extern "C" fn() -> EqnKind> =
        unsafe { lib.get(b"equation_kind").expect("Failed to load symbol") };
    let kind = unsafe { get_kind() };
    kind.clone()
}

/// Loads an ODE (Ordinary Differential Equation) and its metadata from a given library.
///
/// # Safety
///
/// This function is unsafe because:
/// - It involves FFI (Foreign Function Interface) calls and raw pointer manipulation.
/// - The returned `ODE` and `Meta` instances will become invalid if the `Library` is dropped.
///   The caller must ensure that the `Library` remains alive as long as the `ODE` and `Meta`
///   are being used.
///
/// # Arguments
///
/// * `model_path` - Path to the compiled model library file.
///
/// # Returns
///
/// A tuple containing the `Library` and a pair of (`ODE`, `Meta`). The `Library` must be kept
/// in scope as long as the `ODE` and `Meta` are used.
pub unsafe fn load<E: Equation>(model_path: PathBuf) -> (Library, (E, Meta)) {
    let lib = unsafe { Library::new(model_path).expect("Failed to load library") };

    let create_eqn: Symbol<unsafe extern "C" fn() -> *mut std::ffi::c_void> =
        unsafe { lib.get(b"create_eqn_ptr").expect("Failed to load symbol") };
    let eqn_ptr = unsafe { create_eqn() };

    let create_meta: Symbol<unsafe extern "C" fn() -> *mut std::ffi::c_void> =
        unsafe { lib.get(b"metadata_ptr").expect("Failed to load symbol") };
    let meta_ptr = unsafe { create_meta() };

    unsafe {
        (
            lib,
            (
                (&*(eqn_ptr as *mut E)).clone(),
                (&*(meta_ptr as *mut Meta)).clone(),
            ),
        )
    }
}

/// Retrieves the model parameters from a dynamically loaded model.
///
/// # Safety
///
/// This function is unsafe for the same reasons as `load_ode`. It internally calls `load_ode`
/// which performs FFI calls and pointer manipulation.
///
/// # Arguments
///
/// * `model_path` - Path to the compiled model library file.
///
/// # Returns
///
/// A vector of strings representing the model parameters.
pub unsafe fn model_parameters<E: Equation>(model_path: PathBuf) -> Vec<String> {
    let (_, (_, meta)) = unsafe { load::<E>(model_path) };
    meta.get_params().clone()
}