lex operation: largest exponent (#350)

ckrause · web-flow · commit e272450e33dd · 2024-10-20T15:37:41.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,12 +2,18 @@ To install or update LODA, please follow the [installation instructions](https:/
 
 ## [Unreleased]
 
+## v24.10.20
+
+### Features
+
+* Added `lex` operation (largest exponent)
+
 ## v24.9.15
 
 ### Bugfixes
 
-* Fix optimizer bug
-* Fix program folding bug
+* Fix optimizer bugs
+* Fix program folding bugs
 
 ## v24.9.7
 
diff --git a/src/cmd/test.cpp b/src/cmd/test.cpp
@@ -588,15 +588,11 @@ void Test::programUtil() {
                      true);
   }
   p = parser.parse(ProgramUtil::getProgramPath(45));
-  auto h = ProgramUtil::hash(p);
-  size_t expected_hash = 12279585564253383018ULL;
-  if (h != expected_hash) {
-    Log::get().error("Unexpected program hash: " + std::to_string(h), true);
-  }
+  auto h1 = ProgramUtil::hash(p);
   ProgramUtil::removeOps(p, Operation::Type::NOP);
-  h = ProgramUtil::hash(p);
-  if (h != expected_hash) {
-    Log::get().error("Unexpected program hash: " + std::to_string(h), true);
+  auto h2 = ProgramUtil::hash(p);
+  if (h2 != h1) {
+    Log::get().error("Unexpected program hash: " + std::to_string(h2), true);
   }
 }
 
diff --git a/src/eval/interpreter.cpp b/src/eval/interpreter.cpp
@@ -65,6 +65,9 @@ Number Interpreter::calc(const Operation::Type type, const Number& target,
     case Operation::Type::GCD: {
       return Semantics::gcd(target, source);
     }
+    case Operation::Type::LEX: {
+      return Semantics::lex(target, source);
+    }
     case Operation::Type::BIN: {
       return Semantics::bin(target, source);
     }
diff --git a/src/eval/semantics.cpp b/src/eval/semantics.cpp
@@ -106,6 +106,27 @@ Number Semantics::gcd(const Number& a, const Number& b) {
   return aa;
 }
 
+Number Semantics::lex(const Number& a, const Number& b) {
+  if (a == Number::INF || b == Number::INF) {
+    return Number::INF;
+  }
+  if (b == Number::ZERO || b == Number::ONE) {
+    return Number::ZERO;
+  }
+  auto r = Number::ZERO;
+  auto aa = abs(a);
+  auto bb = abs(b);
+  while (true) {
+    auto aaa = dif(aa, bb);
+    if (aaa == aa) {
+      break;
+    }
+    aa = aaa;
+    r += Number::ONE;
+  }
+  return r;
+}
+
 Number Semantics::bin(const Number& nn, const Number& kk) {
   if (nn == Number::INF || kk == Number::INF) {
     return Number::INF;
diff --git a/src/eval/semantics.hpp b/src/eval/semantics.hpp
@@ -22,6 +22,8 @@ class Semantics {
 
   static Number gcd(const Number& a, const Number& b);
 
+  static Number lex(const Number& a, const Number& b);
+
   static Number bin(const Number& n, const Number& k);
 
   static Number log(const Number& a, const Number& b);
diff --git a/src/lang/program.cpp b/src/lang/program.cpp
@@ -2,18 +2,18 @@
 
 #include <stdexcept>
 
-const std::array<Operation::Type, 32> Operation::Types = {
+const std::array<Operation::Type, 33> Operation::Types = {
     Operation::Type::NOP, Operation::Type::MOV, Operation::Type::ADD,
     Operation::Type::SUB, Operation::Type::TRN, Operation::Type::MUL,
     Operation::Type::DIV, Operation::Type::DIF, Operation::Type::MOD,
-    Operation::Type::POW, Operation::Type::GCD, Operation::Type::BIN,
-    Operation::Type::LOG, Operation::Type::NRT, Operation::Type::DIS,
-    Operation::Type::DIR, Operation::Type::EQU, Operation::Type::NEQ,
-    Operation::Type::LEQ, Operation::Type::GEQ, Operation::Type::MIN,
-    Operation::Type::MAX, Operation::Type::BAN, Operation::Type::BOR,
-    Operation::Type::BXO, Operation::Type::LPB, Operation::Type::LPE,
-    Operation::Type::CLR, Operation::Type::SRT, Operation::Type::SEQ,
-    Operation::Type::PRG, Operation::Type::DBG,
+    Operation::Type::POW, Operation::Type::GCD, Operation::Type::LEX,
+    Operation::Type::BIN, Operation::Type::LOG, Operation::Type::NRT,
+    Operation::Type::DIS, Operation::Type::DIR, Operation::Type::EQU,
+    Operation::Type::NEQ, Operation::Type::LEQ, Operation::Type::GEQ,
+    Operation::Type::MIN, Operation::Type::MAX, Operation::Type::BAN,
+    Operation::Type::BOR, Operation::Type::BXO, Operation::Type::LPB,
+    Operation::Type::LPE, Operation::Type::CLR, Operation::Type::SRT,
+    Operation::Type::SEQ, Operation::Type::PRG, Operation::Type::DBG,
 };
 
 const Operation::Metadata& Operation::Metadata::get(Type t) {
@@ -39,6 +39,8 @@ const Operation::Metadata& Operation::Metadata::get(Type t) {
       Operation::Type::POW, "pow", 2, true, true, true};
   static Operation::Metadata gcd{
       Operation::Type::GCD, "gcd", 2, true, true, true};
+  static Operation::Metadata lex{
+      Operation::Type::LEX, "lex", 2, true, true, true};
   static Operation::Metadata bin{
       Operation::Type::BIN, "bin", 2, true, true, true};
   static Operation::Metadata log{
@@ -104,6 +106,8 @@ const Operation::Metadata& Operation::Metadata::get(Type t) {
       return pow;
     case Operation::Type::GCD:
       return gcd;
+    case Operation::Type::LEX:
+      return lex;
     case Operation::Type::BIN:
       return bin;
     case Operation::Type::LOG:
diff --git a/src/lang/program.hpp b/src/lang/program.hpp
@@ -45,6 +45,7 @@ class Operation {
     MOD,     // modulo
     POW,     // power
     GCD,     // greatest common divisor
+    LEX,     // largest exponent
     BIN,     // binomial coefficient
     LOG,     // logarithm
     NRT,     // n-th root
@@ -69,7 +70,7 @@ class Operation {
     __COUNT  // number of operation types
   };
 
-  static const std::array<Type, 32> Types;
+  static const std::array<Type, 33> Types;
 
   class Metadata {
    public:
diff --git a/src/mine/generator.cpp b/src/mine/generator.cpp
@@ -264,6 +264,7 @@ void Generator::ensureMeaningfulLoops(Program &p) {
       case Operation::Type::DIF:
       case Operation::Type::MOD:
       case Operation::Type::GCD:
+      case Operation::Type::LEX:
       case Operation::Type::BIN:
       case Operation::Type::EQU:
       case Operation::Type::NEQ:
diff --git a/src/mine/iterator.cpp b/src/mine/iterator.cpp
@@ -93,6 +93,10 @@ bool Iterator::inc(Operation& op) {
       return true;
 
     case Operation::Type::GCD:
+      op.type = Operation::Type::LEX;
+      return true;
+
+    case Operation::Type::LEX:
       op.type = Operation::Type::BIN;
       return true;
 
@@ -173,20 +177,22 @@ bool Iterator::shouldSkip(const Operation& op) {
        op.type == Operation::Type::TRN || op.type == Operation::Type::MUL ||
        op.type == Operation::Type::DIV || op.type == Operation::Type::DIF ||
        op.type == Operation::Type::MOD || op.type == Operation::Type::GCD ||
-       op.type == Operation::Type::BIN || op.type == Operation::Type::EQU ||
-       op.type == Operation::Type::NEQ)) {
+       op.type == Operation::Type::LEX || op.type == Operation::Type::BIN ||
+       op.type == Operation::Type::EQU || op.type == Operation::Type::NEQ)) {
     return true;
   }
   if (op.source == CONSTANT_ZERO &&
       (op.type == Operation::Type::MUL || op.type == Operation::Type::DIV ||
        op.type == Operation::Type::DIF || op.type == Operation::Type::MOD ||
        op.type == Operation::Type::POW || op.type == Operation::Type::GCD ||
-       op.type == Operation::Type::BIN || op.type == Operation::Type::LPB)) {
+       op.type == Operation::Type::LEX || op.type == Operation::Type::BIN ||
+       op.type == Operation::Type::LPB)) {
     return true;
   }
   if (op.source == CONSTANT_ONE &&
       (op.type == Operation::Type::MOD || op.type == Operation::Type::POW ||
-       op.type == Operation::Type::GCD || op.type == Operation::Type::BIN)) {
+       op.type == Operation::Type::GCD || op.type == Operation::Type::LEX ||
+       op.type == Operation::Type::BIN)) {
     return true;
   }
 
diff --git a/tests/semantics/lex.csv b/tests/semantics/lex.csv
@@ -0,0 +1,59 @@
+Op1,Op2,Result
+-4,-5,0
+-4,-4,1
+-4,-3,0
+-4,-2,2
+-4,-1,0
+-4,0,0
+-4,1,0
+-4,2,2
+-4,3,0
+-4,4,1
+-4,5,0
+-4,6,0
+-4,7,0
+-4,8,0
+0,-2,0
+0,-1,0
+0,0,0
+0,1,0
+0,2,0
+1,-1,0
+1,-1,0
+1,0,0
+1,1,0
+1,2,0
+2,-3,0
+2,-2,1
+2,-1,0
+2,0,0
+2,1,0
+2,2,1
+2,3,0
+2,4,0
+4,-5,0
+4,-4,1
+4,-3,0
+4,-2,2
+4,-1,0
+4,0,0
+4,1,0
+4,2,2
+4,3,0
+4,4,1
+4,5,0
+9,1,0
+9,2,0
+9,3,2
+9,4,0
+9,5,0
+9,9,1
+9,10,0
+16,2,4
+16,4,2
+36,2,2
+36,3,2
+36,4,1
+36,5,0
+36,6,2
+36,7,0

Original file line number	Diff line number	Diff line change
`@@ -588,15 +588,11 @@ void Test::programUtil() {`
`588`	`588`	`true);`
`589`	`589`	`}`
`590`	`590`	`p = parser.parse(ProgramUtil::getProgramPath(45));`
`591`		`- auto h = ProgramUtil::hash(p);`
`592`		`- size_t expected_hash = 12279585564253383018ULL;`
`593`		`- if (h != expected_hash) {`
`594`		`- Log::get().error("Unexpected program hash: " + std::to_string(h), true);`
`595`		`- }`
	`591`	`+ auto h1 = ProgramUtil::hash(p);`
`596`	`592`	`ProgramUtil::removeOps(p, Operation::Type::NOP);`
`597`		`- h = ProgramUtil::hash(p);`
`598`		`- if (h != expected_hash) {`
`599`		`- Log::get().error("Unexpected program hash: " + std::to_string(h), true);`
	`593`	`+ auto h2 = ProgramUtil::hash(p);`
	`594`	`+ if (h2 != h1) {`
	`595`	`+ Log::get().error("Unexpected program hash: " + std::to_string(h2), true);`
`600`	`596`	`}`
`601`	`597`	`}`
`602`	`598`
Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,9 @@ Number Interpreter::calc(const Operation::Type type, const Number& target,`
`65`	`65`	`case Operation::Type::GCD: {`
`66`	`66`	`return Semantics::gcd(target, source);`
`67`	`67`	`}`
	`68`	`+ case Operation::Type::LEX: {`
	`69`	`+ return Semantics::lex(target, source);`
	`70`	`+ }`
`68`	`71`	`case Operation::Type::BIN: {`
`69`	`72`	`return Semantics::bin(target, source);`
`70`	`73`	`}`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,59 @@ @@
 +Op1,Op2,Result
 +-4,-5,0
 +-4,-4,1
 +-4,-3,0
 +-4,-2,2
 +-4,-1,0
 +-4,0,0
 +-4,1,0
 +-4,2,2
 +-4,3,0
 +-4,4,1
 +-4,5,0
 +-4,6,0
 +-4,7,0
 +-4,8,0
 +0,-2,0
 +0,-1,0
 +0,0,0
 +0,1,0
 +0,2,0
 +1,-1,0
 +1,-1,0
 +1,0,0
 +1,1,0
 +1,2,0
 +2,-3,0
 +2,-2,1
 +2,-1,0
 +2,0,0
 +2,1,0
 +2,2,1
 +2,3,0
 +2,4,0
 +4,-5,0
 +4,-4,1
 +4,-3,0
 +4,-2,2
 +4,-1,0
 +4,0,0
 +4,1,0
 +4,2,2
 +4,3,0
 +4,4,1
 +4,5,0
 +9,1,0
 +9,2,0
 +9,3,2
 +9,4,0
 +9,5,0
 +9,9,1
 +9,10,0
 +16,2,4
 +16,4,2
 +36,2,2
 +36,3,2
 +36,4,1
 +36,5,0
 +36,6,2
 +36,7,0