sim-lib-numbers-signal 0.1.0

Deterministic transforms, autoregression, spectral estimation, and guarded signal operations.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Loadable callables for the real signal-operation runtime.

use std::{any::Any, sync::Arc};

use sim_kernel::{
    Args, Callable, ClassRef, Cx, DefaultFactory, Error, Expr, Factory, Linker, Object, RawArgs,
    Result, Symbol, Value,
};

use crate::runtime_convolution::{execute_exprs, execute_values};

/// Symbol of the Lisp-facing convolution operation (`signal/convolve`).
pub fn signal_convolve_symbol() -> Symbol {
    Symbol::qualified("signal", "convolve")
}

/// Symbol of the Lisp-facing cross-correlation operation (`signal/correlate`).
pub fn signal_correlate_symbol() -> Symbol {
    Symbol::qualified("signal", "correlate")
}

/// Symbol of the Lisp-facing guarded deconvolution operation (`signal/deconvolve`).
pub fn signal_deconvolve_symbol() -> Symbol {
    Symbol::qualified("signal", "deconvolve")
}

#[derive(Clone, Copy)]
pub(crate) enum Operation {
    Convolve,
    Correlate,
    Deconvolve,
}

impl Operation {
    fn symbol(self) -> Symbol {
        match self {
            Self::Convolve => signal_convolve_symbol(),
            Self::Correlate => signal_correlate_symbol(),
            Self::Deconvolve => signal_deconvolve_symbol(),
        }
    }

    pub(crate) fn name(self) -> &'static str {
        match self {
            Self::Convolve => "signal/convolve",
            Self::Correlate => "signal/correlate",
            Self::Deconvolve => "signal/deconvolve",
        }
    }
}

#[derive(Clone)]
struct SignalOperationFunction {
    operation: Operation,
}

impl Object for SignalOperationFunction {
    fn display(&self, _cx: &mut Cx) -> Result<String> {
        Ok(format!("#<function {}>", self.operation.symbol()))
    }

    fn as_any(&self) -> &dyn Any {
        self
    }
}

impl sim_kernel::ObjectCompat for SignalOperationFunction {
    fn class(&self, cx: &mut Cx) -> Result<ClassRef> {
        if let Some(value) = cx
            .registry()
            .class_by_symbol(&Symbol::qualified("core", "Function"))
        {
            return Ok(value.clone());
        }
        DefaultFactory.class_stub(
            sim_kernel::CORE_FUNCTION_CLASS_ID,
            Symbol::qualified("core", "Function"),
        )
    }

    fn as_expr(&self, _cx: &mut Cx) -> Result<Expr> {
        Ok(Expr::Symbol(self.operation.symbol()))
    }

    fn as_callable(&self) -> Option<&dyn Callable> {
        Some(self)
    }
}

impl Callable for SignalOperationFunction {
    fn call(&self, cx: &mut Cx, args: Args) -> Result<Value> {
        execute_values(cx, self.operation, args.into_vec())
    }

    fn call_exprs(&self, cx: &mut Cx, args: RawArgs) -> Result<Value> {
        execute_exprs(cx, self.operation, args.into_exprs())
    }
}

pub(crate) fn operation_symbols() -> [Symbol; 3] {
    [
        signal_convolve_symbol(),
        signal_correlate_symbol(),
        signal_deconvolve_symbol(),
    ]
}

pub(crate) fn load_operations(linker: &mut Linker<'_>) -> Result<()> {
    for operation in [
        Operation::Convolve,
        Operation::Correlate,
        Operation::Deconvolve,
    ] {
        linker.function_value(
            operation.symbol(),
            DefaultFactory.opaque(Arc::new(SignalOperationFunction { operation }))?,
        )?;
    }
    Ok(())
}

/// Calls `signal/convolve` with evaluated signal, kernel, and keyword pairs.
pub fn call_signal_convolve(cx: &mut Cx, args: Args) -> Result<Value> {
    execute_values(cx, Operation::Convolve, args.into_vec())
}

/// Calls `signal/correlate` with evaluated signal, kernel, and keyword pairs.
pub fn call_signal_correlate(cx: &mut Cx, args: Args) -> Result<Value> {
    execute_values(cx, Operation::Correlate, args.into_vec())
}

/// Calls `signal/deconvolve` with evaluated observation, kernel, and keyword pairs.
pub fn call_signal_deconvolve(cx: &mut Cx, args: Args) -> Result<Value> {
    execute_values(cx, Operation::Deconvolve, args.into_vec())
}

pub(crate) fn argument_error(operation: Operation) -> Error {
    Error::Eval(format!(
        "{} expects signal, kernel, and optional keyword pairs",
        operation.name()
    ))
}