use oeis offsets (#351)

Author: ckrause

CHANGELOG.md

@@ -2,6 +2,12 @@ To install or update LODA, please follow the [installation instructions](https:/
 
 ## [Unreleased]
 
+## v24.11.29
+
+### Features
+
+* Support for sequence offsets (extracted from the OEIS)
+
 ## v24.10.20
 
 ### Features

README.md

@@ -44,8 +44,7 @@ Targets:
 
 Options:
   -t <number>          Number of sequence terms (default: 8)
-  -b                   Print result in b-file format from offset 0
-  -B <number>          Print result in b-file format from a custom offset
+  -b                   Print result in the OEIS b-file format
   -o <string>          Export format (formula,loda,pari-function,pari-vector)
   -d                   Export with dependencies to other programs
   -s                   Evaluate program to number of execution steps

src/cmd/commands.cpp

@@ -95,11 +95,7 @@ void Commands::help() {
   std::cout << std::endl << "Options:" << std::endl;
   std::cout << "  -t <number>          Number of sequence terms (default: "
             << settings.num_terms << ")" << std::endl;
-  std::cout
-      << "  -b                   Print result in b-file format from offset 0"
-      << std::endl;
-  std::cout << "  -B <number>          Print result in b-file format from a "
-               "custom offset"
+  std::cout << "  -b                   Print result in the OEIS b-file format"
             << std::endl;
   std::cout << "  -o <string>          Export format "
                "(formula,loda,pari-function,pari-vector)"
@@ -607,7 +603,8 @@ void Commands::testPari(const std::string& test_id) {
     }
 
     // evaluate PARI program
-    auto genSeq = pari_formula.eval(numTerms);
+    auto offset = ProgramUtil::getOffset(program);
+    auto genSeq = pari_formula.eval(offset, numTerms);
 
     // compare results
     if (genSeq != expSeq) {

src/eval/evaluator.cpp

@@ -2,6 +2,7 @@
 
 #include <sstream>
 
+#include "lang/program_util.hpp"
 #include "sys/log.hpp"
 
 steps_t::steps_t() : min(0), max(0), total(0), runs(0) {}
@@ -42,6 +43,7 @@ steps_t Evaluator::eval(const Program &p, Sequence &seq, int64_t num_terms,
   size_t s;
   const bool use_inc = use_inc_eval && inc_evaluator.init(p);
   std::pair<Number, size_t> inc_result;
+  const int64_t offset = ProgramUtil::getOffset(p);
   for (int64_t i = 0; i < num_terms; i++) {
     try {
       if (use_inc) {
@@ -50,7 +52,7 @@ steps_t Evaluator::eval(const Program &p, Sequence &seq, int64_t num_terms,
         s = inc_result.second;
       } else {
         mem.clear();
-        mem.set(Program::INPUT_CELL, i);
+        mem.set(Program::INPUT_CELL, i + offset);
         s = interpreter.run(p, mem);
         seq[i] = mem.get(Program::OUTPUT_CELL);
       }
@@ -71,8 +73,7 @@ steps_t Evaluator::eval(const Program &p, Sequence &seq, int64_t num_terms,
       seq[i] = s;
     }
     if (settings.print_as_b_file) {
-      std::cout << (settings.print_as_b_file_offset + i) << " " << seq[i]
-                << std::endl;
+      std::cout << (offset + i) << " " << seq[i] << std::endl;
     }
   }
   if (is_debug) {
@@ -97,9 +98,10 @@ steps_t Evaluator::eval(const Program &p, std::vector<Sequence> &seqs,
   Memory mem;
   steps_t steps;
   // note: we can't use the incremental evaluator here
+  const int64_t offset = ProgramUtil::getOffset(p);
   for (int64_t i = 0; i < num_terms; i++) {
     mem.clear();
-    mem.set(Program::INPUT_CELL, i);
+    mem.set(Program::INPUT_CELL, i + offset);
     steps.add(interpreter.run(p, mem));
     for (size_t s = 0; s < seqs.size(); s++) {
       seqs[s][i] = mem.get(s);
@@ -128,14 +130,15 @@ std::pair<status_t, steps_t> Evaluator::check(const Program &p,
   const bool use_inc = use_inc_eval && inc_evaluator.init(p);
   std::pair<Number, size_t> inc_result;
   Number out;
+  const int64_t offset = ProgramUtil::getOffset(p);
   for (size_t i = 0; i < expected_seq.size(); i++) {
     try {
       if (use_inc) {
         inc_result = inc_evaluator.next();
         out = inc_result.first;
       } else {
         mem.clear();
-        mem.set(Program::INPUT_CELL, i);
+        mem.set(Program::INPUT_CELL, i + offset);
         result.second.add(interpreter.run(p, mem, id));
         out = mem.get(Program::OUTPUT_CELL);
       }
@@ -152,15 +155,14 @@ std::pair<status_t, steps_t> Evaluator::check(const Program &p,
     }
     if (out != expected_seq[i]) {
       if (settings.print_as_b_file) {
-        std::cout << (settings.print_as_b_file_offset + i) << " " << out
-                  << " -> expected " << expected_seq[i] << std::endl;
+        std::cout << (offset + i) << " " << out << " -> expected "
+                  << expected_seq[i] << std::endl;
       }
       result.first = status_t::ERROR;
       return result;
     }
     if (settings.print_as_b_file) {
-      std::cout << (settings.print_as_b_file_offset + i) << " "
-                << expected_seq[i] << std::endl;
+      std::cout << (offset + i) << " " << expected_seq[i] << std::endl;
     }
   }
   result.first = status_t::OK;

src/eval/evaluator_inc.cpp

@@ -22,6 +22,7 @@ void IncrementalEvaluator::reset() {
   loop_counter_decrement = 0;
   loop_counter_lower_bound = 0;
   loop_counter_type = Operation::Type::NOP;
+  offset = 0;
   initialized = false;
 
   // runtime data
@@ -36,7 +37,7 @@ void IncrementalEvaluator::reset() {
 // ====== Initialization functions (static code analysis) =========
 
 bool IncrementalEvaluator::init(const Program& program,
-                                bool skip_input_transform) {
+                                bool skip_input_transform, bool skip_offset) {
   reset();
   simple_loop = Analyzer::extractSimpleLoop(program);
   if (!simple_loop.is_simple_loop) {
@@ -65,6 +66,10 @@ bool IncrementalEvaluator::init(const Program& program,
     }
     return false;
   }
+  // extract offset from program directive
+  offset = skip_offset ? 0 : ProgramUtil::getOffset(program);
+
+  // initialue the runtime data
   initRuntimeData();
   initialized = true;
   if (is_debug) {
@@ -317,6 +322,7 @@ void IncrementalEvaluator::initRuntimeData() {
   loop_states.resize(loop_counter_decrement);
   previous_loop_counts.resize(loop_counter_decrement, 0);
   total_loop_steps.resize(loop_counter_decrement, 0);
+  argument = offset;
   previous_slice = 0;
 }
 

src/eval/evaluator_inc.hpp

@@ -27,7 +27,8 @@ class IncrementalEvaluator {
 
   // Initialize the IE using a program. IE can be applied only if this function
   // returns true.
-  bool init(const Program& program, bool skip_input_transform = false);
+  bool init(const Program& program, bool skip_input_transform = false,
+            bool skip_offset = false);
 
   // Compute the next term and step count.
   std::pair<Number, size_t> next(bool skip_final_iter = false,
@@ -76,6 +77,7 @@ class IncrementalEvaluator {
   std::set<int64_t> loop_counter_dependent_cells;
   int64_t loop_counter_decrement;
   int64_t loop_counter_lower_bound;
+  int64_t offset;
   Operation::Type loop_counter_type;
   bool initialized;
   const bool is_debug;

src/form/formula_gen.cpp

@@ -231,7 +231,8 @@ bool FormulaGenerator::generateSingle(const Program& p) {
     return false;
   }
   const int64_t numCells = ProgramUtil::getLargestDirectMemoryCell(p) + 1;
-  const bool useIncEval = incEval.init(p, true);  // skip input transformations
+  const bool useIncEval =
+      incEval.init(p, true, true);  // skip input transformations and offset
 
   // initialize function names for memory cells
   cellNames.clear();
@@ -291,12 +292,13 @@ bool FormulaGenerator::generateSingle(const Program& p) {
     simplifyFormulaUsingVariants(formula, numTerms);
 
     // evaluate program and add initial terms to formula
-    if (!addInitialTerms(numCells, numTerms)) {
+    const int64_t offset = ProgramUtil::getOffset(p);
+    if (!addInitialTerms(numCells, offset, numTerms)) {
       return false;
     }
 
     // prepare post-loop processing
-    prepareForPostLoop(numCells, preloopExprs);
+    prepareForPostLoop(numCells, offset, preloopExprs);
     Log::get().debug("Prepared post-loop: " + formula.toString());
 
     // handle post-loop code
@@ -329,7 +331,8 @@ bool FormulaGenerator::generateSingle(const Program& p) {
 }
 
 void FormulaGenerator::prepareForPostLoop(
-    int64_t numCells, const std::map<int64_t, Expression>& preloopExprs) {
+    int64_t numCells, int64_t offset,
+    const std::map<int64_t, Expression>& preloopExprs) {
   // prepare post-loop processing
   auto preloopCounter = preloopExprs.at(incEval.getSimpleLoop().counter);
   for (int64_t cell = 0; cell < numCells; cell++) {
@@ -365,7 +368,8 @@ void FormulaGenerator::prepareForPostLoop(
 }
 
 bool FormulaGenerator::addInitialTerms(
-    int64_t numCells, const std::map<std::string, int64_t>& numTerms) {
+    int64_t numCells, int64_t offset,
+    const std::map<std::string, int64_t>& numTerms) {
   // calculate maximum offset
   int64_t maxNumTerms = 0;
   for (auto it : numTerms) {
@@ -374,7 +378,7 @@ bool FormulaGenerator::addInitialTerms(
     maxNumTerms = std::max(maxNumTerms, it.second);
   }
   // evaluate program and add initial terms to formula
-  for (int64_t offset = 0; offset < maxNumTerms; offset++) {
+  for (int64_t n = 0; n < maxNumTerms; n++) {
     try {
       incEval.next(true, true);  // skip final iteration and post loop code
     } catch (const std::exception&) {
@@ -384,9 +388,13 @@ bool FormulaGenerator::addInitialTerms(
     const auto state = incEval.getLoopStates().at(incEval.getPreviousSlice());
     for (int64_t cell = 0; cell < numCells; cell++) {
       auto name = getCellName(cell);
-      if (offset < numTerms.at(name)) {
+      if (n < numTerms.at(name)) {
+        auto arg = n;
+        if (cell == Program::INPUT_CELL) {
+          arg += offset;
+        }
         Expression func(Expression::Type::FUNCTION, name,
-                        {ExpressionUtil::newConstant(offset)});
+                        {ExpressionUtil::newConstant(arg)});
         Expression val(Expression::Type::CONSTANT, "", state.get(cell));
         formula.entries[func] = val;
         Log::get().debug("Added intial term: " + func.toString() + " = " +

src/form/formula_gen.hpp

@@ -38,10 +38,10 @@ class FormulaGenerator {
 
   bool update(const Program& p);
 
-  void prepareForPostLoop(int64_t numCells,
+  void prepareForPostLoop(int64_t numCells, int64_t offset,
                           const std::map<int64_t, Expression>& preloopExprs);
 
-  bool addInitialTerms(int64_t numCells,
+  bool addInitialTerms(int64_t numCells, int64_t offset,
                        const std::map<std::string, int64_t>& numTerms);
 
   std::string newName();

src/form/pari.cpp

@@ -129,7 +129,8 @@ std::string PariFormula::toString() const {
   }
 }
 
-void PariFormula::printEvalCode(int64_t numTerms, std::ostream& out) const {
+void PariFormula::printEvalCode(int64_t offset, int64_t numTerms,
+                                std::ostream& out) const {
   if (as_vector) {
     // declare vectors
     auto functions =
@@ -141,9 +142,8 @@ void PariFormula::printEvalCode(int64_t numTerms, std::ostream& out) const {
     // main function
     out << toString() << std::endl;
   }
-  const int64_t start = 0;
-  const int64_t end = numTerms - 1;
-  out << "for(n=" << start << "," << end << ",";
+  const int64_t end = offset + numTerms - 1;
+  out << "for(n=" << offset << "," << end << ",";
   if (as_vector) {
     out << toString() << "; ";
     out << "print(a[n+1])";
@@ -153,15 +153,15 @@ void PariFormula::printEvalCode(int64_t numTerms, std::ostream& out) const {
   out << ")" << std::endl << "quit" << std::endl;
 }
 
-Sequence PariFormula::eval(int64_t numTerms) const {
+Sequence PariFormula::eval(int64_t offset, int64_t numTerms) const {
   const std::string gpPath("pari-loda.gp");
   const std::string gpResult("pari-result.txt");
   const int64_t maxparisize = 256;  // in MB
   std::ofstream gp(gpPath);
   if (!gp) {
     throw std::runtime_error("error generating gp file");
   }
-  printEvalCode(numTerms, gp);
+  printEvalCode(offset, numTerms, gp);
   gp.close();
   std::string cmd = "gp -s " + std::to_string(maxparisize) + "M -q " + gpPath +
                     " > " + gpResult;

src/form/pari.hpp

@@ -21,11 +21,11 @@ class PariFormula {
   static bool convert(const Formula& formula, bool as_vector,
                       PariFormula& pari_formula);
 
-  void printEvalCode(int64_t numTerms, std::ostream& out) const;
+  void printEvalCode(int64_t offset, int64_t numTerms, std::ostream& out) const;
 
   std::string toString() const;
 
-  Sequence eval(int64_t numTerms) const;
+  Sequence eval(int64_t offset, int64_t numTerms) const;
 
  private:
   Formula main_formula;

src/lang/parser.cpp

@@ -20,7 +20,8 @@ Program Parser::parse(const std::string &file) {
 }
 
 Program Parser::parse(std::istream &in_) {
-  const static std::set<std::string> valid_directives = {"inputs", "outputs"};
+  const static std::set<std::string> valid_directives = {"inputs", "outputs",
+                                                         "offset"};
   in = &in_;
   Program p;
   Operation o;

src/lang/program_util.cpp

@@ -556,3 +556,29 @@ std::string ProgramUtil::getProgramPath(int64_t id, const std::string &dir,
   return Setup::getProgramsHome() + dir + FILE_SEP + dirStr(id) + FILE_SEP +
          idStr(id, prefix) + ".asm";
 }
+
+int64_t ProgramUtil::getOffset(const Program &p) {
+  return p.getDirective("offset", 0);
+}
+
+int64_t ProgramUtil::setOffset(Program &p, int64_t offset) {
+  const int64_t current = p.getDirective("offset", 0);
+  const int64_t delta = offset - current;
+  if (delta > 0) {
+    p.ops.insert(p.ops.begin(),
+                 Operation(Operation::Type::SUB,
+                           Operand(Operand::Type::DIRECT, Program::INPUT_CELL),
+                           Operand(Operand::Type::CONSTANT, delta)));
+  } else if (delta < 0) {
+    p.ops.insert(p.ops.begin(),
+                 Operation(Operation::Type::ADD,
+                           Operand(Operand::Type::DIRECT, Program::INPUT_CELL),
+                           Operand(Operand::Type::CONSTANT, -delta)));
+  }
+  if (offset != 0) {
+    p.directives["offset"] = offset;
+  } else {
+    p.directives.erase("offset");
+  }
+  return delta;
+}

src/lang/program_util.hpp

@@ -90,4 +90,8 @@ class ProgramUtil {
 
   static std::string getProgramPath(int64_t id, const std::string &dir,
                                     const std::string &prefix);
+
+  static int64_t getOffset(const Program &p);
+
+  static int64_t setOffset(Program &p, int64_t offset);
 };