first & second derivative

.github/workflows/c-cpp.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches: [ master ]
   pull_request:
-    branches: [ master, outside_looporder, first_derivative ]
+    branches: [ master, outside_looporder, first_derivative, second_derivative ]
   workflow_dispatch:
     inputs:
       logLevel:

.github/workflows/outside.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches: [ master ]
   pull_request:
-    branches: [ master, outside_looporder ]
+    branches: [ master, outside_looporder, first_derivative, second_derivative ]
   workflow_dispatch:
     inputs:
       logLevel:

rtlib/generic_main.cc

@@ -46,6 +46,9 @@ int main(int argc, char **argv) {
     std::exit(1);
   }
   gapc::class_name obj;
+#ifdef SECOND_DERIVATIVE
+  gapc::class_name_D2 obj_D2;
+#endif
 
   try {
     obj.init(opts);
@@ -116,6 +119,15 @@ int main(int argc, char **argv) {
   gapc::add_event("end");
 #endif
 
+#ifdef SECOND_DERIVATIVE
+  obj_D2.init(opts, &obj);
+  gapc::add_event("start second derivative");
+  obj_D2.run();
+  gapc::add_event("end_computation of second derivative");
+  obj_D2.report_derivative(std::cout);
+  gapc::add_event("end_result of second derivative");
+#endif
+
 #ifdef STATS
   obj.print_stats(std::cerr);
 #endif

rtlib/traces.hh

@@ -79,6 +79,7 @@ bool is_same_index(std::vector<unsigned int> a, std::vector<unsigned int> b) {
 class candidate {
  private:
   double value;
+  double q;
   std::vector<Trace> sub_components;
 
  public:
@@ -94,6 +95,10 @@ class candidate {
     this->value = value;
   }
 
+  void set_q(double q) {
+    this->q = q;
+  }
+
   void add_sub_component(std::string otherNT,
                          std::vector<unsigned int> *indices) {
     sub_components.push_back({otherNT, *indices, NULL});
@@ -107,6 +112,10 @@ class candidate {
     return value;
   }
 
+  double get_q() const {
+    return q;
+  }
+
   /* we need to normalize the individual trace values into probabilities
    * trace values can come in different flavors, depending on what the
    * user uses as scoring schema. See Algebra::check_derivative
@@ -121,6 +130,16 @@ class candidate {
     }
     return res;
   }
+
+  std::vector<Trace> get_soft_max_hessian_candidate(double eval) const {
+    std::vector<Trace> res;
+    for (std::vector<Trace>::const_iterator part = this->sub_components.begin();
+         part != this->sub_components.end(); ++part) {
+      res.push_back({std::get<0>(*part), std::get<1>(*part),
+                     this->get_q() - (eval * this->get_value())});
+    }
+    return res;
+  }
 //  void empty() {
 //    empty(this->value);
 //  }
@@ -143,6 +162,19 @@ std::vector<Trace> normalize_traces(std::vector<Trace> *tabulated,
   return res;
 }
 
+inline
+std::vector<Trace> soft_max_hessian_product(std::vector<Trace> *tabulated,
+                                    const std::vector<candidate> &candidates,
+                                    double eval) {
+  std::vector<std::tuple<std::string, std::vector<unsigned int>, double > > res;
+  for (std::vector<candidate>::const_iterator i = candidates.begin();
+       i != candidates.end(); ++i) {
+    std::vector<Trace> comp = (*i).get_soft_max_hessian_candidate(eval);
+    res.insert(res.end(), comp.begin(), comp.end());
+  }
+  return res;
+}
+
 inline
 double get_trace_weights(const std::vector<Trace> &traces,
                          const std::string &to_nt,