Move old version

old/c++/Makefile

@@ -0,0 +1,26 @@
+# 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
+
+
+
+# Pour compiler avec une valeur différente: make MAX_GENUS=35
+#DEFAULT_MAX_GENUS=40
+#MAX_GENUS=$(DEFAULT_MAX_GENUS)
+
+all: $(TARGET)
+
+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:
+	rm -rf $(TARGET) *.o *~ 
+
+

old/c++/semigroup.cpp

@@ -0,0 +1,115 @@
+#include <iostream>
+#include <cstring>
+#include "semigroup.hpp"
+
+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;
+    block = block + 8;
+  }
+  m.genus = 0;
+  m.conductor = 1;
+  m.min = 1;
+  m.left=1;
+  m.left_primitive=0;
+  m.e=1;
+  m.wilf=0;
+}
+
+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;
+  }
+  for(auto i=0;i<SIZE-2*m;++i){
+    O.decs[2*m+i]=2+i/2;
+  }
+			     
+  O.genus = m-1;
+  O.conductor = m;
+  O.min = m;
+  O.left=1;
+  O.left_primitive=0;
+  O.e=m;
+  O.wilf=0;
+}
+
+void print_Semigroup(const Semigroup &m)
+{
+  unsigned int i;
+  std::cout<<"min = "<<m.min<<", cond = "<<m.conductor<<", genus = "<<m.genus<<", decs = ";
+  for (i=0; i<SIZE; i++) std::cout<<((int) m.decs[i])<<' ';
+  std::cout<<std::endl;
+}
+
+void print_Semigroup_gen(const Semigroup &m)
+{
+  unsigned int i;
+  std::cout<<"m = "<<m.min<<", c = "<<m.conductor<<", g = "<<m.genus<<" w = "<<m.wilf<<" ";
+  std::cout<<"< ";
+  for (i=1; i<SIZE; i++){
+    if(m.decs[i]==1){
+      std::cout<<i<<' ';
+    }
+  }
+  std::cout<<'>'<<std::endl;
+}
+
+#include <cmath>
+
+
+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;
+  for (auto i=m.min+1; i<SIZE; i++){
+    if(m.decs[i]==1){
+      f<<','<<i;
+    }
+  }
+  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;
+  for (i=0; i<16; i++) std::cout<<((uint8_t*)&bl)[i]<<' ';
+  std::cout<<std::endl;
+}

old/c++/semigroup.hpp

@@ -0,0 +1,245 @@
+#ifndef SEMIGROUP_HPP
+#define SEMIGROUP_HPP
+
+#include <cstdint>
+#include <fstream>
+
+// We cant have those as C++ constant because of the #define used below in
+// remove_generator manual loop unrolling. I don't know if the unrolling is
+// doable using template metaprogamming. I didn't manage to figure out how.
+
+#ifndef MAX_GENUS
+#error "Please define the MAX_GENUS macro"
+#endif
+#define SIZE_BOUND (3*(MAX_GENUS-1))
+#define NBLOCKS ((SIZE_BOUND+15) >> 4)
+#define SIZE (NBLOCKS << 4)
+// const uint_fast8_t MAX_GENUS = 40;
+// const uint_fast8_t SIZE_BOUND = (3*(MAX_GENUS-1));
+// const uint_fast8_t NBLOCKS = ((SIZE_BOUND+15) >> 4);
+// const uint_fast8_t SIZE = (NBLOCKS << 4);
+
+#include <x86intrin.h>
+
+typedef uint8_t epi8 __attribute__ ((vector_size (16)));
+typedef uint8_t dec_numbers[SIZE] __attribute__ ((aligned (16)));
+typedef epi8 dec_blocks[NBLOCKS];
+typedef uint_fast64_t ind_t;  // The type used for array indexes
+
+using namespace std;
+
+struct Semigroup
+{
+  union {
+    dec_numbers decs;
+    dec_blocks blocks;
+  };
+  // Dont use char as they have to be promoted to 64 bits to do pointer arithmetic.
+  ind_t conductor, min, genus,left_primitive,left,e,wilf;
+};
+
+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 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(Semigroup &__restrict__ dst,
+		      const Semigroup &__restrict__ 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;
+class ALL {};
+class CHILDREN {};
+
+// template <generator_type T> class generator_iter
+template <class T> class generator_iter{
+private:
+
+  const Semigroup &m;
+  unsigned int mask;   // movemask_epi8 returns a 32 bits values
+  ind_t iblock, gen, bound;
+
+public:
+
+  generator_iter(const Semigroup &mon);
+  bool move_next();
+  uint8_t count();
+  inline ind_t get_gen() const {return gen; };
+};
+
+
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+////////////////   Implementation part here for inlining   ////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+/*
+Note: for some reason the code using gcc vector variables is 2-3% faster than
+the code using gcc intrinsic instructions.
+Here are the results of two runs:
+data_mmx =  [9.757, 9.774, 9.757, 9.761, 9.811, 9.819, 9.765, 9.888, 9.774, 9.771]
+data_epi8 = [9.592, 9.535, 9.657, 9.468, 9.460, 9.679, 9.458, 9.461, 9.629, 9.474]
+*/
+
+extern inline epi8 load_unaligned_epi8(const uint8_t *t)
+{ return (epi8) _mm_loadu_si128((__m128i *) (t)); };
+
+extern inline epi8 shuffle_epi8(epi8 b, epi8 sh)    // Require SSE 3
+{ return (epi8) _mm_shuffle_epi8((__m128i) b, (__m128i) sh);}
+
+extern inline int movemask_epi8(epi8 b)
+{ return _mm_movemask_epi8((__m128i) b);};
+
+const epi8 zero   = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+const epi8 block1 = zero + 1;
+const uint8_t m1 = 255;
+const epi8 shift16[16] =
+  { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15},
+    {m1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14},
+    {m1,m1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13},
+    {m1,m1,m1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12},
+    {m1,m1,m1,m1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11},
+    {m1,m1,m1,m1,m1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10},
+    {m1,m1,m1,m1,m1,m1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+    {m1,m1,m1,m1,m1,m1,m1, 0, 1, 2, 3, 4, 5, 6, 7, 8},
+    {m1,m1,m1,m1,m1,m1,m1,m1, 0, 1, 2, 3, 4, 5, 6, 7},
+    {m1,m1,m1,m1,m1,m1,m1,m1,m1, 0, 1, 2, 3, 4, 5, 6},
+    {m1,m1,m1,m1,m1,m1,m1,m1,m1,m1, 0, 1, 2, 3, 4, 5},
+    {m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1, 0, 1, 2, 3, 4},
+    {m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1, 0, 1, 2, 3},
+    {m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1, 0, 1, 2},
+    {m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1, 0, 1},
+    {m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1, 0} };
+const epi8 mask16[16] =
+  { {m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0,m1,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0,m1,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0,m1,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0,m1,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,m1,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,m1,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,m1,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,m1,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,m1,m1},
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,m1} };
+
+
+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];
+  mask  = movemask_epi8(block == block1);
+  mask &= 0xFFFE; // 0 is not a generator
+  gen = - 1;
+};
+
+
+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];
+  mask  = movemask_epi8(block == block1);
+  gen = (iblock << 4) - 1;
+};
+
+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);
+  }
+  unsigned char shift = __bsfd (mask) + 1; // Bit Scan Forward
+  gen += shift;
+  mask >>= shift;
+  return true;
+};
+
+
+
+inline __attribute__((always_inline))
+void copy_blocks(dec_blocks &dst, dec_blocks const &src){
+  for (ind_t i=0; i<NBLOCKS; i++) dst[i] = src[i];
+}
+
+
+#include <cassert>
+
+inline __attribute__((always_inline))
+void remove_generator(Semigroup &__restrict__ dst,
+		      const Semigroup &__restrict__ src,
+		      ind_t gen,
+		      ind_t pos){
+  ind_t start_block, decal;
+  epi8 block;
+
+  assert(src.decs[gen] == 1);
+
+  ind_t t=gen+1;
+  dst.conductor = t;
+  dst.genus = src.genus + 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;
+  assert(dst.conductor==src.conductor+k+1);
+  dst.left=src.left+k;
+  dst.left_primitive=src.left_primitive+pos;
+  //dst.wilf=dst.e*dst.left-dst.conductor;//src.wilf+delta*(src.left+k)-k-1;
+  dst.wilf=src.wilf+delta*(src.left+k)+(src.e-1)*k-1;
+  copy_blocks(dst.blocks, src.blocks);
+
+  start_block = gen >> 4;
+  decal = gen & 0xF;
+  // Shift block by decal uchar
+  block = shuffle_epi8(src.blocks[0], shift16[decal]);
+  dst.blocks[start_block] -= ((block != zero) & block1);
+
+
+  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 Semigroup
+remove_generator(const Semigroup &src, ind_t gen,ind_t pos){
+  Semigroup dst;
+  remove_generator(dst, src, gen,pos);
+  return dst;
+}
+
+#endif

old/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;
+}

old/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;
+  }
+}
+

old/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;
+}

old/genus

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

old/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

old/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

old/scripts/build.py

@@ -0,0 +1,126 @@
+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 --checkpoint 60\n")
+    file.write("#OAR --signal 12\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()
+            
+        

old/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()
+            
+        

old/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*")

old/scripts/cluster.py

@@ -0,0 +1,32 @@
+import sys
+import os
+
+if __name__=="__main__":
+    if len(sys.argv)!=2:
+        print("Usage : python3 "+sys.argv[0]+" genus")
+        exit(-1)
+    g=int(sys.argv[1])
+    mmax=int((3*(g+2))/5)
+    n=0
+    os.system("make clean;make MAX_GENUS="+repr(g))
+    file=open("output/param_"+repr(g),'w')
+    for m in range(2,mmax+1):
+        for k in range(g-m+1):
+            file.write(repr(m)+' '+repr(k)+"\n")
+            n+=1
+    file.close()
+    print("Split in ",n," subtasks")
+    file=open("oar_wilf.sh",'w')
+    file.write("#!/bin/sh\n")
+    file.write("#OAR -l core=1,walltime=100: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 output/param_"+repr(g)+"\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")
+    file.close()
+