Missing arithmetic operators

crates/datex-core/src/runtime/execution/execution_loop/operations.rs

@@ -161,12 +161,12 @@ pub fn handle_arithmetic_operation(
     match operator {
         ArithmeticOperator::Add => Ok((lhs + rhs)?),
         ArithmeticOperator::Subtract => Ok((lhs - rhs)?),
-        // ArithmeticOperator::Multiply => {
-        //     Ok((active_value_container * &value_container)?)
-        // }
-        // ArithmeticOperator::Divide => {
-        //     Ok((active_value_container / &value_container)?)
-        // }
+        ArithmeticOperator::Multiply => {
+            Ok((lhs * rhs)?)
+        }
+        ArithmeticOperator::Divide => {
+            Ok((lhs / rhs)?)
+        }
         _ => {
             core::todo!(
                 "#408 Implement arithmetic operation for {:?}",

crates/datex-core/src/values/core_values/decimal/mod.rs

@@ -19,7 +19,7 @@ use core::{
     cmp::Ordering,
     fmt::Display,
     hash::Hash,
-    ops::{Add, Neg, Sub},
+    ops::{Add, Neg, Sub, Mul, Div},
     str::FromStr,
 };
 use num::{BigInt, BigRational};
@@ -28,7 +28,7 @@ use num_traits::{FromPrimitive, Zero};
 use rational::Rational;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Eq, Serialize, Deserialize, PartialOrd)]
 pub enum Decimal {
     Finite(Rational),
     Nan,
@@ -69,6 +69,20 @@ impl PartialEq for Decimal {
 impl Decimal {
     /// Attempts to convert the Decimal to an f32.
     /// If an overflow occurs, returns infinity or -infinity.
+    pub fn as_f64(&self) -> f64 {
+        match self {
+            Decimal::Finite(rational) => {
+                // Convert Rational to f64
+                rational.to_f64()
+            }
+            Decimal::Zero => 0.0,
+            Decimal::NegZero => -0.0,
+            Decimal::Infinity => f64::INFINITY,
+            Decimal::NegInfinity => f64::NEG_INFINITY,
+            Decimal::Nan => f64::NAN,
+        }
+    }
+
     pub fn into_f32(&self) -> f32 {
         match self {
             Decimal::Finite(value) => value.to_f32(),
@@ -136,9 +150,13 @@ impl Decimal {
         core::matches!(self, Decimal::Nan)
     }
 
-    /// Returns true if the value is zero (positive or negative).
+    /// Returns true if the value is zero (positive or negative)
     pub fn is_zero(&self) -> bool {
-        core::matches!(self, Decimal::Zero | Decimal::NegZero)
+        match self {
+            Decimal::Zero | Decimal::NegZero => true,
+            Decimal::Finite(rational) => rational.is_zero(), // Check if rational is zero
+            _ => false,
+        }
     }
 
     /// Returns true if the value has a positive sign.
@@ -314,6 +332,89 @@ impl Sub for &Decimal {
     }
 }
 
+impl Mul for Decimal {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (Decimal::Finite(a), Decimal::Finite(b)) => Decimal::from(a * b),
+            (Decimal::NegZero, Decimal::Zero)
+            | (Decimal::Zero, Decimal::NegZero) => Decimal::Zero,
+            (Decimal::Zero, b) | (b, Decimal::Zero) => b,
+            (Decimal::NegZero, b) | (b, Decimal::NegZero) => b,
+            (Decimal::Infinity, Decimal::NegInfinity)
+            | (Decimal::NegInfinity, Decimal::Infinity) => Decimal::Nan,
+            (Decimal::Infinity, _) | (_, Decimal::Infinity) => {
+                Decimal::Infinity
+            }
+            (Decimal::NegInfinity, _) | (_, Decimal::NegInfinity) => {
+                Decimal::NegInfinity
+            }
+            (Decimal::Nan, _) | (_, Decimal::Nan) => Decimal::Nan,
+        }
+    }
+}
+
+impl Mul for &Decimal {
+    type Output = Decimal;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        // FIXME #334: Avoid cloning, as add should be applicable for refs only
+        Decimal::add(self.clone(), rhs.clone())
+    }
+}
+
+impl Div for Decimal {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            // Division by zero is invalid, so we will return NaN
+            (_, Decimal::Zero) | (_, Decimal::NegZero) => Decimal::Nan,
+
+            // Zero divided by anything (except zero) is zero
+            (Decimal::Zero, _) => Decimal::Zero,
+            (Decimal::NegZero, _) => Decimal::NegZero,
+
+            // Finite division
+            (Decimal::Finite(a), Decimal::Finite(b)) => Decimal::from(a / b),
+
+            // Infinity / Infinity = NaN
+            (Decimal::Infinity, Decimal::Infinity) 
+            | (Decimal::NegInfinity, Decimal::NegInfinity) 
+            | (Decimal::Infinity, Decimal::NegInfinity) 
+            | (Decimal::NegInfinity, Decimal::Infinity) => Decimal::Nan,
+
+            // Finite / Infinity = 0 (with sign)
+            (Decimal::Finite(_), Decimal::Infinity) => Decimal::Zero,
+            (Decimal::Finite(_), Decimal::NegInfinity) => Decimal::NegZero,
+            (Decimal::NegZero, Decimal::Infinity) => Decimal::NegZero,
+
+            // Infinity / Finite = Infinity (preserve sign)
+            (Decimal::Infinity, Decimal::Finite(_)) => Decimal::Infinity,
+            (Decimal::NegInfinity, Decimal::Finite(_)) => Decimal::NegInfinity,
+
+            // Infinity / Zero = Infinity
+            (Decimal::Infinity, Decimal::Zero) => Decimal::Infinity,
+            (Decimal::NegInfinity, Decimal::Zero) => Decimal::NegInfinity,
+            (Decimal::Infinity, Decimal::NegZero) => Decimal::NegInfinity,
+            (Decimal::NegInfinity, Decimal::NegZero) => Decimal::Infinity,
+
+            // Anything with NaN results in NaN
+            (Decimal::Nan, _) | (_, Decimal::Nan) => Decimal::Nan,
+        }
+    }
+}
+
+impl Div for &Decimal {
+    type Output = Decimal;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        // FIXME #334: Avoid cloning, as add should be applicable for refs only
+        Decimal::add(self.clone(), rhs.clone())
+    }
+}
+
 impl Display for Decimal {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {

crates/datex-core/src/values/core_values/decimal/rational.rs

@@ -2,16 +2,17 @@ use crate::prelude::*;
 
 use core::{
     fmt::Display,
-    ops::{Add, Neg},
+    ops::{Add, Neg, Div, Mul, Sub},
     result::Result,
 };
 use num::BigRational;
 use num_bigint::BigInt;
 use num_integer::Integer;
 use num_traits::{Signed, ToPrimitive, Zero};
 use serde::{Deserialize, Serialize};
+use serde_with::chrono::SubsecRound;
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct Rational {
     big_rational: BigRational,
 }
@@ -228,6 +229,31 @@ impl Add for Rational {
     }
 }
 
+impl Sub for Rational {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Rational::from_big_rational(self.big_rational - rhs.big_rational)
+    }
+}
+
+
+impl Mul for Rational {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        Rational::from_big_rational(self.big_rational * rhs.big_rational)
+    }
+}
+
+impl Div for Rational {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        Rational::from_big_rational(self.big_rational / rhs.big_rational)
+    }
+}
+
 impl Display for Rational {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         core::write!(f, "{}", self.rational_to_string())