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

use crate as cm;
use cm::number;

pub mod basic;

enum Operation {
	Addition,
	Soustraction,
	Multiplication,
	Division,
}


pub trait Equation {
	fn make_addition(&mut self) -> f64;
	fn make_soustraction(&mut self) -> f64;
	fn make_multiplication(&mut self) -> f64;
	fn make_division(&mut self) -> f64;
	fn print(&self) -> Result<String, &str>;
	fn result(&self) -> Option<f64>;
}

//2 factors equation base
pub struct TwoFactor {
	pub x: f64,
	pub y: f64,
	result: Option<f64>,
	operation: Option<Operation>,
}

impl TwoFactor {
	pub fn new(random_buffer: &[i32; 100]) -> TwoFactor {
		let x_random_index = random_number::random_ranged(0..random_buffer.len());
		let y_random_index = random_number::random_ranged(0..random_buffer.len());

		TwoFactor {
			x: f64::from(*random_buffer.get(x_random_index).unwrap()),
			y: f64::from(*random_buffer.get(y_random_index).unwrap()),
			result: None,
			operation: None,
		}
	}

	//todo
	// fn add_factor(self, random_buffer: &mut [i32; 100]) -> ThreeFactor {
	// 	ThreeFactor {
	// 		x: self.x,
	// 		y: self.y,
	// 		z: f64::from(*random_buffer.get(cm::number::r_index()).unwrap()),
	// 		result: 0.0,
	// 	}
	// }
}

impl Equation for TwoFactor {

	fn make_addition(&mut self) -> f64 {
		let result = self.x + self.y;
		self.operation = Some(Operation::Addition);
		self.result = Some(result);

		result
	}

	fn make_soustraction(&mut self) -> f64 {
		let result = self.x - self.y;
		self.operation = Some(Operation::Soustraction);
		self.result = Some(result);

		result
	}

	fn make_multiplication(&mut self) -> f64 {
		let result = self.x * self.y;
		self.operation = Some(Operation::Multiplication);
		self.result = Some(result);

		result
	}

	fn make_division(&mut self) -> f64 {
		let result = number::change_float_part(self.x / self.y, 3);
		self.operation = Some(Operation::Division);
		self.result = Some(result);

		result
	}

	fn print(&self) -> Result<String, &str> {
		let operation = match &self.operation {
			Some(operation) => match operation {
				Operation::Addition => "+",
				Operation::Soustraction => "-",
				Operation::Multiplication => "*",
				Operation::Division => "/",
			}
			None => return Err("There is no operation on this equation"),
		};

		let expression = format!("{} {} {}", self.x, operation, self.y);

		Ok(expression)
	}

	fn result(&self) -> Option<f64> {
		self.result
	}
}


pub struct SimpleTwoFactor {
	pub x: f64,
	pub y: f64,
}

impl SimpleTwoFactor {
	pub fn new(x: f64, y: f64) -> SimpleTwoFactor {
		SimpleTwoFactor {
			x,
			y,
		}
	}
}


//todo 
pub struct _ThreeFactor { }