Merge branch 'feature/lex-instruction' into develop

Author: neoneye

rust_project/loda-rust-core/src/execute/node_calc.rs

@@ -39,32 +39,33 @@ impl NodeCalc {
 
     fn calc_with_semantics<S: Semantics>(&self, target: &BigInt, source: &BigInt) -> Result<BigInt, EvalError> {
         match self.instruction_id {
-            InstructionId::Move           => Ok(source.clone()),
-            InstructionId::Add            => S::add(target, source),
-            InstructionId::Subtract       => S::subtract(target, source),
-            InstructionId::Truncate       => S::truncate(target, source),
-            InstructionId::Multiply       => S::multiply(target, source),
-            InstructionId::Divide         => S::divide(target, source),
-            InstructionId::DivideIf       => S::divide_if(target, source),
-            InstructionId::DivideIfRepeat => S::divide_if_repeat(target, source),
-            InstructionId::Modulo         => S::modulo(target, source),
-            InstructionId::Power          => S::power(target, source),
-            InstructionId::GCD            => S::gcd(target, source),
-            InstructionId::Binomial       => S::binomial(target, source),
-            InstructionId::Compare        => S::compare(target, source),
-            InstructionId::Min            => S::min(target, source),
-            InstructionId::Max            => S::max(target, source),
-            InstructionId::Logarithm      => S::logarithm(target, source),
-            InstructionId::NthRoot        => S::nthroot(target, source),
-            InstructionId::DigitSum       => S::digitsum(target, source),
-            InstructionId::DigitalRoot    => S::digitalroot(target, source),
-            InstructionId::Equal          => S::equal(target, source),
-            InstructionId::NotEqual       => S::notequal(target, source),
-            InstructionId::LessOrEqual    => S::lessorequal(target, source),
-            InstructionId::GreaterOrEqual => S::greaterorequal(target, source),
-            InstructionId::BitwiseAnd     => S::bitwiseand(target, source),
-            InstructionId::BitwiseOr      => S::bitwiseor(target, source),
-            InstructionId::BitwiseXor     => S::bitwisexor(target, source),
+            InstructionId::Move            => Ok(source.clone()),
+            InstructionId::Add             => S::add(target, source),
+            InstructionId::Subtract        => S::subtract(target, source),
+            InstructionId::Truncate        => S::truncate(target, source),
+            InstructionId::Multiply        => S::multiply(target, source),
+            InstructionId::Divide          => S::divide(target, source),
+            InstructionId::DivideIf        => S::divide_if(target, source),
+            InstructionId::DivideIfRepeat  => S::divide_if_repeat(target, source),
+            InstructionId::Modulo          => S::modulo(target, source),
+            InstructionId::Power           => S::power(target, source),
+            InstructionId::GCD             => S::gcd(target, source),
+            InstructionId::Binomial        => S::binomial(target, source),
+            InstructionId::Compare         => S::compare(target, source),
+            InstructionId::Min             => S::min(target, source),
+            InstructionId::Max             => S::max(target, source),
+            InstructionId::Logarithm       => S::logarithm(target, source),
+            InstructionId::NthRoot         => S::nthroot(target, source),
+            InstructionId::DigitSum        => S::digitsum(target, source),
+            InstructionId::DigitalRoot     => S::digitalroot(target, source),
+            InstructionId::Equal           => S::equal(target, source),
+            InstructionId::NotEqual        => S::notequal(target, source),
+            InstructionId::LessOrEqual     => S::lessorequal(target, source),
+            InstructionId::GreaterOrEqual  => S::greaterorequal(target, source),
+            InstructionId::BitwiseAnd      => S::bitwiseand(target, source),
+            InstructionId::BitwiseOr       => S::bitwiseor(target, source),
+            InstructionId::BitwiseXor      => S::bitwisexor(target, source),
+            InstructionId::LargestExponent => S::largestexponent(target, source),
             _ => {
                 error!("unsupported instruction: {:?}", self.instruction_id);
                 return Err(EvalError::UnsupportedInstruction);

rust_project/loda-rust-core/src/execute/semantic_simple.rs

@@ -54,7 +54,7 @@ pub trait SemanticSimpleConfig {
                 return Err(SemanticSimpleError::InputOutOfRange);
             }
         }
-        let z: BigInt = x - y;
+        let z: BigInt = x - y.clone();
         if let Some(value_max_bits) = self.value_max_bits() {
             if z.bits() >= value_max_bits {
                 return Err(SemanticSimpleError::OutputOutOfRange);
@@ -376,6 +376,30 @@ pub trait SemanticSimpleConfig {
         Ok(result)
     }
 
+    fn compute_largestexponent(&self, x: &BigInt, y: &BigInt) -> Result<BigInt, SemanticSimpleError> {
+        if let Some(value_max_bits) = self.value_max_bits() {
+            if x.bits() >= value_max_bits || y.bits() >= value_max_bits {
+                return Err(SemanticSimpleError::InputOutOfRange);
+            }
+        }
+        if *y == BigInt::zero() || *y == BigInt::one() {
+            return Ok(BigInt::zero());
+        }
+
+        let mut xx: BigInt = x.abs();
+        let yy: BigInt = y.abs();
+        let mut r: BigInt = BigInt::zero();
+        loop {
+            let aaa: BigInt = self.compute_divide_if(&xx, &yy)?;
+            if aaa == xx {
+                break;
+            }
+            xx = aaa;
+            r += BigInt::one();
+        }
+        Ok(r)
+    }
+    
     fn compute_equal(&self, x: &BigInt, y: &BigInt) -> Result<BigInt, SemanticSimpleError> {
         if let Some(value_max_bits) = self.value_max_bits() {
             if x.bits() >= value_max_bits || y.bits() >= value_max_bits {
@@ -529,6 +553,7 @@ mod tests {
         BitwiseAnd,
         BitwiseOr,
         BitwiseXor,
+        LargestExponent,
     }
 
     fn compute(config: &dyn SemanticSimpleConfig, mode: ComputeMode, left: i64, right: i64) -> String {
@@ -568,6 +593,7 @@ mod tests {
             ComputeMode::BitwiseAnd     => config.compute_bitwiseand(&x, &y),
             ComputeMode::BitwiseOr      => config.compute_bitwiseor(&x, &y),
             ComputeMode::BitwiseXor     => config.compute_bitwisexor(&x, &y),
+            ComputeMode::LargestExponent => config.compute_largestexponent(&x, &y),
         };
         match result {
             Ok(value) => return value.to_string(),
@@ -1342,4 +1368,116 @@ mod tests {
         assert_eq!(compute_bitwisexor("-9223372036854775807", "-9223372036854775808"), "18446744073709551615");
         assert_eq!(compute_bitwisexor("3148244321913096809130", "1574122160956548404565"), "4722366482869645213695");
     }
+
+    fn compute_largestexponent(left: i64, right: i64) -> String {
+        let config = SemanticSimpleConfigLimited::new(32);
+        compute(&config, ComputeMode::LargestExponent, left, right)
+    }
+
+    #[test]
+    fn test_230000_largestexponent() {
+        assert_eq!(compute_largestexponent(-4, -5), "0");
+        assert_eq!(compute_largestexponent(-4, -4), "1");
+        assert_eq!(compute_largestexponent(-4, -3), "0");
+        assert_eq!(compute_largestexponent(-4, -2), "2");
+        assert_eq!(compute_largestexponent(-4, -1), "0");
+        assert_eq!(compute_largestexponent(-4, 0), "0");
+        assert_eq!(compute_largestexponent(-4, 1), "0");
+        assert_eq!(compute_largestexponent(-4, 2), "2");
+        assert_eq!(compute_largestexponent(-4, 3), "0");
+        assert_eq!(compute_largestexponent(-4, 4), "1");
+        assert_eq!(compute_largestexponent(-4, 5), "0");
+        assert_eq!(compute_largestexponent(-4, 6), "0");
+        assert_eq!(compute_largestexponent(-4, 7), "0");
+        assert_eq!(compute_largestexponent(-4, 8), "0");
+        assert_eq!(compute_largestexponent(0, -2), "0");
+        assert_eq!(compute_largestexponent(0, -1), "0");
+        assert_eq!(compute_largestexponent(0, 0), "0");
+        assert_eq!(compute_largestexponent(0, 1), "0");
+        assert_eq!(compute_largestexponent(0, 2), "0");
+        assert_eq!(compute_largestexponent(1, -1), "0");
+        assert_eq!(compute_largestexponent(1, -1), "0");
+        assert_eq!(compute_largestexponent(1, 0), "0");
+        assert_eq!(compute_largestexponent(1, 1), "0");
+        assert_eq!(compute_largestexponent(1, 2), "0");
+        assert_eq!(compute_largestexponent(2, -3), "0");
+        assert_eq!(compute_largestexponent(2, -2), "1");
+        assert_eq!(compute_largestexponent(2, -1), "0");
+        assert_eq!(compute_largestexponent(2, 0), "0");
+        assert_eq!(compute_largestexponent(2, 1), "0");
+        assert_eq!(compute_largestexponent(2, 2), "1");
+        assert_eq!(compute_largestexponent(2, 3), "0");
+        assert_eq!(compute_largestexponent(2, 4), "0");
+        assert_eq!(compute_largestexponent(4, -5), "0");
+        assert_eq!(compute_largestexponent(4, -4), "1");
+        assert_eq!(compute_largestexponent(4, -3), "0");
+        assert_eq!(compute_largestexponent(4, -2), "2");
+        assert_eq!(compute_largestexponent(4, -1), "0");
+        assert_eq!(compute_largestexponent(4, 0), "0");
+        assert_eq!(compute_largestexponent(4, 1), "0");
+        assert_eq!(compute_largestexponent(4, 2), "2");
+        assert_eq!(compute_largestexponent(4, 3), "0");
+        assert_eq!(compute_largestexponent(4, 4), "1");
+        assert_eq!(compute_largestexponent(4, 5), "0");
+        assert_eq!(compute_largestexponent(9, 1), "0");
+        assert_eq!(compute_largestexponent(9, 2), "0");
+        assert_eq!(compute_largestexponent(9, 3), "2");
+        assert_eq!(compute_largestexponent(9, 4), "0");
+        assert_eq!(compute_largestexponent(9, 5), "0");
+        assert_eq!(compute_largestexponent(9, 9), "1");
+        assert_eq!(compute_largestexponent(9, 10), "0");
+        assert_eq!(compute_largestexponent(16, 2), "4");
+        assert_eq!(compute_largestexponent(16, 4), "2");
+        assert_eq!(compute_largestexponent(36, 2), "2");
+        assert_eq!(compute_largestexponent(36, 3), "2");
+        assert_eq!(compute_largestexponent(36, 4), "1");
+        assert_eq!(compute_largestexponent(36, 5), "0");
+        assert_eq!(compute_largestexponent(36, 6), "2");
+        assert_eq!(compute_largestexponent(36, 7), "0");
+    }
+
+    #[test]
+    fn test_230000_largestexponent_big_values() {
+        assert_eq!(compute_largestexponent(0x7fffffff, 0x7fffffff), "1");
+        assert_eq!(compute_largestexponent(0x7fffffff, -0x7fffffff), "1");
+        assert_eq!(compute_largestexponent(-0x7fffffff, 0x7fffffff), "1");
+        assert_eq!(compute_largestexponent(-0x7fffffff, -0x7fffffff), "1");
+        assert_eq!(compute_largestexponent(0x7fffffff, 0), "0");
+        assert_eq!(compute_largestexponent(-0x7fffffff, 0), "0");
+        assert_eq!(compute_largestexponent(0x7fffffff, 1), "0");
+        assert_eq!(compute_largestexponent(-0x7fffffff, 1), "0");
+        assert_eq!(compute_largestexponent(0x7fffffff, 2), "0");
+        assert_eq!(compute_largestexponent(-0x7fffffff, 2), "0");
+        assert_eq!(compute_largestexponent(0x7fffffff, 3), "0");
+        assert_eq!(compute_largestexponent(-0x7fffffff, 3), "0");
+        assert_eq!(compute_largestexponent(0x80000000, 1), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(-0x80000000, 1), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(0x80000001, 2), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(-0x80000001, 2), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(1, 0x7fffffff), "0");
+        assert_eq!(compute_largestexponent(1, -0x7fffffff), "0");
+        assert_eq!(compute_largestexponent(2, 0x7fffffff), "0");
+        assert_eq!(compute_largestexponent(2, -0x7fffffff), "0");
+        assert_eq!(compute_largestexponent(1, 0x80000000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(1, -0x80000000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(1, 0x80000001), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(1, -0x80000001), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(0x10000, 0x100), "2");
+        assert_eq!(compute_largestexponent(-0x10000, 0x100), "2");
+        assert_eq!(compute_largestexponent(0x1000000, 0x1000), "2");
+        assert_eq!(compute_largestexponent(-0x1000000, 0x1000), "2");
+        assert_eq!(compute_largestexponent(0x100000000, 0x10000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(-0x100000000, 0x10000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(0x10000000000, 0x100000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(-0x10000000000, 0x100000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(0x10000, -0x100), "2");
+        assert_eq!(compute_largestexponent(-0x10000, -0x100), "2");
+        assert_eq!(compute_largestexponent(0x1000000, -0x1000), "2");
+        assert_eq!(compute_largestexponent(-0x1000000, -0x1000), "2");
+        assert_eq!(compute_largestexponent(0x100000000, -0x10000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(-0x100000000, -0x10000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(0x10000000000, -0x100000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(-0x10000000000, -0x100000), "InputOutOfRange");
+        assert_eq!(compute_largestexponent(0x1000001, 0x1000), "0");
+    }
 }

rust_project/loda-rust-core/src/execute/semantics.rs

@@ -23,6 +23,7 @@ pub trait Semantics {
     fn nthroot(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError>;
     fn digitsum(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError>;
     fn digitalroot(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError>;
+    fn largestexponent(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError>;
     fn equal(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError>;
     fn notequal(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError>;
     fn lessorequal(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError>;
@@ -143,6 +144,12 @@ impl Semantics for SemanticsWithoutLimits {
         Ok(value)
     }
 
+    fn largestexponent(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError> {
+        let result: Result<BigInt, SemanticSimpleError> = semantic_simple::SEMANTIC_SIMPLE_CONFIG_UNLIMITED.compute_largestexponent(x, y);
+        let value = result?;
+        Ok(value)
+    }
+
     fn equal(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError> {
         let result: Result<BigInt, SemanticSimpleError> = semantic_simple::SEMANTIC_SIMPLE_CONFIG_UNLIMITED.compute_equal(x, y);
         let value = result?;
@@ -297,6 +304,12 @@ impl Semantics for SemanticsWithSmallLimits {
         Ok(value)
     }
 
+    fn largestexponent(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError> {
+        let result: Result<BigInt, SemanticSimpleError> = semantic_simple::SEMANTIC_SIMPLE_CONFIG_LIMIT_SMALL.compute_largestexponent(x, y);
+        let value = result?;
+        Ok(value)
+    }
+
     fn equal(x: &BigInt, y: &BigInt) -> Result<BigInt, EvalError> {
         let result: Result<BigInt, SemanticSimpleError> = semantic_simple::SEMANTIC_SIMPLE_CONFIG_LIMIT_SMALL.compute_equal(x, y);
         let value = result?;

rust_project/loda-rust-core/src/parser/create_program.rs

@@ -466,6 +466,10 @@ impl CreateProgram {
                     let node = self.create_node_calc(&instruction)?;
                     program.push_boxed(node);
                 },
+                InstructionId::LargestExponent => {
+                    let node = self.create_node_calc(&instruction)?;
+                    program.push_boxed(node);
+                },
                 InstructionId::Equal => {
                     let node = self.create_node_calc(&instruction)?;
                     program.push_boxed(node);

rust_project/loda-rust-core/src/parser/instruction_id.rs

@@ -17,6 +17,7 @@ pub enum InstructionId {
     Equal,
     GCD,
     GreaterOrEqual,
+    LargestExponent,
     LessOrEqual,
     Logarithm,
     LoopBegin,
@@ -38,35 +39,36 @@ pub enum InstructionId {
 impl fmt::Display for InstructionId {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let s: &'static str = match self {
-            Self::Add            => "add",
-            Self::Binomial       => "bin",
-            Self::BitwiseAnd     => "ban",
-            Self::BitwiseOr      => "bor",
-            Self::BitwiseXor     => "bxo",
-            Self::EvalSequence   => "seq",
-            Self::Compare        => "cmp",
-            Self::DigitalRoot    => "dgr",
-            Self::DigitSum       => "dgs",
-            Self::Divide         => "div",
-            Self::DivideIf       => "dif",
-            Self::DivideIfRepeat => "dir",
-            Self::Equal          => "equ",
-            Self::GCD            => "gcd",
-            Self::GreaterOrEqual => "geq",
-            Self::LessOrEqual    => "leq",
-            Self::Logarithm      => "log",
-            Self::LoopBegin      => "lpb",
-            Self::LoopEnd        => "lpe",
-            Self::Max            => "max",
-            Self::Min            => "min",
-            Self::Modulo         => "mod",
-            Self::Move           => "mov",
-            Self::Multiply       => "mul",
-            Self::NotEqual       => "neq",
-            Self::NthRoot        => "nrt",
-            Self::Power          => "pow",
-            Self::Subtract       => "sub",
-            Self::Truncate       => "trn",
+            Self::Add             => "add",
+            Self::Binomial        => "bin",
+            Self::BitwiseAnd      => "ban",
+            Self::BitwiseOr       => "bor",
+            Self::BitwiseXor      => "bxo",
+            Self::EvalSequence    => "seq",
+            Self::Compare         => "cmp",
+            Self::DigitalRoot     => "dgr",
+            Self::DigitSum        => "dgs",
+            Self::Divide          => "div",
+            Self::DivideIf        => "dif",
+            Self::DivideIfRepeat  => "dir",
+            Self::Equal           => "equ",
+            Self::GCD             => "gcd",
+            Self::GreaterOrEqual  => "geq",
+            Self::LargestExponent => "lex",
+            Self::LessOrEqual     => "leq",
+            Self::Logarithm       => "log",
+            Self::LoopBegin       => "lpb",
+            Self::LoopEnd         => "lpe",
+            Self::Max             => "max",
+            Self::Min             => "min",
+            Self::Modulo          => "mod",
+            Self::Move            => "mov",
+            Self::Multiply        => "mul",
+            Self::NotEqual        => "neq",
+            Self::NthRoot         => "nrt",
+            Self::Power           => "pow",
+            Self::Subtract        => "sub",
+            Self::Truncate        => "trn",
             Self::UnofficialFunction { input_count, output_count } => {
                 return write!(f, "f{}{}", input_count, output_count);
             },

rust_project/loda-rust-core/src/parser/parse_instruction_id.rs

@@ -36,6 +36,7 @@ impl ParseInstructionId for InstructionId {
             "equ" => Ok(Self::Equal),
             "gcd" => Ok(Self::GCD),
             "geq" => Ok(Self::GreaterOrEqual),
+            "lex" => Ok(Self::LargestExponent),
             "log" => Ok(Self::Logarithm),
             "lpb" => Ok(Self::LoopBegin),
             "lpe" => Ok(Self::LoopEnd),
@@ -123,6 +124,10 @@ mod tests {
             let instruction_id: InstructionId = InstructionId::parse("dir", 1).expect("InstructionId");
             assert_eq!(instruction_id, InstructionId::DivideIfRepeat);
         }
+        {
+            let instruction_id: InstructionId = InstructionId::parse("lex", 1).expect("InstructionId");
+            assert_eq!(instruction_id, InstructionId::LargestExponent);
+        }
         {
             let instruction_id: InstructionId = InstructionId::parse("lps", 1).expect("InstructionId");
             assert_eq!(instruction_id, InstructionId::UnofficialLoopBeginSubtract);

rust_project/loda-rust-web/Cargo.toml

@@ -7,6 +7,9 @@ repository = "https://github.com/loda-lang/loda-rust"
 license = "MIT OR Apache-2.0"
 edition = "2021"
 
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = false
+
 [lib]
 crate-type = ["cdylib"]