Tikz

.github/workflows/c-cpp.yml

@@ -31,7 +31,7 @@ jobs:
       run: sudo apt-get install flex bison make libboost-all-dev libgsl-dev python3 python3-pip
 
     - name: Checkout truth
-      run: git clone --branch master https://github.com/jlab/gapc-test-suite.git $GITHUB_WORKSPACE/../gapc-test-suite
+      run: git clone --branch tikz3 https://github.com/jlab/gapc-test-suite.git $GITHUB_WORKSPACE/../gapc-test-suite
 
     - uses: actions/checkout@v3
     - name: configure
@@ -83,7 +83,7 @@ jobs:
     - name: add base Haskell lib containers (prelude, Data.Map, Data.Map.Strict)
       run: cabal install --lib base
     - name: Checkout truth
-      run: git clone --branch master https://github.com/jlab/gapc-test-suite.git $GITHUB_WORKSPACE/../gapc-test-suite
+      run: git clone --branch tikz3 https://github.com/jlab/gapc-test-suite.git $GITHUB_WORKSPACE/../gapc-test-suite
 
     - uses: actions/checkout@v3
     - name: configure

debian/changelog

@@ -1,3 +1,80 @@
+bellmansgapc (2024.08.01-0ubuntu0ppa1~noble1) xenial; urgency=medium
+
+   * features:
+     + new auto generation of "tikz" algebras" to generate tikZ code to draw
+       candidate trees. Just add "algebra foo auto tikz" to your gap code, as
+       you already did for "count" or "enum".
+       Note: for lager search spaces, you will probably hit the limit of
+       recursive LaTeX environments when compiling the generated tikZ code.
+
+ -- janssenlab <[email protected]>  Mon, 8 January 2024 11:36:00 +0200
+
+bellmansgapc (2024.08.01-0ubuntu0ppa1~mantic1) xenial; urgency=medium
+
+   * features:
+     + new auto generation of "tikz" algebras" to generate tikZ code to draw
+       candidate trees. Just add "algebra foo auto tikz" to your gap code, as
+       you already did for "count" or "enum".
+       Note: for lager search spaces, you will probably hit the limit of
+       recursive LaTeX environments when compiling the generated tikZ code.
+
+ -- janssenlab <[email protected]>  Mon, 8 January 2024 11:36:00 +0200
+
+bellmansgapc (2024.08.01-0ubuntu0ppa1~lunar1) xenial; urgency=medium
+
+   * features:
+     + new auto generation of "tikz" algebras" to generate tikZ code to draw
+       candidate trees. Just add "algebra foo auto tikz" to your gap code, as
+       you already did for "count" or "enum".
+       Note: for lager search spaces, you will probably hit the limit of
+       recursive LaTeX environments when compiling the generated tikZ code.
+
+ -- janssenlab <[email protected]>  Mon, 8 January 2024 11:36:00 +0200
+
+bellmansgapc (2024.08.01-0ubuntu0ppa1~jammy1) xenial; urgency=medium
+
+   * features:
+     + new auto generation of "tikz" algebras" to generate tikZ code to draw
+       candidate trees. Just add "algebra foo auto tikz" to your gap code, as
+       you already did for "count" or "enum".
+       Note: for lager search spaces, you will probably hit the limit of
+       recursive LaTeX environments when compiling the generated tikZ code.
+
+ -- janssenlab <[email protected]>  Mon, 8 January 2024 11:36:00 +0200
+
+bellmansgapc (2024.08.01-0ubuntu0ppa1~focal1) xenial; urgency=medium
+
+   * features:
+     + new auto generation of "tikz" algebras" to generate tikZ code to draw
+       candidate trees. Just add "algebra foo auto tikz" to your gap code, as
+       you already did for "count" or "enum".
+       Note: for lager search spaces, you will probably hit the limit of
+       recursive LaTeX environments when compiling the generated tikZ code.
+
+ -- janssenlab <[email protected]>  Mon, 8 January 2024 11:36:00 +0200
+
+bellmansgapc (2024.08.01-0ubuntu0ppa1~bionic1) xenial; urgency=medium
+
+   * features:
+     + new auto generation of "tikz" algebras" to generate tikZ code to draw
+       candidate trees. Just add "algebra foo auto tikz" to your gap code, as
+       you already did for "count" or "enum".
+       Note: for lager search spaces, you will probably hit the limit of
+       recursive LaTeX environments when compiling the generated tikZ code.
+
+ -- janssenlab <[email protected]>  Mon, 8 January 2024 11:36:00 +0200
+
+bellmansgapc (2024.08.01-0ubuntu0ppa1~xenial1) xenial; urgency=medium
+
+   * features:
+     + new auto generation of "tikz" algebras" to generate tikZ code to draw
+       candidate trees. Just add "algebra foo auto tikz" to your gap code, as
+       you already did for "count" or "enum".
+       Note: for lager search spaces, you will probably hit the limit of
+       recursive LaTeX environments when compiling the generated tikZ code.
+
+ -- janssenlab <[email protected]>  Mon, 8 January 2024 11:36:00 +0200
+
 bellmansgapc (2023.07.05-0ubuntu0ppa1~xenial1) xenial; urgency=medium
 
    * features:

rtlib/generic_main.cc

@@ -71,6 +71,8 @@ int main(int argc, char **argv) {
   std::cout << std::setprecision(FLOAT_ACC) << std::fixed;
 #endif
 
+  // print statements prior to result list, e.g. for TikZ document generation
+  obj.print_document_header(std::cout);
 #ifdef WINDOW_MODE
   unsigned n = obj.t_0_seq.size();
   for (unsigned int i = 0; ; i+=opts.window_increment) {
@@ -94,7 +96,9 @@ int main(int argc, char **argv) {
   gapc::add_event("end_computation");
 
 #ifndef OUTSIDE
+#ifndef TIKZ
   std::cout << "Answer: \n";
+#endif
   obj.print_result(std::cout, res);
 #else
   obj.report_insideoutside(std::cout);
@@ -112,6 +116,8 @@ int main(int argc, char **argv) {
   gapc::add_event("end");
 #endif
 
+  // print statements after result list, e.g. for TikZ document generation
+  obj.print_document_footer(std::cout);
 #ifdef STATS
   obj.print_stats(std::cerr);
 #endif

rtlib/rna.hh

@@ -191,6 +191,20 @@ inline void append_deep_rna(
     str.append(static_cast<char>(base_to_char(*i)));
 }
 
+// same as append_deep_rna, but LOC will leave a <X> instead of an empty string
+template<typename X, typename alphabet, typename pos_type>
+inline void append_deep_rna_loc(
+  rope::Ref<X> &str, const Basic_Subsequence<alphabet, pos_type> &sub) {
+  for (typename Basic_Subsequence<alphabet, pos_type>::const_iterator
+       i = sub.begin(); i != sub.end(); ++i)
+    str.append(static_cast<char>(base_to_char(*i)));
+  if ((sub.size() == 0) && (sub.i == sub.j)) {
+    str.append('<');
+    str.append(static_cast<int>(sub.i));
+    str.append('>');
+  }
+}
+
 // ======== energy wrapper function ========
 
 /*

rtlib/rope.hh

@@ -32,7 +32,9 @@
 #include <fstream>
 #include <sstream>
 
+#include <string>
 #include <boost/cstdint.hpp>
+#include <boost/algorithm/string/replace.hpp>
 
 #include "../rtlib/cstr.h"
 #include "bitops.hh"
@@ -754,6 +756,49 @@ inline void append(rope::Ref<X> &str, const T &x) {
   str.append(x);
 }
 
+/* accepts a string and escapes all containing characters to be compatible
+ * to LaTeX math mode. Used for tikZ generations.
+ */
+inline std::string latex(const std::string in) {
+  std::string out = std::string(in);
+
+  /* https://www.cespedes.org/blog/85/how-to-escape-latex-special-characters
+   * note that we are in math mode, which might use different rules than
+   * LaTeX's "normal" text mode. */
+  boost::replace_all(out, "\\", "\\backslash");
+  boost::replace_all(out, "#", "\\#");
+  boost::replace_all(out, "$", "\\$");
+  boost::replace_all(out, "%", "\\%");
+  boost::replace_all(out, "&", "\\&");
+  boost::replace_all(out, "_", "\\_");
+  boost::replace_all(out, "{", "\\{");
+  boost::replace_all(out, "}", "\\}");
+  boost::replace_all(out, "^", "\\hat{\\ }");
+  boost::replace_all(out, "~", "\\tilde{\\ }");
+
+  return out;
+}
+template<typename X>
+inline void append_latex(rope::Ref<X> &str, char &c) {
+  std::string in(1, c);
+  std::string out = latex(in);
+  str.append(out.c_str(), out.size());
+}
+template<typename X>
+inline void append_latex(rope::Ref<X> &str, const Subsequence &s) {
+  for (typename Subsequence::const_iterator i = s.begin(); i != s.end(); ++i) {
+    char ichar = (*i);
+    append_latex(str, ichar);
+  }
+}
+template<typename X>
+inline void append_latex(rope::Ref<X> &str, const char *s, int slen) {
+  for (int i = 0; i < slen; ++i) {
+    char ichar = (s[i]);
+    append_latex(str, ichar);
+  }
+}
+
 template<class T, typename X>
 inline void append(rope::Ref<X> &str, char c, T i) {
   assert(i >= 0);

src/algebra.hh

@@ -51,9 +51,15 @@ class Filter;
 
 
 class Algebra : public Signature_Base {
+ public:
+  // if algebra is auto generated, it is one of three types: enum, count, tikz
+  // otherwise, it is a user defined one, i.e. not auto generated: NONE
+  enum AutoRole { NONE, ENUM, COUNT, TIKZ };
+
  private:
   std::string *default_choice_fn_mode;
   void init_choice_fns();
+  AutoRole role = AutoRole::NONE;
 
  public:
   hashtable<std::string, Fn_Def*> fns;
@@ -77,9 +83,9 @@ class Algebra : public Signature_Base {
       signature(NULL), signature_name(NULL) {
   }
 
-  explicit Algebra(std::string *n)
+  explicit Algebra(std::string *n, AutoRole role)
     :  Signature_Base(n), default_choice_fn_mode(0),
-      signature(NULL), signature_name(NULL) {
+       role(role), signature(NULL), signature_name(NULL) {
   }
 
 
@@ -139,6 +145,13 @@ class Algebra : public Signature_Base {
   void add_choice_specialisations(Product::Two &product);
 
   Algebra *copy() const;
+
+  /* return role of automatically generated algebra. None if algebra is user
+   * defined.
+   */
+  AutoRole get_auto_role() {
+    return this->role;
+  }
 };
 
 inline std::ostream &operator<<(std::ostream &s, const Algebra &a) {

src/ast.cc

@@ -61,6 +61,7 @@ AST::AST()
     signature(NULL),
     first_instance(NULL), instance_(0),
     backtrack_product(0),
+    fwd_product(0),
     backtrack_filter(0),
     original_product(0),
     char_type(0),
@@ -739,6 +740,7 @@ Instance *AST::split_instance_for_backtrack(std::string &n) {
   original_product = two;
 
   backtrack_product = two->right();
+  fwd_product = two->left();
   backtrack_filter = two->filter();
   Instance *score = new Instance(i->name(), two->left(), grammar());
   return score;

src/ast.hh

@@ -58,6 +58,7 @@
 #include "product.hh"
 
 #include "checkpoint.hh"
+#include "instance.hh"
 
 
 class Signature;
@@ -257,6 +258,10 @@ class AST {
  private:
   // FIXME
   Product::Base *backtrack_product;
+
+  // when instance is split for backtracing, fwd_product is the part computed
+  // in the forward pass
+  Product::Base *fwd_product;
   Filter *backtrack_filter;
   Product::Two *original_product;
 
@@ -299,9 +304,12 @@ class AST {
 
   std::list<std::pair<Filter*, Expr::Fn_Call*> > sf_filter_code;
 
-  Product::Base * get_backtrack_product() {
+  Product::Base * get_backtrack_product() const {
       return backtrack_product;
   }
+  Product::Base * get_fwd_product() const {
+    return fwd_product;
+  }
 
   Printer::Checkpoint *checkpoint;
 
@@ -317,6 +325,12 @@ class AST {
   std::vector<std::string> *get_outside_nt_list() const {
     return this->outside_nt_list;
   }
+
+  bool uses_tikz() const {
+    return instance_->product->uses_tikz() ||
+        (backtrack_product && backtrack_product->uses_tikz()) ||
+        (fwd_product && fwd_product->uses_tikz());
+  }
 };
 
 #endif  // SRC_AST_HH_

src/backtrack_base.cc

@@ -102,6 +102,6 @@ void Backtrack_Base::gen_nt_decls(const std::list<Symbol::NT*> &nts) {
 
 void Backtrack_Base::gen_algebra(Signature &signature, Type::Base *alph) {
   Algebra *a = signature.generate_backtrace
-    (new std::string("bt_algebra"), value_type, pos_type, alph);
+    (new std::string("bt_algebra"), value_type, pos_type, alph, Algebra::NONE);
   algebra = a;
 }