need to redesign, can't just start programming
This commit is contained in:
parent
e0414009ff
commit
528aeb1c9b
@ -1,353 +0,0 @@
|
|||||||
use std::ops::Not;
|
|
||||||
|
|
||||||
use crate::push::state::{Gene, PushState};
|
|
||||||
|
|
||||||
/// Checks to see if a single gene is a block.
|
|
||||||
fn _is_block(vals: Vec<Gene>) -> Option<bool> {
|
|
||||||
Some(match vals[0] {
|
|
||||||
Gene::Block(_) => true,
|
|
||||||
_ => false,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, boolean, _is_block, Gene, 1);
|
|
||||||
|
|
||||||
/// Checks to see if a single gene is not a block.
|
|
||||||
fn _is_singular(vals: Vec<Gene>) -> Option<bool> {
|
|
||||||
Some(_is_block(vals)?.not())
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, boolean, _is_singular, Gene, 1);
|
|
||||||
|
|
||||||
/// Returns the length of a block, else 1 if not a block
|
|
||||||
fn _length(vals: Vec<Gene>) -> Option<i128> {
|
|
||||||
Some(match &vals[0] {
|
|
||||||
Gene::Block(x) => x.len() as i128,
|
|
||||||
_ => 1,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, int, _length, Gene, 1);
|
|
||||||
|
|
||||||
/// Returns the first item in a block if doable, else None
|
|
||||||
fn _first(vals: Vec<Gene>) -> Option<Gene> {
|
|
||||||
match &vals[0] {
|
|
||||||
Gene::Block(x) => {
|
|
||||||
if x.len() > 1 {
|
|
||||||
Some(x[0].clone())
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, code, _first, Gene, 1);
|
|
||||||
|
|
||||||
/// Returns the first item in a block if applicable, else None
|
|
||||||
fn _last(vals: Vec<Gene>) -> Option<Gene> {
|
|
||||||
match &vals[0] {
|
|
||||||
Gene::Block(x) => {
|
|
||||||
if x.len() > 1 {
|
|
||||||
Some(x.last()?.clone())
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, code, _last, Gene, 1);
|
|
||||||
|
|
||||||
/// Returns all but the first code item in a block if applicable, else None
|
|
||||||
fn _rest(vals: Vec<Gene>) -> Option<Gene> {
|
|
||||||
match &vals[0] {
|
|
||||||
Gene::Block(x) => {
|
|
||||||
if x.len() > 1 {
|
|
||||||
Some(Gene::Block(Box::new(x[1..].to_vec())))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, code, _rest, Gene, 1);
|
|
||||||
|
|
||||||
/// Returns all but the first code item in a block if applicable, else None
|
|
||||||
fn _but_last(vals: Vec<Gene>) -> Option<Gene> {
|
|
||||||
match &vals[0] {
|
|
||||||
Gene::Block(x) => {
|
|
||||||
let x_len = x.len();
|
|
||||||
if x_len > 1 {
|
|
||||||
Some(Gene::Block(Box::new(x[..x_len - 1].to_vec())))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, code, _but_last, Gene, 1);
|
|
||||||
|
|
||||||
/// Returns all of the vals wrapped in a code block
|
|
||||||
fn _wrap_block(vals: Vec<Gene>) -> Option<Gene> {
|
|
||||||
Some(Gene::Block(Box::new(vals)))
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, code, _wrap_block, Gene, 1);
|
|
||||||
|
|
||||||
/// Combines two genes into one. Accounts for blocks.
|
|
||||||
/// If the second gene is a block and the first one isn't,
|
|
||||||
/// appends the first gene to the second gene.
|
|
||||||
fn _combine(vals: Vec<Gene>) -> Option<Gene> {
|
|
||||||
match (&vals[0], &vals[1]) {
|
|
||||||
(Gene::Block(x), Gene::Block(y)) => {
|
|
||||||
let x_clone = x.clone();
|
|
||||||
let mut y_clone = y.clone();
|
|
||||||
y_clone.extend(x_clone.into_iter());
|
|
||||||
Some(Gene::Block(y_clone))
|
|
||||||
}
|
|
||||||
(Gene::Block(x), y) => {
|
|
||||||
let mut x_clone = x.clone();
|
|
||||||
x_clone.push(y.clone());
|
|
||||||
Some(Gene::Block(x_clone))
|
|
||||||
}
|
|
||||||
(x, Gene::Block(y)) => {
|
|
||||||
let mut y_clone = y.clone();
|
|
||||||
y_clone.push(x.clone());
|
|
||||||
Some(Gene::Block(y_clone))
|
|
||||||
}
|
|
||||||
(x, y) => Some(Gene::Block(Box::new(vec![x.clone(), y.clone()]))),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, code, _combine, Gene, 2);
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use super::*;
|
|
||||||
use crate::push::state::EMPTY_STATE;
|
|
||||||
use rust_decimal::dec;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn is_block_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![]))];
|
|
||||||
code_is_block(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
test_state.boolean.clear();
|
|
||||||
|
|
||||||
test_state.code = vec![(Gene::GeneInt(1))];
|
|
||||||
code_is_block(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn is_singular_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![]))];
|
|
||||||
code_is_singular(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
test_state.boolean.clear();
|
|
||||||
|
|
||||||
test_state.code = vec![(Gene::GeneInt(1))];
|
|
||||||
code_is_singular(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn length_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
]))];
|
|
||||||
code_length(&mut test_state);
|
|
||||||
assert_eq!(vec![2], test_state.int);
|
|
||||||
test_state.int.clear();
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![]))];
|
|
||||||
code_length(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
test_state.int.clear();
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::GeneInt(3)];
|
|
||||||
code_length(&mut test_state);
|
|
||||||
assert_eq!(vec![1], test_state.int);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn first_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
]))];
|
|
||||||
code_first(&mut test_state);
|
|
||||||
assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
|
|
||||||
|
|
||||||
test_state.code = vec![];
|
|
||||||
code_first(&mut test_state);
|
|
||||||
let empty_vec: Vec<Gene> = vec![];
|
|
||||||
assert_eq!(empty_vec, test_state.code);
|
|
||||||
drop(empty_vec);
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::GeneInt(1)];
|
|
||||||
code_first(&mut test_state);
|
|
||||||
assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn last_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
]))];
|
|
||||||
code_last(&mut test_state);
|
|
||||||
assert_eq!(vec![Gene::GeneFloat(dec!(3.8))], test_state.code);
|
|
||||||
|
|
||||||
test_state.code = vec![];
|
|
||||||
code_last(&mut test_state);
|
|
||||||
let empty_vec: Vec<Gene> = vec![];
|
|
||||||
assert_eq!(empty_vec, test_state.code);
|
|
||||||
drop(empty_vec);
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::GeneInt(1)];
|
|
||||||
code_last(&mut test_state);
|
|
||||||
assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn rest_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
Gene::GeneBoolean(true),
|
|
||||||
]))];
|
|
||||||
code_rest(&mut test_state);
|
|
||||||
assert_eq!(
|
|
||||||
vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
Gene::GeneBoolean(true)
|
|
||||||
]))],
|
|
||||||
test_state.code
|
|
||||||
);
|
|
||||||
|
|
||||||
test_state.code = vec![];
|
|
||||||
code_rest(&mut test_state);
|
|
||||||
let empty_vec: Vec<Gene> = vec![];
|
|
||||||
assert_eq!(empty_vec, test_state.code);
|
|
||||||
drop(empty_vec);
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::GeneInt(1)];
|
|
||||||
code_rest(&mut test_state);
|
|
||||||
assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn but_last_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
Gene::GeneBoolean(true),
|
|
||||||
]))];
|
|
||||||
code_but_last(&mut test_state);
|
|
||||||
assert_eq!(
|
|
||||||
vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
]))],
|
|
||||||
test_state.code
|
|
||||||
);
|
|
||||||
|
|
||||||
test_state.code = vec![];
|
|
||||||
code_but_last(&mut test_state);
|
|
||||||
let empty_vec: Vec<Gene> = vec![];
|
|
||||||
assert_eq!(empty_vec, test_state.code);
|
|
||||||
drop(empty_vec);
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::GeneInt(1)];
|
|
||||||
code_but_last(&mut test_state);
|
|
||||||
assert_eq!(vec![Gene::GeneInt(1)], test_state.code);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn wrap_block_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.code = vec![Gene::GeneInt(1)];
|
|
||||||
code_wrap_block(&mut test_state);
|
|
||||||
assert_eq!(
|
|
||||||
vec![Gene::Block(Box::new(vec![Gene::GeneInt(1)]))],
|
|
||||||
test_state.code
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn combine_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state
|
|
||||||
.code
|
|
||||||
.push(Gene::Block(Box::new(vec![Gene::GeneInt(1)])));
|
|
||||||
test_state.code.push(Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
Gene::GeneBoolean(true),
|
|
||||||
])));
|
|
||||||
code_combine(&mut test_state);
|
|
||||||
assert_eq!(
|
|
||||||
vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(3.8)),
|
|
||||||
Gene::GeneBoolean(true),
|
|
||||||
]))],
|
|
||||||
test_state.code
|
|
||||||
);
|
|
||||||
test_state.code.clear();
|
|
||||||
|
|
||||||
test_state
|
|
||||||
.code
|
|
||||||
.push(Gene::Block(Box::new(vec![Gene::GeneInt(1)])));
|
|
||||||
test_state.code.push(Gene::GeneFloat(dec!(4.0)));
|
|
||||||
code_combine(&mut test_state);
|
|
||||||
assert_eq!(
|
|
||||||
vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(4.0)),
|
|
||||||
]))],
|
|
||||||
test_state.code
|
|
||||||
);
|
|
||||||
test_state.code.clear();
|
|
||||||
|
|
||||||
test_state.code.push(Gene::GeneFloat(dec!(4.0)));
|
|
||||||
test_state
|
|
||||||
.code
|
|
||||||
.push(Gene::Block(Box::new(vec![Gene::GeneInt(1)])));
|
|
||||||
code_combine(&mut test_state);
|
|
||||||
assert_eq!(
|
|
||||||
vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(4.0)),
|
|
||||||
]))],
|
|
||||||
test_state.code
|
|
||||||
);
|
|
||||||
test_state.code.clear();
|
|
||||||
|
|
||||||
test_state.code.push(Gene::GeneFloat(dec!(4.0)));
|
|
||||||
test_state.code.push(Gene::GeneChar('z'));
|
|
||||||
code_combine(&mut test_state);
|
|
||||||
assert_eq!(
|
|
||||||
vec![Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneChar('z'),
|
|
||||||
Gene::GeneFloat(dec!(4.0)),
|
|
||||||
]))],
|
|
||||||
test_state.code
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,29 +0,0 @@
|
|||||||
use crate::push::state::{Gene, PushState};
|
|
||||||
|
|
||||||
/// Acts as a NoOp, does nothing with the vals list.
|
|
||||||
fn _noop<T>(_: Vec<T>) -> Option<T> {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
make_instruction_clone!(code, code, _noop, Gene, 0);
|
|
||||||
make_instruction_clone!(exec, exec, _noop, Gene, 0);
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use super::*;
|
|
||||||
use crate::push::state::EMPTY_STATE;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn noop_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![1, 2];
|
|
||||||
let test_state_copy = test_state.clone();
|
|
||||||
code_noop(&mut test_state);
|
|
||||||
assert_eq!(test_state, test_state_copy);
|
|
||||||
|
|
||||||
test_state.int = vec![1, 2];
|
|
||||||
let test_state_copy = test_state.clone();
|
|
||||||
exec_noop(&mut test_state);
|
|
||||||
assert_eq!(test_state, test_state_copy);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,198 +0,0 @@
|
|||||||
//! # Logical Instructions
|
|
||||||
//!
|
|
||||||
//! This file holds instructions for the boolean stack.
|
|
||||||
|
|
||||||
use super::utils::{CastingTrait, LogicalTrait};
|
|
||||||
use crate::push::state::PushState;
|
|
||||||
use rust_decimal::Decimal;
|
|
||||||
|
|
||||||
/// Runs logical and on two values
|
|
||||||
fn _and<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + LogicalTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].logical_and(vals[1]))
|
|
||||||
}
|
|
||||||
make_instruction!(boolean, boolean, _and, bool, 2);
|
|
||||||
|
|
||||||
/// Runs logical or on two values
|
|
||||||
fn _or<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + LogicalTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].logical_or(vals[1]))
|
|
||||||
}
|
|
||||||
make_instruction!(boolean, boolean, _or, bool, 2);
|
|
||||||
|
|
||||||
/// Runs logical not on two values
|
|
||||||
fn _not<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + LogicalTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].logical_not())
|
|
||||||
}
|
|
||||||
make_instruction!(boolean, boolean, _not, bool, 1);
|
|
||||||
|
|
||||||
/// Runs logical xor on two values
|
|
||||||
fn _xor<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + LogicalTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].logical_xor(vals[1]))
|
|
||||||
}
|
|
||||||
make_instruction!(boolean, boolean, _xor, bool, 2);
|
|
||||||
|
|
||||||
/// Inverts the first value and runs logical and on two values
|
|
||||||
fn _invert_first_then_and<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + LogicalTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].logical_not().logical_and(vals[1]))
|
|
||||||
}
|
|
||||||
make_instruction!(boolean, boolean, _invert_first_then_and, bool, 2);
|
|
||||||
|
|
||||||
/// Inverts the second value and runs logical and on two values
|
|
||||||
fn _invert_second_then_and<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + LogicalTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].logical_and(vals[1].logical_not()))
|
|
||||||
}
|
|
||||||
make_instruction!(boolean, boolean, _invert_second_then_and, bool, 2);
|
|
||||||
|
|
||||||
fn _from_int<T>(vals: Vec<i128>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + CastingTrait,
|
|
||||||
{
|
|
||||||
T::from_int(vals[0])
|
|
||||||
}
|
|
||||||
make_instruction_out!(int, boolean, _from_int, i128, 1);
|
|
||||||
|
|
||||||
fn _from_float<T>(vals: Vec<Decimal>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + CastingTrait,
|
|
||||||
{
|
|
||||||
T::from_float(vals[0])
|
|
||||||
}
|
|
||||||
make_instruction_out!(float, boolean, _from_float, Decimal, 1);
|
|
||||||
|
|
||||||
pub fn boolean_instructions() -> Vec<fn(&mut PushState)> {
|
|
||||||
vec![
|
|
||||||
boolean_and,
|
|
||||||
boolean_or,
|
|
||||||
boolean_not,
|
|
||||||
boolean_xor,
|
|
||||||
boolean_invert_first_then_and,
|
|
||||||
boolean_invert_second_then_and,
|
|
||||||
boolean_from_int,
|
|
||||||
boolean_from_float,
|
|
||||||
]
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use super::*;
|
|
||||||
use crate::push::state::EMPTY_STATE;
|
|
||||||
use rust_decimal::dec;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn and_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, false, true];
|
|
||||||
boolean_and(&mut test_state);
|
|
||||||
assert_eq!(vec![true, false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, true];
|
|
||||||
boolean_and(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn or_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, false, true];
|
|
||||||
boolean_or(&mut test_state);
|
|
||||||
assert_eq!(vec![true, true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![false, false];
|
|
||||||
boolean_or(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn not_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, false, true];
|
|
||||||
boolean_not(&mut test_state);
|
|
||||||
assert_eq!(vec![true, false, false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![false, false];
|
|
||||||
boolean_not(&mut test_state);
|
|
||||||
assert_eq!(vec![false, true], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn xor_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, false, true];
|
|
||||||
boolean_xor(&mut test_state);
|
|
||||||
assert_eq!(vec![true, true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![false, false];
|
|
||||||
boolean_xor(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, true];
|
|
||||||
boolean_xor(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn invert_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, false];
|
|
||||||
boolean_invert_first_then_and(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![false, false];
|
|
||||||
boolean_invert_first_then_and(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![true, false];
|
|
||||||
boolean_invert_second_then_and(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.boolean = vec![false, true];
|
|
||||||
boolean_invert_second_then_and(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn cast_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![1];
|
|
||||||
boolean_from_int(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
test_state.boolean.clear();
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
boolean_from_int(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
test_state.boolean.clear();
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(2.0)];
|
|
||||||
boolean_from_float(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
test_state.boolean.clear();
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(0.0)];
|
|
||||||
boolean_from_float(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,135 +0,0 @@
|
|||||||
#[macro_use]
|
|
||||||
pub mod macros {
|
|
||||||
/// A macro that makes a push instruction given: the name of the input stack to use,
|
|
||||||
/// the name of the output stack, an internal function to call, the type of a function,
|
|
||||||
/// and the arity of the internal function call.
|
|
||||||
///
|
|
||||||
/// The `in_stack` argument refers to which push stack should this operate on.
|
|
||||||
/// The `out_stack` argument refers to which push stack should the result be pushed to.
|
|
||||||
/// The `fn_name` argement refers to the name of the function that is to operate
|
|
||||||
/// on the values popped from `in_stack`.
|
|
||||||
/// The `fn_type` argument refers to the type of `in_stack`. For example, the
|
|
||||||
/// int stack is type: *Vec<i128>*. `fn_type` is *i128* in this case.
|
|
||||||
/// The `fn_arity` argument refers to how many popped stack items are needed to
|
|
||||||
/// execute the instruction. If the amount of items in the stack is less than
|
|
||||||
/// this value, the instruction does nothing.
|
|
||||||
///
|
|
||||||
/// What causes an instruction to NoOp:
|
|
||||||
/// 1) There aren't enough values on a stack to execute an instruction.
|
|
||||||
/// 2) The internal operation the instruction executes is unable to be ran without
|
|
||||||
/// erroring such as division by 0.
|
|
||||||
#[macro_export]
|
|
||||||
macro_rules! make_instruction {
|
|
||||||
($in_stack:ident, $out_stack:ident, $fn_name:ident, $fn_type:ty, $fn_arity:stmt) => {
|
|
||||||
paste::item! {
|
|
||||||
/// Runs the $fn_name function on the top $fn_arity items from
|
|
||||||
/// the $in_stack and places the calculated value on the $out_stack.
|
|
||||||
pub fn [< $in_stack $fn_name >] (state: &mut PushState) {
|
|
||||||
let in_stack_len = state.$in_stack.len();
|
|
||||||
if in_stack_len < $fn_arity {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let mut inputs: Vec<$fn_type> = Vec::with_capacity($fn_arity);
|
|
||||||
for n in 1..=$fn_arity {
|
|
||||||
inputs.push(state.$in_stack[in_stack_len - n]);
|
|
||||||
}
|
|
||||||
if let Some(result) = $fn_name(inputs) {
|
|
||||||
for _ in 0..$fn_arity {
|
|
||||||
state.$in_stack.pop();
|
|
||||||
}
|
|
||||||
state.$out_stack.push(result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The same as make_instruction above but prepends the output
|
|
||||||
/// stack to the function name rather than the input stack.
|
|
||||||
#[macro_export]
|
|
||||||
macro_rules! make_instruction_out {
|
|
||||||
($in_stack:ident, $out_stack:ident, $fn_name:ident, $fn_type:ty, $fn_arity:stmt) => {
|
|
||||||
paste::item! {
|
|
||||||
/// Runs the $fn_name function on the top $fn_arity items from
|
|
||||||
/// the $in_stack and places the calculated value on the $out_stack.
|
|
||||||
pub fn [< $out_stack $fn_name >] (state: &mut PushState) {
|
|
||||||
let in_stack_len = state.$in_stack.len();
|
|
||||||
if in_stack_len < $fn_arity {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let mut inputs: Vec<$fn_type> = Vec::with_capacity($fn_arity);
|
|
||||||
for n in 1..=$fn_arity {
|
|
||||||
inputs.push(state.$in_stack[in_stack_len - n]);
|
|
||||||
}
|
|
||||||
if let Some(result) = $fn_name(inputs) {
|
|
||||||
for _ in 0..$fn_arity {
|
|
||||||
state.$in_stack.pop();
|
|
||||||
}
|
|
||||||
state.$out_stack.push(result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The same as make_instruction but uses clone() to fill the arguments
|
|
||||||
/// to each function rather than a reference. Is slower, but will be okay
|
|
||||||
/// for the time being.
|
|
||||||
#[macro_export]
|
|
||||||
macro_rules! make_instruction_clone {
|
|
||||||
($in_stack:ident, $out_stack:ident, $fn_name:ident, $fn_type:ty, $fn_arity:stmt) => {
|
|
||||||
paste::item! {
|
|
||||||
/// Runs the $fn_name function on the top $fn_arity items from
|
|
||||||
/// the $in_stack and places the calculated value on the $out_stack.
|
|
||||||
pub fn [< $in_stack $fn_name >] (state: &mut PushState) {
|
|
||||||
let in_stack_len = state.$in_stack.len();
|
|
||||||
if in_stack_len < $fn_arity {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let mut inputs: Vec<$fn_type> = Vec::with_capacity($fn_arity);
|
|
||||||
for n in 1..=$fn_arity {
|
|
||||||
inputs.push(state.$in_stack[in_stack_len - n].clone());
|
|
||||||
}
|
|
||||||
if let Some(result) = $fn_name(inputs) {
|
|
||||||
for _ in 0..$fn_arity {
|
|
||||||
state.$in_stack.pop();
|
|
||||||
}
|
|
||||||
state.$out_stack.push(result);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#[macro_export]
|
|
||||||
macro_rules! make_instruction_mult {
|
|
||||||
($in_stack:ident, $out_stack:ident, $fn_name:ident, $fn_type:ty, $fn_arity:stmt) => {
|
|
||||||
paste::item! {
|
|
||||||
/// Runs the $fn_name function on the top $fn_arity items from
|
|
||||||
/// the $in_stack and places the calculated value on the $out_stack.
|
|
||||||
pub fn [< $in_stack $fn_name >] (state: &mut PushState) {
|
|
||||||
let in_stack_len = state.$in_stack.len();
|
|
||||||
if in_stack_len < $fn_arity {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let mut inputs: Vec<$fn_type> = Vec::with_capacity($fn_arity);
|
|
||||||
for n in 1..=$fn_arity {
|
|
||||||
inputs.push(state.$in_stack[in_stack_len - n]);
|
|
||||||
}
|
|
||||||
if let Some(result) = $fn_name(inputs) {
|
|
||||||
for _ in 0..$fn_arity {
|
|
||||||
state.$in_stack.pop();
|
|
||||||
}
|
|
||||||
state.$out_stack.extend(result.iter());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub mod code;
|
|
||||||
pub mod common;
|
|
||||||
pub mod logical;
|
|
||||||
pub mod numeric;
|
|
||||||
pub mod utils;
|
|
||||||
@ -1,936 +0,0 @@
|
|||||||
//! # Numeric Instructions
|
|
||||||
//!
|
|
||||||
//! This file contains numeric instructions for int and float.
|
|
||||||
|
|
||||||
// There has to be a better way to declare these functions.
|
|
||||||
// Just don't know enough Rust yet ig.
|
|
||||||
|
|
||||||
use crate::push::state::PushState;
|
|
||||||
use rust_decimal::Decimal;
|
|
||||||
use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
|
|
||||||
use std::cmp::{max, min};
|
|
||||||
use std::ops::{Add, Div, Mul, Sub};
|
|
||||||
|
|
||||||
use super::utils::{CastingTrait, NumericTrait};
|
|
||||||
|
|
||||||
/// Adds two addable values together.
|
|
||||||
fn _add<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Add<Output = T> + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[1] + vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _add, i128, 2);
|
|
||||||
make_instruction!(float, float, _add, Decimal, 2);
|
|
||||||
|
|
||||||
/// Subtracts two subtractable values from each other.
|
|
||||||
fn _sub<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Sub<Output = T> + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[1] - vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _sub, i128, 2);
|
|
||||||
make_instruction!(float, float, _sub, Decimal, 2);
|
|
||||||
|
|
||||||
/// Multiplies two multipliable values together.
|
|
||||||
fn _mult<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Mul<Output = T> + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[1] * vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _mult, i128, 2);
|
|
||||||
make_instruction!(float, float, _mult, Decimal, 2);
|
|
||||||
|
|
||||||
/// Divides two values from each other.
|
|
||||||
fn _div<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Div<Output = T> + Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[1].checked_div(vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _div, i128, 2);
|
|
||||||
make_instruction!(float, float, _div, Decimal, 2);
|
|
||||||
|
|
||||||
/// Takes the remainder of two values
|
|
||||||
fn _rem<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Div<Output = T> + Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[1].checked_mod(vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _rem, i128, 2);
|
|
||||||
make_instruction!(float, float, _rem, Decimal, 2);
|
|
||||||
|
|
||||||
/// Takes the max of two values
|
|
||||||
fn _max<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Ord + Copy,
|
|
||||||
{
|
|
||||||
Some(max(vals[1], vals[0]))
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _max, i128, 2);
|
|
||||||
make_instruction!(float, float, _max, Decimal, 2);
|
|
||||||
|
|
||||||
/// Takes the min of two values
|
|
||||||
fn _min<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Ord + Copy,
|
|
||||||
{
|
|
||||||
Some(min(vals[1], vals[0]))
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _min, i128, 2);
|
|
||||||
make_instruction!(float, float, _min, Decimal, 2);
|
|
||||||
|
|
||||||
/// Increments a single value by 1
|
|
||||||
fn _inc<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: NumericTrait + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[0].increment())
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _inc, i128, 1);
|
|
||||||
make_instruction!(float, float, _inc, Decimal, 1);
|
|
||||||
|
|
||||||
/// Decrements a single value by 1
|
|
||||||
fn _dec<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: NumericTrait + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[0].decrement())
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _dec, i128, 1);
|
|
||||||
make_instruction!(float, float, _dec, Decimal, 1);
|
|
||||||
|
|
||||||
/// Checks if the 2nd to top value is less than the top value
|
|
||||||
fn _lt<T>(vals: Vec<T>) -> Option<bool>
|
|
||||||
where
|
|
||||||
T: Ord + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[1] < vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, boolean, _lt, i128, 2);
|
|
||||||
make_instruction!(float, boolean, _lt, Decimal, 2);
|
|
||||||
|
|
||||||
/// Checks if the 2nd to top value is greater than the top value
|
|
||||||
fn _gt<T>(vals: Vec<T>) -> Option<bool>
|
|
||||||
where
|
|
||||||
T: Ord + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[1] > vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, boolean, _gt, i128, 2);
|
|
||||||
make_instruction!(float, boolean, _gt, Decimal, 2);
|
|
||||||
|
|
||||||
/// Checks if the 2nd to top value is less than or equal to the top value
|
|
||||||
fn _lte<T>(vals: Vec<T>) -> Option<bool>
|
|
||||||
where
|
|
||||||
T: Ord + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[1] <= vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, boolean, _lte, i128, 2);
|
|
||||||
make_instruction!(float, boolean, _lte, Decimal, 2);
|
|
||||||
|
|
||||||
/// Checks if the 2nd to top value is greater than or equal to the top value
|
|
||||||
fn _gte<T>(vals: Vec<T>) -> Option<bool>
|
|
||||||
where
|
|
||||||
T: Ord + Copy,
|
|
||||||
{
|
|
||||||
Some(vals[1] >= vals[0])
|
|
||||||
}
|
|
||||||
make_instruction!(int, boolean, _gte, i128, 2);
|
|
||||||
make_instruction!(float, boolean, _gte, Decimal, 2);
|
|
||||||
|
|
||||||
/// Runs sin on a single item.
|
|
||||||
fn _sin<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_sin()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _sin, i128, 1);
|
|
||||||
make_instruction!(float, float, _sin, Decimal, 1);
|
|
||||||
|
|
||||||
/// Runs arcsin on a single item.
|
|
||||||
fn _arcsin<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_sin()?.inverse()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _arcsin, i128, 1);
|
|
||||||
make_instruction!(float, float, _arcsin, Decimal, 1);
|
|
||||||
|
|
||||||
/// Runs cos on a single item.
|
|
||||||
fn _cos<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_cos()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _cos, i128, 1);
|
|
||||||
make_instruction!(float, float, _cos, Decimal, 1);
|
|
||||||
|
|
||||||
/// Runs arcsin on a single item.
|
|
||||||
fn _arccos<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_cos()?.inverse()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _arccos, i128, 1);
|
|
||||||
make_instruction!(float, float, _arccos, Decimal, 1);
|
|
||||||
|
|
||||||
/// Runs tan on a single item.
|
|
||||||
fn _tan<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_tan()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _tan, i128, 1);
|
|
||||||
make_instruction!(float, float, _tan, Decimal, 1);
|
|
||||||
|
|
||||||
/// Runs arctan on a single item.
|
|
||||||
fn _arctan<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_tan()?.inverse()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _arctan, i128, 1);
|
|
||||||
make_instruction!(float, float, _arctan, Decimal, 1);
|
|
||||||
|
|
||||||
/// Converts a single value from a float to an arbitrary type.
|
|
||||||
fn _from_int<T>(vals: Vec<i128>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + CastingTrait,
|
|
||||||
{
|
|
||||||
T::from_int(vals[0])
|
|
||||||
}
|
|
||||||
make_instruction_out!(int, float, _from_int, i128, 1);
|
|
||||||
|
|
||||||
/// Converts a single value from a float to an arbitrary type.
|
|
||||||
fn _from_float<T>(vals: Vec<Decimal>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + CastingTrait,
|
|
||||||
{
|
|
||||||
T::from_float(vals[0])
|
|
||||||
}
|
|
||||||
make_instruction_out!(float, int, _from_float, Decimal, 1);
|
|
||||||
|
|
||||||
/// Converts a bool to a to a new type.
|
|
||||||
fn _from_boolean<T>(vals: Vec<bool>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + CastingTrait,
|
|
||||||
{
|
|
||||||
T::from_bool(vals[0])
|
|
||||||
}
|
|
||||||
make_instruction_out!(boolean, int, _from_boolean, bool, 1);
|
|
||||||
make_instruction_out!(boolean, float, _from_boolean, bool, 1);
|
|
||||||
|
|
||||||
/// Takes the log base 10 of a single Decimal. Acts as a
|
|
||||||
/// NoOp if the value is 0. If the value is negative, takes
|
|
||||||
/// the absolute value of the number.
|
|
||||||
fn _log<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].absolute().safe_log10()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _log, i128, 1);
|
|
||||||
make_instruction!(float, float, _log, Decimal, 1);
|
|
||||||
|
|
||||||
/// Takes the exp of a single value. Ints get truncated.
|
|
||||||
fn _exp<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_exp()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _exp, i128, 1);
|
|
||||||
make_instruction!(float, float, _exp, Decimal, 1);
|
|
||||||
|
|
||||||
/// Takes the square root of the absolute value of a single value.
|
|
||||||
fn _sqrt<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].safe_sqrt()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _sqrt, i128, 1);
|
|
||||||
make_instruction!(float, float, _sqrt, Decimal, 1);
|
|
||||||
|
|
||||||
/// Takes the inverse of a single value. If the number is 0,
|
|
||||||
/// does nothing (returns None). Truncates an int to 0.
|
|
||||||
fn _inv<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
vals[0].inverse()
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _inv, i128, 1);
|
|
||||||
make_instruction!(float, float, _inv, Decimal, 1);
|
|
||||||
|
|
||||||
/// Takes the absolute value of the top number
|
|
||||||
fn _abs<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].absolute())
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _abs, i128, 1);
|
|
||||||
make_instruction!(float, float, _abs, Decimal, 1);
|
|
||||||
|
|
||||||
/// Reverses the sign of the top number
|
|
||||||
fn _sign_reverse<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].sign_reverse())
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _sign_reverse, i128, 1);
|
|
||||||
make_instruction!(float, float, _sign_reverse, Decimal, 1);
|
|
||||||
|
|
||||||
/// Squares the top number
|
|
||||||
fn _square<T>(vals: Vec<T>) -> Option<T>
|
|
||||||
where
|
|
||||||
T: Copy + NumericTrait,
|
|
||||||
{
|
|
||||||
Some(vals[0].square())
|
|
||||||
}
|
|
||||||
make_instruction!(int, int, _square, i128, 1);
|
|
||||||
make_instruction!(float, float, _square, Decimal, 1);
|
|
||||||
|
|
||||||
/// A list of all of the defined int functions in this file.
|
|
||||||
/// Must manually register functions in this list if added.
|
|
||||||
pub fn int_instructions() -> Vec<fn(&mut PushState)> {
|
|
||||||
vec![
|
|
||||||
int_add,
|
|
||||||
int_sub,
|
|
||||||
int_mult,
|
|
||||||
int_div,
|
|
||||||
int_rem,
|
|
||||||
int_max,
|
|
||||||
int_min,
|
|
||||||
int_inc,
|
|
||||||
int_dec,
|
|
||||||
int_lt,
|
|
||||||
int_gt,
|
|
||||||
int_lte,
|
|
||||||
int_gte,
|
|
||||||
int_sin,
|
|
||||||
int_arcsin,
|
|
||||||
int_cos,
|
|
||||||
int_arccos,
|
|
||||||
int_tan,
|
|
||||||
int_arctan,
|
|
||||||
int_from_float,
|
|
||||||
int_from_boolean,
|
|
||||||
int_log,
|
|
||||||
int_exp,
|
|
||||||
int_sqrt,
|
|
||||||
int_inv,
|
|
||||||
int_abs,
|
|
||||||
int_sign_reverse,
|
|
||||||
int_square,
|
|
||||||
]
|
|
||||||
}
|
|
||||||
|
|
||||||
/// All of the float instructions declared in this file.
|
|
||||||
pub fn float_instructions() -> Vec<fn(&mut PushState)> {
|
|
||||||
vec![
|
|
||||||
float_add,
|
|
||||||
float_sub,
|
|
||||||
float_mult,
|
|
||||||
float_div,
|
|
||||||
float_rem,
|
|
||||||
float_max,
|
|
||||||
float_min,
|
|
||||||
float_inc,
|
|
||||||
float_dec,
|
|
||||||
float_lt,
|
|
||||||
float_gt,
|
|
||||||
float_lte,
|
|
||||||
float_gte,
|
|
||||||
float_sin,
|
|
||||||
float_arcsin,
|
|
||||||
float_cos,
|
|
||||||
float_arccos,
|
|
||||||
float_tan,
|
|
||||||
float_arctan,
|
|
||||||
float_from_int,
|
|
||||||
float_from_boolean,
|
|
||||||
float_log,
|
|
||||||
float_exp,
|
|
||||||
float_sqrt,
|
|
||||||
float_inv,
|
|
||||||
float_abs,
|
|
||||||
float_sign_reverse,
|
|
||||||
float_square,
|
|
||||||
]
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use super::*;
|
|
||||||
use crate::push::state::EMPTY_STATE;
|
|
||||||
use rust_decimal::dec;
|
|
||||||
|
|
||||||
/// Tests the _add function.
|
|
||||||
#[test]
|
|
||||||
fn add_test() {
|
|
||||||
let vals: Vec<i64> = vec![1, 2];
|
|
||||||
assert_eq!(Some(3), _add(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(1.1), dec!(2.2)];
|
|
||||||
assert_eq!(Some(dec!(3.3)), _add(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _sub function.
|
|
||||||
#[test]
|
|
||||||
fn sub_test() {
|
|
||||||
let vals: Vec<i64> = vec![1, 2];
|
|
||||||
assert_eq!(Some(1), _sub(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(1.1), dec!(2.2)];
|
|
||||||
assert_eq!(Some(dec!(1.1)), _sub(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _mult function.
|
|
||||||
#[test]
|
|
||||||
fn mult_test() {
|
|
||||||
let vals: Vec<i128> = vec![4, 5];
|
|
||||||
assert_eq!(Some(20), _mult(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(1.1), dec!(2.2)];
|
|
||||||
assert_eq!(Some(dec!(2.42)), _mult(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _div function
|
|
||||||
#[test]
|
|
||||||
fn div_test() {
|
|
||||||
let vals: Vec<i128> = vec![4, 20];
|
|
||||||
assert_eq!(Some(5), _div(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 20];
|
|
||||||
assert_eq!(Some(6), _div(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(1.6), dec!(2.2)];
|
|
||||||
assert_eq!(Some(dec!(1.375)), _div(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![0, 1];
|
|
||||||
assert_eq!(None, _div(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _rem function
|
|
||||||
#[test]
|
|
||||||
fn rem_test() {
|
|
||||||
let vals: Vec<i128> = vec![3, 20];
|
|
||||||
assert_eq!(Some(2), _rem(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![20, 20];
|
|
||||||
assert_eq!(Some(0), _rem(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![0, 9];
|
|
||||||
assert_eq!(None, _rem(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _max function
|
|
||||||
#[test]
|
|
||||||
fn max_test() {
|
|
||||||
let vals: Vec<i128> = vec![1, 2];
|
|
||||||
assert_eq!(Some(2), _max(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 0];
|
|
||||||
assert_eq!(Some(3), _max(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(2.2), dec!(1.1)];
|
|
||||||
assert_eq!(Some(dec!(2.2)), _max(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(3.3), dec!(-1.1)];
|
|
||||||
assert_eq!(Some(dec!(3.3)), _max(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _min function
|
|
||||||
#[test]
|
|
||||||
fn min_test() {
|
|
||||||
let vals: Vec<i128> = vec![1, 2];
|
|
||||||
assert_eq!(Some(1), _min(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 0];
|
|
||||||
assert_eq!(Some(0), _min(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(2.2), dec!(1.1)];
|
|
||||||
assert_eq!(Some(dec!(1.1)), _min(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(3.3), dec!(-1.1)];
|
|
||||||
assert_eq!(Some(dec!(-1.1)), _min(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _inc and _dec functions
|
|
||||||
#[test]
|
|
||||||
fn inc_dec_test() {
|
|
||||||
let vals: Vec<i128> = vec![2];
|
|
||||||
assert_eq!(Some(3), _inc(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![10];
|
|
||||||
assert_eq!(Some(9), _dec(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(2.2)];
|
|
||||||
assert_eq!(Some(dec!(3.2)), _inc(vals));
|
|
||||||
|
|
||||||
let vals: Vec<Decimal> = vec![dec!(5.6)];
|
|
||||||
assert_eq!(Some(dec!(4.6)), _dec(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the _lt, _gt, _lte, and _gte functions
|
|
||||||
#[test]
|
|
||||||
fn lt_gt_lte_gte_test() {
|
|
||||||
let vals: Vec<i128> = vec![3, 2];
|
|
||||||
assert_eq!(Some(true), _lt(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![1, 4];
|
|
||||||
assert_eq!(Some(false), _lt(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 3];
|
|
||||||
assert_eq!(Some(false), _lt(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![2, 3];
|
|
||||||
assert_eq!(Some(true), _gt(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![4, 1];
|
|
||||||
assert_eq!(Some(false), _gt(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 3];
|
|
||||||
assert_eq!(Some(false), _gt(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 2];
|
|
||||||
assert_eq!(Some(true), _lte(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![1, 4];
|
|
||||||
assert_eq!(Some(false), _lte(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 3];
|
|
||||||
assert_eq!(Some(true), _lte(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![2, 3];
|
|
||||||
assert_eq!(Some(true), _gte(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![4, 1];
|
|
||||||
assert_eq!(Some(false), _gte(vals));
|
|
||||||
|
|
||||||
let vals: Vec<i128> = vec![3, 3];
|
|
||||||
assert_eq!(Some(true), _gte(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the various trig functions.
|
|
||||||
#[test]
|
|
||||||
fn trig_tests() {
|
|
||||||
let vals = vec![Decimal::PI];
|
|
||||||
assert_eq!(Some(dec!(0.0)), _sin(vals));
|
|
||||||
|
|
||||||
let vals = vec![Decimal::QUARTER_PI];
|
|
||||||
assert_eq!(Some(dec!(1.4142135623869512272301701717)), _arcsin(vals));
|
|
||||||
|
|
||||||
let vals = vec![Decimal::PI];
|
|
||||||
assert_eq!(Some(dec!(-1.0)), _cos(vals));
|
|
||||||
|
|
||||||
let vals = vec![Decimal::QUARTER_PI];
|
|
||||||
assert_eq!(Some(dec!(1.4142135626023406165042434783)), _arccos(vals));
|
|
||||||
|
|
||||||
let vals = vec![Decimal::PI];
|
|
||||||
assert_eq!(Some(dec!(0.0)), _tan(vals));
|
|
||||||
|
|
||||||
let vals = vec![Decimal::QUARTER_PI];
|
|
||||||
assert_eq!(Some(dec!(1.0000000043184676055890307049)), _arctan(vals));
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests that the various addition functions.
|
|
||||||
#[test]
|
|
||||||
fn state_add() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
test_state.int = vec![1, 2];
|
|
||||||
test_state.float = vec![dec!(1.1), dec!(2.2)];
|
|
||||||
|
|
||||||
int_add(&mut test_state);
|
|
||||||
assert_eq!(vec![3], test_state.int);
|
|
||||||
|
|
||||||
float_add(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(3.3)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the various subtraction functions.
|
|
||||||
#[test]
|
|
||||||
fn state_sub() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
test_state.int = vec![1, 2];
|
|
||||||
test_state.float = vec![dec!(1.1), dec!(2.2)];
|
|
||||||
|
|
||||||
int_sub(&mut test_state);
|
|
||||||
assert_eq!(vec![-1], test_state.int);
|
|
||||||
|
|
||||||
float_sub(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(-1.1)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the various multiplication functions.
|
|
||||||
#[test]
|
|
||||||
fn state_mult() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
int_mult(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![10, 3, 2];
|
|
||||||
test_state.float = vec![dec!(1.1), dec!(2.2)];
|
|
||||||
|
|
||||||
int_mult(&mut test_state);
|
|
||||||
assert_eq!(vec![10, 6], test_state.int);
|
|
||||||
|
|
||||||
float_mult(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(2.42)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the division functions in the state
|
|
||||||
#[test]
|
|
||||||
fn state_div() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
int_div(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![2, 0];
|
|
||||||
int_div(&mut test_state);
|
|
||||||
assert_eq!(vec![2, 0], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![6, 3];
|
|
||||||
|
|
||||||
int_div(&mut test_state);
|
|
||||||
assert_eq!(vec![2], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(2.2), dec!(1.6)];
|
|
||||||
float_div(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(1.375)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the remainder functions in the state.
|
|
||||||
#[test]
|
|
||||||
fn state_rem() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
int_rem(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![2, 0];
|
|
||||||
int_rem(&mut test_state);
|
|
||||||
assert_eq!(vec![2, 0], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![60, 80, 20, 3];
|
|
||||||
int_rem(&mut test_state);
|
|
||||||
assert_eq!(vec![60, 80, 2], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(2.7), dec!(1.2)];
|
|
||||||
float_rem(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(0.3)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the min and max functions in the state
|
|
||||||
#[test]
|
|
||||||
fn state_min_max() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
int_max(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
int_min(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![1, 2, 3];
|
|
||||||
int_max(&mut test_state);
|
|
||||||
assert_eq!(vec![1, 3], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![1, 2, 3];
|
|
||||||
int_min(&mut test_state);
|
|
||||||
assert_eq!(vec![1, 2], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(1.2), dec!(4.6)];
|
|
||||||
float_max(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(4.6)], test_state.float);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(0.0), dec!(1.2), dec!(4.6)];
|
|
||||||
float_min(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(0.0), dec!(1.2)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the inc and dec functions in the state
|
|
||||||
#[test]
|
|
||||||
fn state_inc_dec() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![];
|
|
||||||
int_inc(&mut test_state);
|
|
||||||
let empty_vec: Vec<i128> = vec![];
|
|
||||||
assert_eq!(empty_vec, test_state.int);
|
|
||||||
|
|
||||||
drop(empty_vec);
|
|
||||||
|
|
||||||
test_state.int = vec![-2, 1];
|
|
||||||
int_inc(&mut test_state);
|
|
||||||
assert_eq!(vec![-2, 2], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![-2, 1];
|
|
||||||
int_dec(&mut test_state);
|
|
||||||
assert_eq!(vec![-2, 0], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(1.1)];
|
|
||||||
float_inc(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(2.1)], test_state.float);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(1.1)];
|
|
||||||
float_dec(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(0.1)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the lt, gt, lte, gte functions in the state
|
|
||||||
#[test]
|
|
||||||
fn state_lt_gt_lte_gte() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![2, 3];
|
|
||||||
int_lt(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![4, 1];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_lt(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![3, 3];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_lt(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![3, 2];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_gt(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![1, 4];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_gt(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![3, 3];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_gt(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![2, 3];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_lte(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![4, 1];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_lte(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![3, 3];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_lte(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![3, 2];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_gte(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![1, 4];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_gte(&mut test_state);
|
|
||||||
assert_eq!(vec![false], test_state.boolean);
|
|
||||||
|
|
||||||
test_state.int = vec![3, 3];
|
|
||||||
test_state.boolean = vec![];
|
|
||||||
int_gte(&mut test_state);
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the various trig functions when they should revert.
|
|
||||||
#[test]
|
|
||||||
fn state_trig() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.float = vec![Decimal::HALF_PI];
|
|
||||||
float_tan(&mut test_state);
|
|
||||||
assert_eq!(vec![Decimal::HALF_PI], test_state.float);
|
|
||||||
|
|
||||||
test_state.float = vec![Decimal::HALF_PI];
|
|
||||||
float_arccos(&mut test_state);
|
|
||||||
assert_eq!(vec![Decimal::HALF_PI], test_state.float);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(3.4), Decimal::PI];
|
|
||||||
float_arcsin(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(3.4), Decimal::PI], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the int and float casting functions
|
|
||||||
#[test]
|
|
||||||
fn state_cast() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![0, 1];
|
|
||||||
float_from_int(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(1.0)], test_state.float);
|
|
||||||
test_state.int.clear();
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(2.1)];
|
|
||||||
int_from_float(&mut test_state);
|
|
||||||
assert_eq!(vec![2], test_state.int);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the log function
|
|
||||||
#[test]
|
|
||||||
fn state_log() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![1];
|
|
||||||
int_log(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
test_state.int.clear();
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(2)];
|
|
||||||
float_log(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(0.3010299956639811952137388949)], test_state.float);
|
|
||||||
test_state.float.clear();
|
|
||||||
|
|
||||||
test_state.int = vec![6, 7, 0];
|
|
||||||
int_log(&mut test_state);
|
|
||||||
assert_eq!(vec![6, 7, 0], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(-4.5)];
|
|
||||||
float_log(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(0.6532125137753436793763169119)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the exp function
|
|
||||||
#[test]
|
|
||||||
fn state_exp() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
int_exp(&mut test_state);
|
|
||||||
assert_eq!(vec![1], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![0, 2];
|
|
||||||
int_exp(&mut test_state);
|
|
||||||
assert_eq!(vec![0, 7], test_state.int);
|
|
||||||
|
|
||||||
test_state.int.clear();
|
|
||||||
test_state.float = vec![dec!(1.2)];
|
|
||||||
float_exp(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(3.3201169022444051948051948052)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the sqrt function
|
|
||||||
#[test]
|
|
||||||
fn state_sqrt() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![4];
|
|
||||||
int_sqrt(&mut test_state);
|
|
||||||
assert_eq!(vec![2], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![5];
|
|
||||||
int_sqrt(&mut test_state);
|
|
||||||
assert_eq!(vec![2], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(4.84)];
|
|
||||||
float_sqrt(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(2.2)], test_state.float);
|
|
||||||
|
|
||||||
test_state.int = vec![-1];
|
|
||||||
int_sqrt(&mut test_state);
|
|
||||||
assert_eq!(vec![1], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(-1.0)];
|
|
||||||
float_sqrt(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(1.0)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the inv function
|
|
||||||
#[test]
|
|
||||||
fn state_inv() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![-1, 10];
|
|
||||||
int_inv(&mut test_state);
|
|
||||||
assert_eq!(vec![-1, 0], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(-10)];
|
|
||||||
float_inv(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(-0.1)], test_state.float);
|
|
||||||
|
|
||||||
test_state.int = vec![0];
|
|
||||||
int_inv(&mut test_state);
|
|
||||||
assert_eq!(vec![0], test_state.int);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the abs function
|
|
||||||
#[test]
|
|
||||||
fn state_abs() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![-1];
|
|
||||||
int_abs(&mut test_state);
|
|
||||||
assert_eq!(vec![1], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(-2.7)];
|
|
||||||
float_abs(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(2.7)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the sign reverse function
|
|
||||||
#[test]
|
|
||||||
fn state_sign_reverse() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![-2];
|
|
||||||
int_sign_reverse(&mut test_state);
|
|
||||||
assert_eq!(vec![2], test_state.int);
|
|
||||||
|
|
||||||
test_state.int = vec![3];
|
|
||||||
int_sign_reverse(&mut test_state);
|
|
||||||
assert_eq!(vec![-3], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(3.0), dec!(-2.0)];
|
|
||||||
float_sign_reverse(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(3.0), dec!(2.0)], test_state.float);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(3.0)];
|
|
||||||
float_sign_reverse(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(-3.0)], test_state.float);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Tests the square function
|
|
||||||
#[test]
|
|
||||||
fn state_square() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
test_state.int = vec![2, 3];
|
|
||||||
int_square(&mut test_state);
|
|
||||||
assert_eq!(vec![2, 9], test_state.int);
|
|
||||||
|
|
||||||
test_state.float = vec![dec!(-4.0)];
|
|
||||||
float_square(&mut test_state);
|
|
||||||
assert_eq!(vec![dec!(16.0)], test_state.float);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,191 +0,0 @@
|
|||||||
use rust_decimal::Decimal;
|
|
||||||
use rust_decimal::prelude::*;
|
|
||||||
use std::ops::Div;
|
|
||||||
|
|
||||||
/// This trait houses various methods for making instructions
|
|
||||||
/// more generic instead of declaring a separate function for each
|
|
||||||
/// stack. In a way I'm doing that here, but in a more Rusty way.
|
|
||||||
///
|
|
||||||
/// Trig functions named safe rather than checked to not overlap
|
|
||||||
/// with Decimal library's checked function names.
|
|
||||||
pub trait NumericTrait: Sized + Div<Output = Self> {
|
|
||||||
fn checked_div(self, v: Self) -> Option<Self>;
|
|
||||||
fn checked_mod(self, v: Self) -> Option<Self>;
|
|
||||||
fn increment(self) -> Self;
|
|
||||||
fn decrement(self) -> Self;
|
|
||||||
fn safe_sin(self) -> Option<Self>;
|
|
||||||
fn safe_cos(self) -> Option<Self>;
|
|
||||||
fn safe_tan(self) -> Option<Self>;
|
|
||||||
fn inverse(self) -> Option<Self>;
|
|
||||||
fn safe_exp(self) -> Option<Self>;
|
|
||||||
fn absolute(self) -> Self;
|
|
||||||
fn safe_log10(self) -> Option<Self>;
|
|
||||||
fn safe_sqrt(self) -> Option<Self>;
|
|
||||||
fn sign_reverse(self) -> Self;
|
|
||||||
fn square(self) -> Self;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl NumericTrait for Decimal {
|
|
||||||
fn checked_div(self, v: Self) -> Option<Self> {
|
|
||||||
if v == dec!(0.0) { None } else { Some(self / v) }
|
|
||||||
}
|
|
||||||
fn checked_mod(self, v: Self) -> Option<Self> {
|
|
||||||
if v == dec!(0.0) { None } else { Some(self % v) }
|
|
||||||
}
|
|
||||||
fn increment(self) -> Self {
|
|
||||||
self + dec!(1.0)
|
|
||||||
}
|
|
||||||
fn decrement(self) -> Self {
|
|
||||||
self - dec!(1.0)
|
|
||||||
}
|
|
||||||
fn safe_sin(self) -> Option<Self> {
|
|
||||||
self.checked_sin()
|
|
||||||
}
|
|
||||||
fn safe_cos(self) -> Option<Self> {
|
|
||||||
self.checked_cos()
|
|
||||||
}
|
|
||||||
fn safe_tan(self) -> Option<Self> {
|
|
||||||
self.checked_tan()
|
|
||||||
}
|
|
||||||
fn inverse(self) -> Option<Self> {
|
|
||||||
dec!(1.0).checked_div(self)
|
|
||||||
}
|
|
||||||
fn safe_exp(self) -> Option<Self> {
|
|
||||||
self.checked_exp()
|
|
||||||
}
|
|
||||||
fn absolute(self) -> Self {
|
|
||||||
self.abs()
|
|
||||||
}
|
|
||||||
fn safe_log10(self) -> Option<Self> {
|
|
||||||
self.absolute().checked_log10()
|
|
||||||
}
|
|
||||||
fn safe_sqrt(self) -> Option<Self> {
|
|
||||||
self.absolute().sqrt()
|
|
||||||
}
|
|
||||||
fn sign_reverse(self) -> Self {
|
|
||||||
self * dec!(-1)
|
|
||||||
}
|
|
||||||
fn square(self) -> Self {
|
|
||||||
self * self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl NumericTrait for i128 {
|
|
||||||
fn checked_div(self, v: Self) -> Option<Self> {
|
|
||||||
if v == 0 { None } else { Some(self / v) }
|
|
||||||
}
|
|
||||||
fn checked_mod(self, v: Self) -> Option<Self> {
|
|
||||||
if v == 0 { None } else { Some(self % v) }
|
|
||||||
}
|
|
||||||
fn increment(self) -> Self {
|
|
||||||
self + 1
|
|
||||||
}
|
|
||||||
fn decrement(self) -> Self {
|
|
||||||
self - 1
|
|
||||||
}
|
|
||||||
/// Casts the i128 to a Decimal and takes the checked_sin
|
|
||||||
/// of the value. Casts the calculated value back to an i128.
|
|
||||||
fn safe_sin(self) -> Option<Self> {
|
|
||||||
Decimal::from_i128(self)?.checked_sin()?.to_i128()
|
|
||||||
}
|
|
||||||
fn safe_cos(self) -> Option<Self> {
|
|
||||||
Decimal::from_i128(self)?.checked_cos()?.to_i128()
|
|
||||||
}
|
|
||||||
fn safe_tan(self) -> Option<Self> {
|
|
||||||
Decimal::from_i128(self)?.checked_tan()?.to_i128()
|
|
||||||
}
|
|
||||||
fn inverse(self) -> Option<Self> {
|
|
||||||
if self == 0 { None } else { Some(1 / self) }
|
|
||||||
}
|
|
||||||
fn safe_exp(self) -> Option<Self> {
|
|
||||||
Decimal::from_i128(self)?.checked_exp()?.to_i128()
|
|
||||||
}
|
|
||||||
fn absolute(self) -> Self {
|
|
||||||
self.abs()
|
|
||||||
}
|
|
||||||
fn safe_log10(self) -> Option<Self> {
|
|
||||||
Decimal::from_i128(self)?
|
|
||||||
.absolute()
|
|
||||||
.checked_log10()?
|
|
||||||
.to_i128()
|
|
||||||
}
|
|
||||||
fn safe_sqrt(self) -> Option<Self> {
|
|
||||||
Decimal::from_i128(self)?.absolute().sqrt()?.to_i128()
|
|
||||||
}
|
|
||||||
fn sign_reverse(self) -> Self {
|
|
||||||
-1 * self
|
|
||||||
}
|
|
||||||
fn square(self) -> Self {
|
|
||||||
self * self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A trait for types to implement logical functions that work
|
|
||||||
/// for push types.
|
|
||||||
pub trait LogicalTrait {
|
|
||||||
fn logical_and(self, v: Self) -> Self;
|
|
||||||
fn logical_or(self, v: Self) -> Self;
|
|
||||||
fn logical_not(self) -> Self;
|
|
||||||
fn logical_xor(self, v: Self) -> Self;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl LogicalTrait for bool {
|
|
||||||
fn logical_and(self, v: Self) -> Self {
|
|
||||||
self && v
|
|
||||||
}
|
|
||||||
fn logical_or(self, v: Self) -> Self {
|
|
||||||
self || v
|
|
||||||
}
|
|
||||||
fn logical_not(self) -> Self {
|
|
||||||
!self
|
|
||||||
}
|
|
||||||
fn logical_xor(self, v: Self) -> Self {
|
|
||||||
match (self, v) {
|
|
||||||
(true, true) | (false, false) => false,
|
|
||||||
_ => true,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A trait for uniform conversions between types.
|
|
||||||
pub trait CastingTrait: Sized {
|
|
||||||
fn from_bool(v: bool) -> Option<Self>;
|
|
||||||
fn from_int(v: i128) -> Option<Self>;
|
|
||||||
fn from_float(v: Decimal) -> Option<Self>;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CastingTrait for i128 {
|
|
||||||
fn from_bool(v: bool) -> Option<Self> {
|
|
||||||
Some(if v { 1 } else { 0 })
|
|
||||||
}
|
|
||||||
fn from_int(v: i128) -> Option<Self> {
|
|
||||||
Some(v)
|
|
||||||
}
|
|
||||||
fn from_float(v: Decimal) -> Option<Self> {
|
|
||||||
v.to_i128()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CastingTrait for Decimal {
|
|
||||||
fn from_bool(v: bool) -> Option<Self> {
|
|
||||||
Some(if v { dec!(1.0) } else { dec!(0.0) })
|
|
||||||
}
|
|
||||||
fn from_int(v: i128) -> Option<Self> {
|
|
||||||
Decimal::from_i128(v)
|
|
||||||
}
|
|
||||||
fn from_float(v: Decimal) -> Option<Self> {
|
|
||||||
Some(v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CastingTrait for bool {
|
|
||||||
fn from_bool(v: bool) -> Option<Self> {
|
|
||||||
Some(v)
|
|
||||||
}
|
|
||||||
fn from_int(v: i128) -> Option<Self> {
|
|
||||||
Some(if v != 0 { true } else { false })
|
|
||||||
}
|
|
||||||
fn from_float(v: Decimal) -> Option<Self> {
|
|
||||||
Some(if v != dec!(0.0) { true } else { false })
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1 +0,0 @@
|
|||||||
|
|
||||||
36
src/main.rs
36
src/main.rs
@ -1,36 +0,0 @@
|
|||||||
use instructions::utils::NumericTrait;
|
|
||||||
use rust_decimal::MathematicalOps;
|
|
||||||
use rust_decimal::prelude::*;
|
|
||||||
|
|
||||||
mod instructions;
|
|
||||||
mod push;
|
|
||||||
|
|
||||||
fn test_func() {}
|
|
||||||
fn another_test_func() {}
|
|
||||||
|
|
||||||
fn main() {
|
|
||||||
// let sixth_pi = Decimal::PI / dec!(6.0);
|
|
||||||
// let result = dec!(1).sin();
|
|
||||||
// let result = Decimal::PI.sin().checked_div(Decimal::PI.cos());
|
|
||||||
// let result = dec!(1.0) / Decimal::HALF_PI.sin();
|
|
||||||
// let result = sixth_pi.sin();
|
|
||||||
// let result = Decimal::HALF_PI.cos();
|
|
||||||
// let result = Decimal::PI.sin();
|
|
||||||
// let result = Decimal::PI.tan();
|
|
||||||
// let result = dec!(1.0) / Decimal::QUARTER_PI.tan();
|
|
||||||
// let result = dec!(1.0) / Decimal::QUARTER_PI.cos();
|
|
||||||
// let result = dec!(1.2).checked_exp();
|
|
||||||
// let result = dec!(2).log10();
|
|
||||||
let result = vec![0, 1, 2];
|
|
||||||
let r_len = result.len();
|
|
||||||
let fin_result = &result[..r_len - 1];
|
|
||||||
println!("{fin_result:?}");
|
|
||||||
|
|
||||||
// println!("{result:?}");
|
|
||||||
// println!("{sixth_pi}");
|
|
||||||
|
|
||||||
// casting a function call to a usize is a way to
|
|
||||||
// test for function equality.
|
|
||||||
// let test_func_result = test_func as usize == test_func as usize;
|
|
||||||
// println!("{test_func_result}");
|
|
||||||
}
|
|
||||||
@ -1,150 +0,0 @@
|
|||||||
use crate::push::state::*;
|
|
||||||
|
|
||||||
/// The main function that disperses the exec stack Genes into
|
|
||||||
/// the respective stacks. Also is where the individual instructions
|
|
||||||
/// (such as int_add) is ran.
|
|
||||||
pub fn gene_to_stack(state: &mut PushState, gene: Gene) {
|
|
||||||
match gene {
|
|
||||||
Gene::GeneInt(x) => state.int.push(x),
|
|
||||||
Gene::GeneFloat(x) => state.float.push(x),
|
|
||||||
Gene::GeneBoolean(x) => state.boolean.push(x),
|
|
||||||
Gene::GeneString(x) => state.string.push(x),
|
|
||||||
Gene::GeneChar(x) => state.char.push(x),
|
|
||||||
Gene::GeneVectorInt(x) => state.vector_int.push(x),
|
|
||||||
Gene::GeneVectorFloat(x) => state.vector_float.push(x),
|
|
||||||
Gene::GeneVectorBoolean(x) => state.vector_boolean.push(x),
|
|
||||||
Gene::GeneVectorString(x) => state.vector_string.push(x),
|
|
||||||
Gene::GeneVectorChar(x) => state.vector_char.push(x),
|
|
||||||
Gene::StateFunc(func) => func(state),
|
|
||||||
Gene::Block(x) => state.exec.extend(x.into_iter()),
|
|
||||||
Gene::Close => panic!("Close found in the exec stack, this should not happen!"),
|
|
||||||
Gene::Open(_) => panic!("Open found in the exec stack, this should not happen!"),
|
|
||||||
Gene::Skip => panic!("Skip found in the exec stack, this should not happen!"),
|
|
||||||
Gene::CrossoverPadding => {
|
|
||||||
panic!("CrossoverPadding found in the exec stack, this should not happen!")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Where a push program's exec stack is interpreted to completion.
|
|
||||||
/// TODO: Decide where to place loading in a push program.
|
|
||||||
pub fn interpret_program(state: &mut PushState, step_limit: usize, max_stack_size: isize) {
|
|
||||||
let mut steps: usize = 0;
|
|
||||||
while state.exec.len() > 0 && steps < step_limit {
|
|
||||||
if let Some(gene) = state.exec.pop() {
|
|
||||||
gene_to_stack(state, gene);
|
|
||||||
steps += 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use crate::instructions::numeric::int_add;
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
use rust_decimal::dec;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn gene_to_stack_test() {
|
|
||||||
let mut test_state = EMPTY_STATE;
|
|
||||||
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneInt(1));
|
|
||||||
assert_eq!(vec![1], test_state.int);
|
|
||||||
test_state.int.clear();
|
|
||||||
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneFloat(dec!(1.2)));
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneFloat(dec!(2.4)));
|
|
||||||
assert_eq!(vec![dec!(1.2), dec!(2.4)], test_state.float);
|
|
||||||
test_state.float.clear();
|
|
||||||
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneBoolean(true));
|
|
||||||
assert_eq!(vec![true], test_state.boolean);
|
|
||||||
test_state.boolean.clear();
|
|
||||||
|
|
||||||
gene_to_stack(
|
|
||||||
&mut test_state,
|
|
||||||
Gene::GeneString("test".as_bytes().to_vec()),
|
|
||||||
);
|
|
||||||
assert_eq!(vec!["test".as_bytes().to_vec()], test_state.string);
|
|
||||||
test_state.string.clear();
|
|
||||||
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneChar('a'));
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneChar('b'));
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneChar('c'));
|
|
||||||
assert_eq!(vec!['a', 'b', 'c'], test_state.char);
|
|
||||||
test_state.char.clear();
|
|
||||||
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneVectorInt(vec![1, 2, 3]));
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneVectorInt(vec![4, 5, 6]));
|
|
||||||
assert_eq!(vec![vec![1, 2, 3], vec![4, 5, 6]], test_state.vector_int);
|
|
||||||
test_state.vector_int.clear();
|
|
||||||
|
|
||||||
gene_to_stack(
|
|
||||||
&mut test_state,
|
|
||||||
Gene::GeneVectorFloat(vec![dec!(1.7), dec!(2.4), dec!(3.9)]),
|
|
||||||
);
|
|
||||||
gene_to_stack(
|
|
||||||
&mut test_state,
|
|
||||||
Gene::GeneVectorFloat(vec![dec!(4.7), dec!(5.4), dec!(6.9)]),
|
|
||||||
);
|
|
||||||
assert_eq!(
|
|
||||||
vec![
|
|
||||||
vec![dec!(1.7), dec!(2.4), dec!(3.9)],
|
|
||||||
vec![dec!(4.7), dec!(5.4), dec!(6.9)]
|
|
||||||
],
|
|
||||||
test_state.vector_float
|
|
||||||
);
|
|
||||||
test_state.vector_float.clear();
|
|
||||||
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneVectorBoolean(vec![true, false]));
|
|
||||||
assert_eq!(vec![vec![true, false]], test_state.vector_boolean);
|
|
||||||
test_state.vector_boolean.clear();
|
|
||||||
|
|
||||||
gene_to_stack(
|
|
||||||
&mut test_state,
|
|
||||||
Gene::GeneVectorString(vec!["test0".as_bytes().to_vec()]),
|
|
||||||
);
|
|
||||||
gene_to_stack(
|
|
||||||
&mut test_state,
|
|
||||||
Gene::GeneVectorString(vec![
|
|
||||||
"test1".as_bytes().to_vec(),
|
|
||||||
"test2".as_bytes().to_vec(),
|
|
||||||
]),
|
|
||||||
);
|
|
||||||
assert_eq!(
|
|
||||||
vec![
|
|
||||||
vec!["test0".as_bytes().to_vec()],
|
|
||||||
vec!["test1".as_bytes().to_vec(), "test2".as_bytes().to_vec()]
|
|
||||||
],
|
|
||||||
test_state.vector_string
|
|
||||||
);
|
|
||||||
test_state.vector_string.clear();
|
|
||||||
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneVectorChar(vec!['a', 'b']));
|
|
||||||
gene_to_stack(&mut test_state, Gene::GeneVectorChar(vec!['b', 'c', 'd']));
|
|
||||||
assert_eq!(
|
|
||||||
vec![vec!['a', 'b'], vec!['b', 'c', 'd']],
|
|
||||||
test_state.vector_char
|
|
||||||
);
|
|
||||||
test_state.vector_char.clear();
|
|
||||||
|
|
||||||
let test_block: Gene = Gene::Block(Box::new(vec![
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(2.3)),
|
|
||||||
Gene::StateFunc(int_add),
|
|
||||||
]));
|
|
||||||
test_state.exec.push(Gene::GeneInt(2));
|
|
||||||
gene_to_stack(&mut test_state, test_block);
|
|
||||||
assert_eq!(
|
|
||||||
vec![
|
|
||||||
Gene::GeneInt(2),
|
|
||||||
Gene::GeneInt(1),
|
|
||||||
Gene::GeneFloat(dec!(2.3)),
|
|
||||||
Gene::StateFunc(int_add)
|
|
||||||
],
|
|
||||||
test_state.exec
|
|
||||||
);
|
|
||||||
// println!("{:?}", test_state.exec);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,2 +0,0 @@
|
|||||||
pub mod interpreter;
|
|
||||||
pub mod state;
|
|
||||||
@ -1,56 +0,0 @@
|
|||||||
use rust_decimal::prelude::*;
|
|
||||||
|
|
||||||
/// The declaration of the state that push operates on.
|
|
||||||
///
|
|
||||||
/// I chose to use `rust_decimal` crate here because
|
|
||||||
/// there are round off errors with the build in `f64`.
|
|
||||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
||||||
pub struct PushState {
|
|
||||||
pub int: Vec<i128>,
|
|
||||||
pub float: Vec<Decimal>,
|
|
||||||
pub string: Vec<Vec<u8>>,
|
|
||||||
pub boolean: Vec<bool>,
|
|
||||||
pub char: Vec<char>,
|
|
||||||
pub vector_int: Vec<Vec<i128>>,
|
|
||||||
pub vector_float: Vec<Vec<Decimal>>,
|
|
||||||
pub vector_string: Vec<Vec<Vec<u8>>>,
|
|
||||||
pub vector_boolean: Vec<Vec<bool>>,
|
|
||||||
pub vector_char: Vec<Vec<char>>,
|
|
||||||
pub exec: Vec<Gene>,
|
|
||||||
pub code: Vec<Gene>,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub const EMPTY_STATE: PushState = PushState {
|
|
||||||
int: vec![],
|
|
||||||
float: vec![],
|
|
||||||
string: vec![],
|
|
||||||
boolean: vec![],
|
|
||||||
char: vec![],
|
|
||||||
vector_int: vec![],
|
|
||||||
vector_float: vec![],
|
|
||||||
vector_string: vec![],
|
|
||||||
vector_boolean: vec![],
|
|
||||||
vector_char: vec![],
|
|
||||||
exec: vec![],
|
|
||||||
code: vec![],
|
|
||||||
};
|
|
||||||
|
|
||||||
#[derive(PartialEq, Eq, Debug, Clone)]
|
|
||||||
pub enum Gene {
|
|
||||||
GeneInt(i128),
|
|
||||||
GeneFloat(Decimal),
|
|
||||||
GeneBoolean(bool),
|
|
||||||
GeneString(Vec<u8>),
|
|
||||||
GeneChar(char),
|
|
||||||
GeneVectorInt(Vec<i128>),
|
|
||||||
GeneVectorFloat(Vec<Decimal>),
|
|
||||||
GeneVectorBoolean(Vec<bool>),
|
|
||||||
GeneVectorString(Vec<Vec<u8>>),
|
|
||||||
GeneVectorChar(Vec<char>),
|
|
||||||
StateFunc(fn(&mut PushState)),
|
|
||||||
Close,
|
|
||||||
Open(u8),
|
|
||||||
Skip,
|
|
||||||
Block(Box<Vec<Gene>>),
|
|
||||||
CrossoverPadding,
|
|
||||||
}
|
|
||||||
Loading…
x
Reference in New Issue
Block a user