Refonte

single/Makefile

@@ -1,22 +1,23 @@
 # CILK_ROOT must contains the GCC/Cilk root directory
 OS     	    = $(shell uname)
+MAX_GENUS   = $(shell cat ../genus)
 CPPFLAGS    = -DMAX_GENUS=$(MAX_GENUS) #-DNDEBUG
 CXXFLAGS    = -std=c++11 -g -Wall -O3 # -fsanitize=thread # -Winline
 CXX         = g++
 TARGET_ARCH = -march=corei7 -mtune=corei7
-TARGET 	    = wilf
+TARGET 	    = ../wilf
 
 
 
 # Pour compiler avec une valeur différente: make MAX_GENUS=35
-DEFAULT_MAX_GENUS=40
-MAX_GENUS=$(DEFAULT_MAX_GENUS)
+#DEFAULT_MAX_GENUS=40
+#MAX_GENUS=$(DEFAULT_MAX_GENUS)
 
 all: $(TARGET)
 
-monoid.o: monoid.cpp monoid.hpp
-treewalk.o: treewalk.cpp treewalk.hpp monoid.hpp
-wilf: treewalk.o monoid.o
+semigroup.o: semigroup.cpp semigroup.hpp ../genus
+treewalk.o: treewalk.cpp treewalk.hpp semigroup.hpp stack.hpp ../genus
+../wilf: treewalk.o semigroup.o
 	$(CXX) $(LDFLAGS) $^ $(LOADLIBES) $(LDLIBS) -o $@
 
 clean:

single/monoid.cpp

@@ -1,8 +1,8 @@
 #include <iostream>
-#include "monoid.hpp"
+#include <cstring>
+#include "semigroup.hpp"
 
-void init_full_N(monoid &m)
-{
+void init_full_N(Semigroup &m){
   epi8 block ={1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8};
   for(auto i=0; i<NBLOCKS; i++){
     m.blocks[i] = block;
@@ -17,7 +17,32 @@ void init_full_N(monoid &m)
   m.wilf=0;
 }
 
-void init_ordinary(monoid &O,int m){
+void init(Semigroup& S,char c,char g,char m,char* d){
+  S.conductor=c;
+  S.genus=g;
+  S.min=m;
+  memcpy((void*)S.decs,(void*)d,(3*MAX_GENUS+1));
+  S.left=0;
+  S.left_primitive=0;
+  S.e=0;
+  for(ind_t i=0;i<S.conductor;++i){
+    if(d[i]>0){
+      ++S.left;
+      if(d[i]==1){
+	++S.e;
+	++S.left_primitive;
+      }
+    }
+  }
+  for(ind_t i=S.conductor;i<S.conductor+S.min;++i){
+    if(d[i]==1){
+      ++S.e;
+    }
+  }
+  S.wilf=S.left*S.e-S.conductor;
+}
+
+void init_ordinary(Semigroup &O,int m){
   O.decs[0]=1;
   for(auto i=1;i<2*m;++i){
     O.decs[i]=i/m;
@@ -35,7 +60,7 @@ void init_ordinary(monoid &O,int m){
   O.wilf=0;
 }
 
-void print_monoid(const monoid &m)
+void print_Semigroup(const Semigroup &m)
 {
   unsigned int i;
   std::cout<<"min = "<<m.min<<", cond = "<<m.conductor<<", genus = "<<m.genus<<", decs = ";
@@ -43,7 +68,7 @@ void print_monoid(const monoid &m)
   std::cout<<std::endl;
 }
 
-void print_monoid_gen(const monoid &m)
+void print_Semigroup_gen(const Semigroup &m)
 {
   unsigned int i;
   std::cout<<"m = "<<m.min<<", c = "<<m.conductor<<", g = "<<m.genus<<" w = "<<m.wilf<<" ";
@@ -59,7 +84,7 @@ void print_monoid_gen(const monoid &m)
 #include <cmath>
 
 
-void output(const monoid& m,fstream& f){
+void output(const Semigroup& m,fstream& f){
   int q=ceil(float(m.conductor)/float(m.min));
   int rho=q*m.min-m.conductor;
   f<<"c = "<<m.conductor<<", g = "<<m.genus<<", r = "<<rho<<", w = "<<m.wilf<<" : ["<<m.min;
@@ -71,6 +96,17 @@ void output(const monoid& m,fstream& f){
   f<<']'<<endl;
 }
 
+void record(const Semigroup& S,fstream& f){
+  char c,g,m;
+  c=S.conductor;
+  g=S.genus;
+  m=S.min;
+  f.write(&c,1);
+  f.write(&g,1);
+  f.write(&m,1);
+  f.write((char*)(&S.decs),3*MAX_GENUS+1);
+}
+
 void print_epi8(epi8 bl)
 {
   unsigned int i;

single/monoid.hpp

@@ -1,5 +1,5 @@
-#ifndef MONOID_HPP
-#define MONOID_HPP
+#ifndef SEMIGROUP_HPP
+#define SEMIGROUP_HPP
 
 #include <cstdint>
 #include <fstream>
@@ -28,7 +28,7 @@ typedef uint_fast64_t ind_t;  // The type used for array indexes
 
 using namespace std;
 
-struct monoid
+struct Semigroup
 {
   union {
     dec_numbers decs;
@@ -38,18 +38,19 @@ struct monoid
   ind_t conductor, min, genus,left_primitive,left,e,wilf;
 };
 
-void init_full_N(monoid &);
-void init_ordinary(monoid& O,int m);
-void print_monoid(const monoid &);
-void print_monoid_gen(const monoid&);
+void init_full_N(Semigroup &);
+void init(Semigroup&,char,char,char,char*);
+void print_Semigroup(const Semigroup &);
+void print_Semigroup_gen(const Semigroup&);
 void print_epi8(epi8);
-void output(const monoid& m,fstream& f);
+void output(const Semigroup& m,fstream& f);
+void record(const Semigroup& S,fstream& f);
 inline void copy_blocks(      dec_blocks &__restrict__ dst,
 			const dec_blocks &__restrict__ src);
-inline void remove_generator(monoid &__restrict__ dst,
-		      const monoid &__restrict__ src,
+inline void remove_generator(Semigroup &__restrict__ dst,
+		      const Semigroup &__restrict__ src,
 			     ind_t gen,ind_t pos);
-inline monoid remove_generator(const monoid &src, ind_t gen,ind_t pos);
+inline Semigroup remove_generator(const Semigroup &src, ind_t gen,ind_t pos);
 
 
 // typedef enum { ALL, CHILDREN } generator_type;
@@ -57,17 +58,16 @@ class ALL {};
 class CHILDREN {};
 
 // template <generator_type T> class generator_iter
-template <class T> class generator_iter
-{
+template <class T> class generator_iter{
 private:
 
-  const monoid &m;
+  const Semigroup &m;
   unsigned int mask;   // movemask_epi8 returns a 32 bits values
   ind_t iblock, gen, bound;
 
 public:
 
-  generator_iter(const monoid &mon);
+  generator_iter(const Semigroup &mon);
   bool move_next();
   uint8_t count();
   inline ind_t get_gen() const {return gen; };
@@ -137,9 +137,8 @@ const epi8 mask16[16] =
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,m1} };
 
 
-template<> inline generator_iter<ALL>::generator_iter(const monoid &mon)
-  : m(mon), bound((mon.conductor+mon.min+15) >> 4)
-{
+template<> inline generator_iter<ALL>::generator_iter(const Semigroup &mon)
+  : m(mon), bound((mon.conductor+mon.min+15) >> 4){
   epi8 block;
   iblock = 0;
   block = m.blocks[0];
@@ -149,9 +148,8 @@ template<> inline generator_iter<ALL>::generator_iter(const monoid &mon)
 };
 
 
-template<> inline generator_iter<CHILDREN>::generator_iter(const monoid &mon)
-  : m(mon), bound((mon.conductor+mon.min+15) >> 4)
-{
+template<> inline generator_iter<CHILDREN>::generator_iter(const Semigroup &mon)
+  : m(mon), bound((mon.conductor+mon.min+15) >> 4){
   epi8 block;
   iblock = m.conductor >> 4;
   block = m.blocks[iblock] & mask16[m.conductor & 0xF];
@@ -159,23 +157,20 @@ template<> inline generator_iter<CHILDREN>::generator_iter(const monoid &mon)
   gen = (iblock << 4) - 1;
 };
 
-template <class T> inline uint8_t generator_iter<T>::count()
-{
+template <class T> inline uint8_t generator_iter<T>::count(){
   uint8_t nbr = _mm_popcnt_u32(mask); // popcnt returns a 8 bits value
   for (ind_t ib = iblock+1; ib < bound; ib++)
     nbr += _mm_popcnt_u32(movemask_epi8(m.blocks[ib] == block1));
   return nbr;
 };
 
-template <class T> inline bool generator_iter<T>::move_next()
-{
-  while (!mask)
-    {
-      iblock++;
-      if (iblock > bound) return false;
-      gen = (iblock << 4) - 1;
-      mask  = movemask_epi8(m.blocks[iblock] == block1);
-    }
+template <class T> inline bool generator_iter<T>::move_next(){
+  while (!mask){
+    iblock++;
+    if (iblock > bound) return false;
+    gen = (iblock << 4) - 1;
+    mask  = movemask_epi8(m.blocks[iblock] == block1);
+  }
   unsigned char shift = __bsfd (mask) + 1; // Bit Scan Forward
   gen += shift;
   mask >>= shift;
@@ -185,8 +180,7 @@ template <class T> inline bool generator_iter<T>::move_next()
 
 
 inline __attribute__((always_inline))
-void copy_blocks(dec_blocks &dst, dec_blocks const &src)
-{
+void copy_blocks(dec_blocks &dst, dec_blocks const &src){
   for (ind_t i=0; i<NBLOCKS; i++) dst[i] = src[i];
 }
 
@@ -194,11 +188,10 @@ void copy_blocks(dec_blocks &dst, dec_blocks const &src)
 #include <cassert>
 
 inline __attribute__((always_inline))
-void remove_generator(monoid &__restrict__ dst,
-		      const monoid &__restrict__ src,
+void remove_generator(Semigroup &__restrict__ dst,
+		      const Semigroup &__restrict__ src,
 		      ind_t gen,
-		      ind_t pos)
-{
+		      ind_t pos){
   ind_t start_block, decal;
   epi8 block;
 
@@ -207,8 +200,15 @@ void remove_generator(monoid &__restrict__ dst,
   ind_t t=gen+1;
   dst.conductor = t;
   dst.genus = src.genus + 1;
-  dst.min=src.min;
-  int delta=(src.decs[gen+src.min]==2)?0:-1;
+  int delta;
+  if(gen==src.min){
+    dst.min=gen+1;
+    delta=1;
+  }
+  else{
+    dst.min=src.min;
+    delta=(src.decs[gen+src.min]==2)?0:-1;
+  }
   dst.e=src.e+delta;
   assert(dst.e==((gen==src.min)?src.e+1:((src.decs[gen+src.min]==2)?src.e:src.e-1)));
   ind_t k=gen-src.conductor;
@@ -226,21 +226,18 @@ void remove_generator(monoid &__restrict__ dst,
   dst.blocks[start_block] -= ((block != zero) & block1);
 
 
-  for (auto i=start_block+1; i<NBLOCKS; i++)
-    {
+  for (auto i=start_block+1; i<NBLOCKS; i++){
       // The following won't work due to some alignment problem (bug in GCC 4.7.1?)
       // block = *((epi8*)(src.decs + ((i-start_block)<<4) - decal));
       block = load_unaligned_epi8(src.decs + ((i-start_block)<<4) - decal);
       dst.blocks[i] -= ((block != zero) & block1);
     }
-
-
   assert(dst.decs[dst.conductor-1] == 0);
 }
 
-inline monoid remove_generator(const monoid &src, ind_t gen,ind_t pos)
-{
-  monoid dst;
+inline Semigroup
+remove_generator(const Semigroup &src, ind_t gen,ind_t pos){
+  Semigroup dst;
   remove_generator(dst, src, gen,pos);
   return dst;
 }

c++/stack.hpp

@@ -0,0 +1,37 @@
+#include "semigroup.hpp"
+
+#define STACK_SIZE (MAX_GENUS*(MAX_GENUS+1))/2
+
+class Stack{
+public:
+  Semigroup data[STACK_SIZE+1], *stack[STACK_SIZE], *other;
+  size_t stack_size;
+  Stack();
+  Semigroup* pop();
+  Semigroup* pushed();
+  bool is_empty();
+};
+
+
+inline
+Stack::Stack(){
+  for (ind_t i=0; i<STACK_SIZE; i++) stack[i] = &(data[i]);
+  other=&data[STACK_SIZE];
+  stack_size=0;
+}
+
+inline Semigroup*
+Stack::pop(){
+  swap(stack[--stack_size],other);
+  return other;
+}
+
+inline Semigroup*
+Stack::pushed(){
+  return stack[stack_size++];
+};
+
+inline bool
+Stack::is_empty(){
+  return stack_size==0;
+}

c++/treewalk.cpp

@@ -0,0 +1,128 @@
+#include <iostream>
+#include <iomanip>
+#include <chrono>
+#include <cmath>
+#include <cpuid.h>
+#include <fstream>
+#include <csignal>
+#include <unistd.h>
+
+#include "treewalk.hpp"
+
+using namespace std;
+using namespace std::chrono;
+
+
+fstream file_out;
+bool checkpoint;
+bool stack_correct;
+#define SIGNAL_CHECKPOINT SIGUSR2
+
+
+void signal_checkpoint_handler(int signum){
+  checkpoint=true;
+}
+
+void treat(const Semigroup& m){
+  int q=ceil(float(m.conductor)/float(m.min));
+  unsigned int rho=q*m.min-m.conductor;
+  if(m.wilf<=rho){
+    if((m.wilf<0) or (m.wilf<=rho and m.e>2 and m.left_primitive>1 and q>=4)){
+      output(m,file_out);
+    }
+  }
+}
+
+
+void walk(Stack& stack){
+  Semigroup *current,*son;
+  Semigroup temp;
+  while(not stack.is_empty() and not checkpoint){
+    current = stack.pop();
+    if(not cut(*current)){
+      if(current->genus < MAX_GENUS - 1){
+	auto it=generator_iter<CHILDREN>(*current);
+	ind_t pos=0;
+	while (it.move_next()){
+	  son=stack.pushed();
+	  remove_generator(*son, *current, it.get_gen(),pos++);
+	  treat(*son);
+	}
+      }
+      else{
+	auto it = generator_iter<CHILDREN>(*current);
+	ind_t pos=0;
+	while (it.move_next()){
+	  remove_generator(temp, *current, it.get_gen(),pos++);
+	  treat(temp);
+	}
+      }
+    }
+  }
+}
+
+
+int main(int argc, char **argv){
+  if(argc!=2){
+    cerr<<"Usage : "<<argv[0]<<" tasks/task_file"<<endl;
+    exit(-1);
+  }
+  char* task_filename=argv[1];
+  unsigned int ax, bx, cx, dx;
+  if (!__get_cpuid(0x00000001, &ax, &bx, &cx, &dx)){
+    cerr << "Unable to determine the processor type !" << endl;
+    return EXIT_FAILURE;
+  }
+  if (!(cx & bit_SSSE3)){
+    cerr << "This programm require sse3 instructions set !" << endl;
+    return EXIT_FAILURE;
+  }
+  if (!(cx & bit_POPCNT)){
+    cerr << "This programm require popcount instruction !" << endl;
+    return EXIT_FAILURE;
+  }
+  fstream file_in;
+  file_in.open(task_filename,ios::in|ios::binary);
+  string filename=string("tasks/")+task_filename;
+  filename+="-out";
+  file_out.open(filename,ios::out|ios::trunc);
+  Stack stack;
+  char d[3*MAX_GENUS+1];
+  char c,g,m;
+  size_t n;
+  file_in.read((char*)&n,8);
+  cout<<"Stack size = "<<n<<endl;
+  for(size_t i=0;i<n;++i){
+    file_in.read(&c,1);
+    file_in.read(&g,1);
+    file_in.read(&m,1);
+    file_in.read(d,3*MAX_GENUS+1);
+    Semigroup* S=stack.pushed();
+    init(*S,c,g,m,d);
+    treat(*S);
+  }
+  file_in.close();
+  checkpoint=false;
+  signal(SIGNAL_CHECKPOINT, signal_checkpoint_handler);
+  walk(stack);
+
+  file_out.close();
+  if(checkpoint){
+    cout<<"Stoping exploration due to checkpoint signal reception."<<endl;
+    filename=string("tasks/checkpoint/")+task_filename+string("-checkpoint");
+    fstream file_stack;
+    file_stack.open(filename.c_str(),ios::out|ios::binary);
+    size_t size=stack.stack_size;
+    file_stack.write((char*)(&size),8);
+    cout<<"Checkpoint size : "<<size<<endl;
+    for(size_t i=0;i<size;++i){
+      record(*stack.stack[i],file_stack);
+    }
+    file_stack.close();
+    return 1;
+  }
+  else{
+    return 0;
+  }
+}
+

c++/treewalk.hpp

@@ -0,0 +1,13 @@
+#include "semigroup.hpp"
+#include "stack.hpp"
+
+bool cut(const Semigroup& m);
+void treat(const Semigroup& m);
+void walk(Stack& stack);
+void signal_checkpoint_handler(int signum);
+
+inline bool
+cut(const Semigroup& m){
+  if(3*m.left_primitive>=m.min) return true;
+  return false;
+}

genus

@@ -0,0 +1 @@
+40

oar/param

@@ -0,0 +1,621 @@
+task_3_0
+task_3_1
+task_3_2
+task_3_3
+task_3_4
+task_3_5
+task_3_6
+task_3_7
+task_3_8
+task_3_9
+task_3_10
+task_3_11
+task_3_12
+task_3_13
+task_3_14
+task_3_15
+task_3_16
+task_3_17
+task_3_18
+task_3_19
+task_3_20
+task_3_21
+task_3_22
+task_3_23
+task_3_24
+task_3_25
+task_3_26
+task_3_27
+task_3_28
+task_3_29
+task_3_30
+task_3_31
+task_3_32
+task_3_33
+task_3_34
+task_3_35
+task_3_36
+task_3_37
+task_4_0
+task_4_1
+task_4_2
+task_4_3
+task_4_4
+task_4_5
+task_4_6
+task_4_7
+task_4_8
+task_4_9
+task_4_10
+task_4_11
+task_4_12
+task_4_13
+task_4_14
+task_4_15
+task_4_16
+task_4_17
+task_4_18
+task_4_19
+task_4_20
+task_4_21
+task_4_22
+task_4_23
+task_4_24
+task_4_25
+task_4_26
+task_4_27
+task_4_28
+task_4_29
+task_4_30
+task_4_31
+task_4_32
+task_4_33
+task_4_34
+task_4_35
+task_4_36
+task_5_0
+task_5_1
+task_5_2
+task_5_3
+task_5_4
+task_5_5
+task_5_6
+task_5_7
+task_5_8
+task_5_9
+task_5_10
+task_5_11
+task_5_12
+task_5_13
+task_5_14
+task_5_15
+task_5_16
+task_5_17
+task_5_18
+task_5_19
+task_5_20
+task_5_21
+task_5_22
+task_5_23
+task_5_24
+task_5_25
+task_5_26
+task_5_27
+task_5_28
+task_5_29
+task_5_30
+task_5_31
+task_5_32
+task_5_33
+task_5_34
+task_5_35
+task_6_0
+task_6_1
+task_6_2
+task_6_3
+task_6_4
+task_6_5
+task_6_6
+task_6_7
+task_6_8
+task_6_9
+task_6_10
+task_6_11
+task_6_12
+task_6_13
+task_6_14
+task_6_15
+task_6_16
+task_6_17
+task_6_18
+task_6_19
+task_6_20
+task_6_21
+task_6_22
+task_6_23
+task_6_24
+task_6_25
+task_6_26
+task_6_27
+task_6_28
+task_6_29
+task_6_30
+task_6_31
+task_6_32
+task_6_33
+task_6_34
+task_7_0
+task_7_1
+task_7_2
+task_7_3
+task_7_4
+task_7_5
+task_7_6
+task_7_7
+task_7_8
+task_7_9
+task_7_10
+task_7_11
+task_7_12
+task_7_13
+task_7_14
+task_7_15
+task_7_16
+task_7_17
+task_7_18
+task_7_19
+task_7_20
+task_7_21
+task_7_22
+task_7_23
+task_7_24
+task_7_25
+task_7_26
+task_7_27
+task_7_28
+task_7_29
+task_7_30
+task_7_31
+task_7_32
+task_7_33
+task_8_0
+task_8_1
+task_8_2
+task_8_3
+task_8_4
+task_8_5
+task_8_6
+task_8_7
+task_8_8
+task_8_9
+task_8_10
+task_8_11
+task_8_12
+task_8_13
+task_8_14
+task_8_15
+task_8_16
+task_8_17
+task_8_18
+task_8_19
+task_8_20
+task_8_21
+task_8_22
+task_8_23
+task_8_24
+task_8_25
+task_8_26
+task_8_27
+task_8_28
+task_8_29
+task_8_30
+task_8_31
+task_8_32
+task_9_0
+task_9_1
+task_9_2
+task_9_3
+task_9_4
+task_9_5
+task_9_6
+task_9_7
+task_9_8
+task_9_9
+task_9_10
+task_9_11
+task_9_12
+task_9_13
+task_9_14
+task_9_15
+task_9_16
+task_9_17
+task_9_18
+task_9_19
+task_9_20
+task_9_21
+task_9_22
+task_9_23
+task_9_24
+task_9_25
+task_9_26
+task_9_27
+task_9_28
+task_9_29
+task_9_30
+task_9_31
+task_10_0
+task_10_1
+task_10_2
+task_10_3
+task_10_4
+task_10_5
+task_10_6
+task_10_7
+task_10_8
+task_10_9
+task_10_10
+task_10_11
+task_10_12
+task_10_13
+task_10_14
+task_10_15
+task_10_16
+task_10_17
+task_10_18
+task_10_19
+task_10_20
+task_10_21
+task_10_22
+task_10_23
+task_10_24
+task_10_25
+task_10_26
+task_10_27
+task_10_28
+task_10_29
+task_10_30
+task_11_0
+task_11_1
+task_11_2
+task_11_3
+task_11_4
+task_11_5
+task_11_6
+task_11_7
+task_11_8
+task_11_9
+task_11_10
+task_11_11
+task_11_12
+task_11_13
+task_11_14
+task_11_15
+task_11_16
+task_11_17
+task_11_18
+task_11_19
+task_11_20
+task_11_21
+task_11_22
+task_11_23
+task_11_24
+task_11_25
+task_11_26
+task_11_27
+task_11_28
+task_11_29
+task_12_0
+task_12_1
+task_12_2
+task_12_3
+task_12_4
+task_12_5
+task_12_6
+task_12_7
+task_12_8
+task_12_9
+task_12_10
+task_12_11
+task_12_12
+task_12_13
+task_12_14
+task_12_15
+task_12_16
+task_12_17
+task_12_18
+task_12_19
+task_12_20
+task_12_21
+task_12_22
+task_12_23
+task_12_24
+task_12_25
+task_12_26
+task_12_27
+task_12_28
+task_13_0
+task_13_1
+task_13_2
+task_13_3
+task_13_4
+task_13_5
+task_13_6
+task_13_7
+task_13_8
+task_13_9
+task_13_10
+task_13_11
+task_13_12
+task_13_13
+task_13_14
+task_13_15
+task_13_16
+task_13_17
+task_13_18
+task_13_19
+task_13_20
+task_13_21
+task_13_22
+task_13_23
+task_13_24
+task_13_25
+task_13_26
+task_13_27
+task_14_0
+task_14_1
+task_14_2
+task_14_3
+task_14_4
+task_14_5
+task_14_6
+task_14_7
+task_14_8
+task_14_9
+task_14_10
+task_14_11
+task_14_12
+task_14_13
+task_14_14
+task_14_15
+task_14_16
+task_14_17
+task_14_18
+task_14_19
+task_14_20
+task_14_21
+task_14_22
+task_14_23
+task_14_24
+task_14_25
+task_14_26
+task_15_0
+task_15_1
+task_15_2
+task_15_3
+task_15_4
+task_15_5
+task_15_6
+task_15_7
+task_15_8
+task_15_9
+task_15_10
+task_15_11
+task_15_12
+task_15_13
+task_15_14
+task_15_15
+task_15_16
+task_15_17
+task_15_18
+task_15_19
+task_15_20
+task_15_21
+task_15_22
+task_15_23
+task_15_24
+task_15_25
+task_16_0
+task_16_1
+task_16_2
+task_16_3
+task_16_4
+task_16_5
+task_16_6
+task_16_7
+task_16_8
+task_16_9
+task_16_10
+task_16_11
+task_16_12
+task_16_13
+task_16_14
+task_16_15
+task_16_16
+task_16_17
+task_16_18
+task_16_19
+task_16_20
+task_16_21
+task_16_22
+task_16_23
+task_16_24
+task_17_0
+task_17_1
+task_17_2
+task_17_3
+task_17_4
+task_17_5
+task_17_6
+task_17_7
+task_17_8
+task_17_9
+task_17_10
+task_17_11
+task_17_12
+task_17_13
+task_17_14
+task_17_15
+task_17_16
+task_17_17
+task_17_18
+task_17_19
+task_17_20
+task_17_21
+task_17_22
+task_17_23
+task_18_0
+task_18_1
+task_18_2
+task_18_3
+task_18_4
+task_18_5
+task_18_6
+task_18_7
+task_18_8
+task_18_9
+task_18_10
+task_18_11
+task_18_12
+task_18_13
+task_18_14
+task_18_15
+task_18_16
+task_18_17
+task_18_18
+task_18_19
+task_18_20
+task_18_21
+task_18_22
+task_19_0
+task_19_1
+task_19_2
+task_19_3
+task_19_4
+task_19_5
+task_19_6
+task_19_7
+task_19_8
+task_19_9
+task_19_10
+task_19_11
+task_19_12
+task_19_13
+task_19_14
+task_19_15
+task_19_16
+task_19_17
+task_19_18
+task_19_19
+task_19_20
+task_19_21
+task_20_0
+task_20_1
+task_20_2
+task_20_3
+task_20_4
+task_20_5
+task_20_6
+task_20_7
+task_20_8
+task_20_9
+task_20_10
+task_20_11
+task_20_12
+task_20_13
+task_20_14
+task_20_15
+task_20_16
+task_20_17
+task_20_18
+task_20_19
+task_20_20
+task_21_0
+task_21_1
+task_21_2
+task_21_3
+task_21_4
+task_21_5
+task_21_6
+task_21_7
+task_21_8
+task_21_9
+task_21_10
+task_21_11
+task_21_12
+task_21_13
+task_21_14
+task_21_15
+task_21_16
+task_21_17
+task_21_18
+task_21_19
+task_22_0
+task_22_1
+task_22_2
+task_22_3
+task_22_4
+task_22_5
+task_22_6
+task_22_7
+task_22_8
+task_22_9
+task_22_10
+task_22_11
+task_22_12
+task_22_13
+task_22_14
+task_22_15
+task_22_16
+task_22_17
+task_22_18
+task_23_0
+task_23_1
+task_23_2
+task_23_3
+task_23_4
+task_23_5
+task_23_6
+task_23_7
+task_23_8
+task_23_9
+task_23_10
+task_23_11
+task_23_12
+task_23_13
+task_23_14
+task_23_15
+task_23_16
+task_23_17
+task_24_0
+task_24_1
+task_24_2
+task_24_3
+task_24_4
+task_24_5
+task_24_6
+task_24_7
+task_24_8
+task_24_9
+task_24_10
+task_24_11
+task_24_12
+task_24_13
+task_24_14
+task_24_15
+task_24_16
+task_25_0
+task_25_1
+task_25_2
+task_25_3
+task_25_4
+task_25_5
+task_25_6
+task_25_7
+task_25_8
+task_25_9
+task_25_10
+task_25_11
+task_25_12
+task_25_13
+task_25_14
+task_25_15

oar_wilf.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+#OAR -l core=1,walltime=1:00:00
+#OAR -t idempotent
+#OAR -q besteffort
+#OAR -t besteffort
+#OAR --array-param-file oar/param
+#OAR -O oar/output/j%jobid%
+#OAR -E oar/error/j%jobid%
+cd /nfs/home/lmpa/jfromentin/wilf
+./wilf tasks/$*
+mv tasks/$* tasks/donemv tasks/$*-out tasks/out

scripts/build.py

@@ -0,0 +1,124 @@
+import sys
+import os
+
+global gmax
+
+def byte(x):
+    return x.to_bytes(1,sys.byteorder)
+
+class SemiGroup:
+    def __init__(self,parent=None,x=None):
+        if parent==None and x==None:
+            self.m=1
+            self.c=1
+            self.g=0
+            self.d=bytearray(3*gmax+1)
+            for i in range(3*gmax+1):
+                self.d[i]=1+int(i/2)
+        elif parent!=None and x==None:
+            self.m=parent
+            self.c=self.m
+            self.g=self.m-1
+            self.d=bytearray(3*gmax+1)
+            self.d[0]=1
+            for i in range(1,2*self.m):
+                self.d[i]=int(i/self.m)
+            for i in range(3*gmax+1-2*self.m):
+                self.d[i+2*self.m]=2+int(i/2)
+        elif parent!=None and x!=None:
+            if not parent.is_valid_irreductible(x):
+                raise AttributeError("x is not irreducible")
+            if x<parent.c:
+                raise AttributeError("x is not effective")
+       
+            if parent.m==x:
+                self.delta=1
+                self.m=x+1
+            else:
+                if parent.d[x+parent.m]==2:
+                    self.delta=0
+                else:
+                    self.delta=-1
+            self.g=parent.g+1
+            self.m=parent.m
+            self.c=x+1
+            self.d=bytearray(3*gmax+1)
+            for y in range(x):
+                self.d[y]=parent.d[y]
+            self.d[x]=0
+            for y in range(x+1,3*gmax+1):
+                self.d[y]=parent.d[y]-min(1,parent.d[y-x])
+            
+    def __repr__(self):
+        res='<'
+        first=True
+        for i in range(self.m,self.m+self.c+1):
+            if self.d[i]==1:
+                if not first:
+                    res+=','
+                res+=repr(i)
+                first=False
+        return res+'>'+' g='+repr(self.g)
+
+    def is_valid_irreductible(self,x):
+        if x<0 or x>3*gmax:
+            raise AttributeError("x is out of range")
+        return self.d[x]==1 and x!=self.m
+
+    def split_sons(self):
+        first=None
+        other=[]
+        for x in range(self.c,self.c+self.m):
+            if self.is_valid_irreductible(x):
+                if first==None:
+                    first=SemiGroup(self,x)
+                else:
+                    other.append(SemiGroup(self,x))
+        return (first,other)
+
+    def record(self,file):
+        file.write(byte(self.c))
+        file.write(byte(S.g))
+        file.write(byte(S.m))
+        file.write(self.d)
+        
+if __name__=="__main__":
+    file=open("genus","r")
+    gmax=int(file.readline())
+    file.close()
+    print("Generate wilf program ...")
+    os.system("cd c++;make;cd ..")
+    print("Generate OAR tasks for cutted explorations of numerical semigroup up to genus",gmax,"...")
+    mmax=int((3*(gmax+2))/5)
+    param_file=open("oar/param","w")
+    for m in range(3,mmax+1):
+        S=SemiGroup(m)
+        for k in range(gmax-m+1):
+            (S,Others)=S.split_sons()
+            task_filename="task_"+repr(m)+"_"+repr(k)
+            task_file=open("tasks/"+task_filename,"wb")
+            task_file.write(len(Others).to_bytes(8,sys.byteorder))
+            task_file.write(byte(S.g))
+            task_file.write(byte(S.m))
+            for T in Others:
+                T.record(task_file)
+            task_file.close()
+            param_file.write(task_filename+"\n")
+    param_file.close()
+    print("Generate OAR script ...")
+    file=open("oar_wilf.sh",'w')
+    file.write("#!/bin/sh\n")
+    file.write("#OAR -l core=1,walltime=1:00:00\n")
+    file.write("#OAR -t idempotent\n")
+    file.write("#OAR -q besteffort\n")
+    file.write("#OAR -t besteffort\n")
+    file.write("#OAR --array-param-file oar/param\n")
+    file.write("#OAR -O oar/output/j%jobid%\n")
+    file.write("#OAR -E oar/error/j%jobid%\n")
+    file.write("cd /nfs/home/lmpa/jfromentin/wilf\n")
+    file.write("./wilf tasks/$*\n")
+    file.write("mv tasks/$* tasks/done")
+    file.write("mv tasks/$*-out tasks/out")
+    file.close()
+            
+        

scripts/build.py~

@@ -0,0 +1,122 @@
+import sys
+
+global gmax
+
+def byte(x):
+    return x.to_bytes(1,sys.byteorder)
+
+class SemiGroup:
+    def __init__(self,parent=None,x=None):
+        if parent==None and x==None:
+            self.m=1
+            self.c=1
+            self.g=0
+            self.d=bytearray(3*gmax+1)
+            for i in range(3*gmax+1):
+                self.d[i]=1+int(i/2)
+        elif parent!=None and x==None:
+            self.m=parent
+            self.c=self.m
+            self.g=self.m-1
+            self.d=bytearray(3*gmax+1)
+            self.d[0]=1
+            for i in range(1,2*self.m):
+                self.d[i]=int(i/self.m)
+            for i in range(3*gmax+1-2*self.m):
+                self.d[i+2*self.m]=2+int(i/2)
+        elif parent!=None and x!=None:
+            if not parent.is_valid_irreductible(x):
+                raise AttributeError("x is not irreducible")
+            if x<parent.c:
+                raise AttributeError("x is not effective")
+       
+            if parent.m==x:
+                self.delta=1
+                self.m=x+1
+            else:
+                if parent.d[x+parent.m]==2:
+                    self.delta=0
+                else:
+                    self.delta=-1
+            self.g=parent.g+1
+            self.m=parent.m
+            self.c=x+1
+            self.d=bytearray(3*gmax+1)
+            for y in range(x):
+                self.d[y]=parent.d[y]
+            self.d[x]=0
+            for y in range(x+1,3*gmax+1):
+                self.d[y]=parent.d[y]-min(1,parent.d[y-x])
+            
+    def __repr__(self):
+        res='<'
+        first=True
+        for i in range(self.m,self.m+self.c+1):
+            if self.d[i]==1:
+                if not first:
+                    res+=','
+                res+=repr(i)
+                first=False
+        return res+'>'+' g='+repr(self.g)
+
+    def is_valid_irreductible(self,x):
+        if x<0 or x>3*gmax:
+            raise AttributeError("x is out of range")
+        return self.d[x]==1 and x!=self.m
+
+    def split_sons(self):
+        first=None
+        other=[]
+        for x in range(self.c,self.c+self.m):
+            if self.is_valid_irreductible(x):
+                if first==None:
+                    first=SemiGroup(self,x)
+                else:
+                    other.append(SemiGroup(self,x))
+        return (first,other)
+
+    def record(self,file):
+        file.write(byte(self.c))
+        file.write(byte(S.g))
+        file.write(byte(S.m))
+        file.write(self.d)
+        
+if __name__=="__main__":
+    file=open("genus","r")
+    gmax=int(file.readline())
+    file.close()
+    print("Generate OAR tasks for cutted explorations of numerical semigroup up to genus",gmax,"...")
+    mmax=int((3*(gmax+2))/5)
+    param_file=open("oar/param")
+    for m in range(3,mmax+1):
+        S=SemiGroup(m)
+        for k in range(gmax-m+1):
+            (S,Others)=S.split_sons()
+            task_filename="task_"+repr(m)+"_"+repr(k)
+            task_file=open("tasks/"+task_filename,"wb")
+            task_file.write(len(Others).to_bytes(8,sys.byteorder))
+            task_file.write(byte(S.g))
+            task_file.write(byte(S.m))
+            for T in Others:
+                T.record(task_file)
+            task_file.close()
+            param_file.write(task_filename+"\n")
+    param_file.close()
+    print("Generate OAR script ...")
+    
+    file=open("oar_wilf.sh",'w')
+    file.write("#!/bin/sh\n")
+    file.write("#OAR -l core=1,walltime=1:00:00\n")
+    file.write("#OAR -t idempotent\n")
+    file.write("#OAR -q besteffort\n")
+    file.write("#OAR -t besteffort\n")
+    file.write("#OAR --array-param-file oar/param\n")
+    file.write("#OAR -O oar/output/j%jobid%\n")
+    file.write("#OAR -E oar/error/j%jobid%\n")
+    file.write("cd /nfs/home/lmpa/jfromentin/wilf\n")
+    file.write("./wilf tasks/$*\n")
+    file.write("mv tasks/$* tasks/done")
+    file.write("mv tasks/$*-out tasks/out")
+    file.close()
+            
+        

scripts/clean.py

@@ -0,0 +1,10 @@
+import sys
+import os
+
+if __name__=="__main__":
+    os.system("cd c++;make clean;cd ..")
+    os.system("rm oar/output/j*")
+    os.system("rm oar/error/j*")
+    os.system("rm tasks/t*")
+    os.system("rm tasks/done/t*")
+    os.system("rm tasks/todo/t*")

single/cluster.py

@@ -23,8 +23,8 @@ if __name__=="__main__":
     file.write("#OAR -q besteffort\n")
     file.write("#OAR -t besteffort\n")
     file.write("#OAR --array-param-file output/param_"+repr(g)+"\n")
-    file.write("#OAR -O output/job.%jobid%.output\n")
-    file.write("#OAR -E output/job.%jobid%.error\n")
+    file.write("#OAR -O oar/output/job_%jobid%\n")
+    file.write("#OAR -E oar/error/job_%jobid%\n")
     file.write("cd /nfs/home/lmpa/jfromentin/wilf/single\n")
     file.write("./wilf $* output/$OAR_JOBID\n")
     file.write("mv output/$OAR_JOBID*wilf* output/done/\n")

single/treewalk.cpp

@@ -1,159 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include <chrono>
-#include <cmath>
-#include <cpuid.h>
-#include <fstream>
-#include "treewalk.hpp"
-
-using namespace std;
-using namespace std::chrono;
-
-
-fstream file;
-
-
-void treat(const monoid& m){
-  //  output(m,file);
-  //return;
-  //  int w=m.e*m.left-m.conductor;
-  int q=ceil(float(m.conductor)/float(m.min));
-  unsigned int rho=q*m.min-m.conductor;
-  if(m.wilf<=rho){
-    if((m.wilf<0) or (m.wilf<=rho and m.e>2 and m.left_primitive>1 and q>=4)){
-      output(m,file);
-    }
-  }
-}
-
-//static const int mcut=ceil(float(3*(MAX_GENUS+2))/5);
-
-bool cut(const monoid& m){
-  if(3*m.left_primitive>=m.min) return true;
-  return false;
-}
-
-
-#define STACK_SIZE (MAX_GENUS*(MAX_GENUS+1))/2
-void walk(int m,int k)
-{
-  monoid data[STACK_SIZE], *stack[STACK_SIZE], *current,temp,temp2;
-  size_t stack_size=0;
-  for (ind_t i=0; i<STACK_SIZE; i++) stack[i] = &(data[i]); 
-  init_ordinary(data[0],m);
-  for(int i=0;i<k;++i){
-    auto it = generator_iter<CHILDREN>(data[i]);
-    it.move_next();
-    ind_t pos=0;
-    if(i==0){
-      it.move_next();
-      pos=1;
-    }
-    remove_generator(data[i+1],data[i],it.get_gen(),pos);
-  }
-  //Root @ data[k]
-  temp=data[k];
-  cout<<"Root : ";
-  print_monoid_gen(temp);
-  
-  auto it = generator_iter<CHILDREN>(temp);
-  it.move_next();
-  ind_t pos=0;
-  if(k==0){
-    it.move_next();
-    ++pos;
-  }
-  while (it.move_next()){
-    remove_generator(*stack[stack_size], temp, it.get_gen(),pos++);
-    cout<<"Pop "<<it.get_gen()<<" : ";
-    print_monoid_gen(*stack[stack_size]);
-    treat(*stack[stack_size]);
-    ++stack_size;
-  }
-  while (stack_size != 0)
-    {
-      current = stack[--stack_size];
-      /*if(current->conductor>=35){
-	cout<<"Pop ";
-	print_monoid_gen(*current);
-	}*/
-      
-      if(not cut(*current))
-	{
-	  if (current->genus < MAX_GENUS - 1)
-	    {
-	      auto it = generator_iter<CHILDREN>(*current);
-	      ind_t pos=0;
-	      while (it.move_next())
-		{
-		  swap(stack[stack_size],stack[stack_size+1]);
-		  //Current is tored @ stack_size+1
-		  remove_generator(*stack[stack_size], *current, it.get_gen(),pos++);
-		  treat(*stack[stack_size]);
-		  ++stack_size;
-		}
-	      
-	    }
-	  else
-	    {
-	      auto it = generator_iter<CHILDREN>(*current);
-	      ind_t pos=0;
-	      while (it.move_next())
-		{
-		  remove_generator(temp2, *current, it.get_gen(),pos++);
-		  temp2.conductor=0;
-		  treat(temp2);
-		}
-	    }
-	}
-    }
-}
-
-
-
-int main(int argc, char **argv)
-{
-  if(argc!=4){
-    cerr<<"Usage : "<<argv[0]<<" [m] [k] filename with k in [0,MAX_GENUS-m]"<<endl;
-    exit(-1);
-  }
-  int m=atoi(argv[1]);
-  int k=atoi(argv[2]);
-  char* filename_base=argv[3];
-  if(k<0 or k>=MAX_GENUS-m){
-    cerr<<"k must be in [0,MAX_GENUS-m]"<<endl;
-    exit(-2);
-  }
-  unsigned int ax, bx, cx, dx;
-  if (!__get_cpuid(0x00000001, &ax, &bx, &cx, &dx))
-    {
-      cerr << "Unable to determine the processor type !" << endl;
-      return EXIT_FAILURE;
-    }
-  if (!(cx & bit_SSSE3))
-    {
-      cerr << "This programm require sse3 instructions set !" << endl;
-      return EXIT_FAILURE;
-    }
-  if (!(cx & bit_POPCNT))
-    {
-      cerr << "This programm require popcount instruction !" << endl;
-      return EXIT_FAILURE;
-    }
-
- 
-  cout << "Testing Wilf's conjecture for numerical semigroups of genus <= "
-       << MAX_GENUS << " for m="<<m<<" and k="<<k<<"."<<endl;
-  /*cerr << "Testing Wilf's conjecture for numerical semigroups of genus <= "
-    << MAX_GENUS << " for m="<<m<<" and k="<<k<<"."<<endl;*/
-  auto begin = high_resolution_clock::now();
-  string filename=string(filename_base)+"_wilf_"+to_string(m)+"_"+to_string(k);
-  file.open(filename.c_str(),ios::out|ios::trunc);
-  walk(m,k);
-  auto end = high_resolution_clock::now();
-  duration<double> ticks = end-begin;
-  cout << " Computation time = " << std::setprecision(4) << ticks.count() << " s."  << endl;
-  file.close();
-  return EXIT_SUCCESS;
-}
-

single/treewalk.hpp

@@ -1,4 +0,0 @@
-#include "monoid.hpp"
-
-void walk(int m,int k);
-