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

//! Implements a floating-point register bank.

use osiris_data::data::atomic::Word;
use osiris_data::data::composite::Array;
use osiris_data::data::identification::Identifier;

use crate::register::{RegisterId, RegisterRange, REGISTERS_IN_BANK};

pub type VectorApplication = fn(&[Number]) -> Number;

#[derive(Copy, Clone, Debug, Default)]
pub struct Number(f64);

impl Number {
    pub fn new(data: f64) -> Self { Self(data) }

    pub fn to_f64(&self) -> f64 { self.0 }
    pub fn from_u64(data: u64) -> Self { Self::new(f64::from_bits(data)) }
    pub fn from_word(data: Word) -> Self { Self::new(f64::from_bits(data.to_u64())) }
    pub fn to_u64(&self) -> u64 { self.0.to_bits() }
    pub fn to_word(&self) -> Word { Word::new(self.to_u64()) }

    pub fn from_words_slice(from: &[Word]) -> Vec<Self> {
        let mut slice = vec![];
        for e in from {
            slice.push(Self::from_word(*e));
        }
        slice
    }

    pub fn slice_to_array(from: &[Self]) -> Array {
        let mut array:Array = Array::new(0);
        for e in from {
            array.push(e.to_word());
        }
        array
    }
}

#[derive(Clone, Debug)]
pub struct Vector {
    registers: Vec<Number>,
}

impl Vector {
    pub fn new() -> Self {
        Self { registers: vec![Number::default(); REGISTERS_IN_BANK] }
    }

    pub fn set(&mut self, register: RegisterId, number: Number) {
        if register.to_usize() > REGISTERS_IN_BANK {
            return;
        }
        self.registers[register.to_usize()] = number;
    }

    pub fn get(&self, register: RegisterId) -> Number {
        self.registers[register.to_usize()]
    }

    pub fn apply(&self, range: RegisterRange, function: VectorApplication) -> Number {
        let slice = &self.registers[range.to_usize_range()];
        function(slice)
    }
    pub fn slice(&self, range: RegisterRange) -> &[Number] {
        &self.registers[range.to_usize_range()]
    }
    pub fn copy(&mut self, to: RegisterId, slice: &[Number]) {
        let mut index = to.to_usize();
        for w in slice {
            self.registers[index] = *w;
            index += 1;
        }
    }
}

impl Default for Vector {
    fn default() -> Self { Self::new() }
}