genmodel 0.0.48 → 0.0.49

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGM0YjRkZTgxY2JiYWI3NzJmMmJmZGMyMjk0OWU5NzJhZjJmYTI5Ng==
+    Y2FjZDQ0NDU5YTQ1OGY4MzljMWEyN2ViZDFmMmIxNDNhMWEyNGUxYQ==
   data.tar.gz: !binary |-
-    NzQ5NGNmNDI4NmQzZmE4YWQxZTA0ZDVjOTQ5OWVhN2ZkZThjYmVjMw==
+    NjUyYmUxNzkzYjliMmM0ZDM4MzRmNzFiMWI1MDIzYzRlYzIwZWQ2OA==
 SHA512:
   metadata.gz: !binary |-
-    YWViMjRiMWEyODJlYjA1MGUwOTQ3OWExOGQ4YTUyZGNkYTEzOWQ2OGE3NjA1
-    OGJhNzk2NDU4M2ViY2UxOTY2NjY0NzMxYjM3NWM2YjI2ODE2OTBkMjczYzA0
-    NWM5Yjk1MDdiNTU5ZGNhZDU2N2U4ZDZjZDMxYzczYjQxYWJmZTc=
+    MzllMTU1NDQ3YmI0ZTA3YzFkY2YxYjc4MzBkNjYwMzE0Y2NiODI5OTE0YjUw
+    Mjg5N2VjM2FkNDFmMDQxYTFlOWJmNTU3ODUzODZlYjZjOTI5ZjIyZGZiODg4
+    OGRhYjU3ZDliYjllNjk0YmI1ZWEyZTA2YWI5MTRmMDA3MjYzZDg=
   data.tar.gz: !binary |-
-    ODIxM2QwMjQ4YmQ0YWFmMmEyOGM0MGRkMzczYTg3MjFjNmIzYTM5MTY5ZTJl
-    ZGQ4NDQxNWIxMmEyYmM1ZGM1NjQ4MzAxMGMxZGE5NzQ4NDY1ODQ4NTJkMzI0
-    NTJhZGQxMTBlZmUxOWRlNzhhYTMzNTE3M2YwMTQ4ZDkwOTdmNmY=
+    ZDRhODcxZGEyZmM0NmVkYzIxNTQ4MTM5MzkxMTI2ZjYzNmMwZDk0YjBhYWY0
+    MjQxMGFiYzEyZDI3YjMzNWViYmUxOGQ1YWU5NjRhYTI3NGEyYWQyMWI3ZGU2
+    Y2EyMzBhY2Q3MTlkYTFjMTI4NDhiNDM1MGNkZWE3NDA5YWIwNjY=

data/ext/Genmodel/GenModel.h

@@ -27,6 +27,7 @@
 #include <stdarg.h>
 #include <float.h>
 #include <limits>
+ 
 
 using namespace std;
 
@@ -121,10 +122,11 @@ public:
 	virtual long CreateModel() = 0;
 	virtual long Solve() = 0;
 	virtual long SetSol() = 0;
-    virtual long ChangeBulkBounds(int count, int * ind, char * type, double * vals);
+    virtual long ChangeBulkBounds(size_t count, vector<int>& ind, vector<char>& type, vector<double>& vals);
 	virtual long WriteProblemToLpFile(string filename);
     virtual long WriteSolutionToFile(string filename);
-	virtual long ChangeBulkObjectives(int count, int * ind, double * vals);
+	virtual long ChangeBulkObjectives(size_t count, vector<int>& ind, vector<double>& vals);
+	virtual long ChangeBulkNz(size_t count, vector<int>& rind, vector<int>& cind, vector<double>& vals);
 	virtual long DeleteMipStarts();
 	virtual double GetMIPRelativeGap();
     virtual double FindConstraintMaxLhs(long row);
@@ -135,7 +137,8 @@ public:
     virtual long MakeAllConstraintFeasible(long max_iter = -1);
     virtual long PrintRowInfo(long row);
     virtual string GetStatusString();
-    //virtual string Serialize();
+    string Serialize();
+    long Deserialize(string encoded_compressed_data);
     bool binit;
     bool bcreated;
     string name;

data/ext/Genmodel/GenModelBase.cpp

@@ -2,6 +2,37 @@
 //#include "SqlCaller.h"
 #include <math.h>
 #include <time.h>
+#include <sstream>
+#include <zlib.h>
+#include <sys/time.h>
+//#include "json.h"
+#ifdef __MACH__
+    #include <mach/clock.h>
+    #include <mach/mach.h>
+#endif
+
+
+void get_perfo_time(timespec& ts)
+{
+    #ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
+        clock_serv_t cclock;
+        mach_timespec_t mts;
+        host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+        clock_get_time(cclock, &mts);
+        mach_port_deallocate(mach_task_self(), cclock);
+        ts.tv_sec = mts.tv_sec;
+        ts.tv_nsec = mts.tv_nsec;
+    #else
+        clock_gettime(CLOCK_REALTIME, &ts);
+    #endif
+}
+
+inline double get_timer_diff(timespec& t1, timespec& t2)
+{
+    return (t2.tv_sec-t1.tv_sec)+(t2.tv_nsec-t1.tv_nsec)/1000000000.0;
+}
+
+
 
 #define GM_RED     "\x1b[31m"
 #define GM_GREEN   "\x1b[32m"
@@ -11,6 +42,230 @@
 #define GM_CYAN    "\x1b[36m"
 #define GM_RESET   "\x1b[0m"
 
+static const string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static inline bool is_base64(unsigned char c) {
+  return (isalnum(c) || (c == '+') || (c == '/'));
+}
+string base64_encode(const unsigned char* bytes_to_encode, unsigned int in_len)
+{
+    string ret;
+    int i = 0;
+    int j = 0;
+    unsigned char char_array_3[3];
+    unsigned char char_array_4[4];
+
+    while (in_len--) 
+    {
+        char_array_3[i++] = *(bytes_to_encode++);
+        if (i == 3) 
+        {
+            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+            char_array_4[3] = char_array_3[2] & 0x3f;
+
+            for(i = 0; (i <4) ; i++)
+                ret += base64_chars[char_array_4[i]];
+            i = 0;
+        }
+    }
+    if (i)
+    {
+        for(j = i; j < 3; j++)
+            char_array_3[j] = '\0';
+
+        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+        char_array_4[3] = char_array_3[2] & 0x3f;
+
+        for (j = 0; (j < i + 1); j++)
+            ret += base64_chars[char_array_4[j]];
+
+        while((i++ < 3))
+            ret += '=';
+    }
+    return ret;
+}
+
+string base64_decode(const string& encoded_string) 
+{
+    int in_len = encoded_string.size();
+    int i = 0;
+    int j = 0;
+    int in_ = 0;
+    unsigned char char_array_4[4], char_array_3[3];
+    std::string ret;
+
+    while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) 
+    {
+        char_array_4[i++] = encoded_string[in_]; in_++;
+        if (i ==4) 
+        {
+            for (i = 0; i <4; i++)
+                char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+            for (i = 0; (i < 3); i++)
+                ret += char_array_3[i];
+            i = 0;
+        }
+    }
+
+    if (i) 
+    {
+        for (j = i; j <4; j++)
+            char_array_4[j] = 0;
+        for (j = 0; j <4; j++)
+            char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+        for (j = 0; (j < i - 1); j++) 
+            ret += char_array_3[j];
+    }
+    return ret;
+}
+
+vector<unsigned char> compress_data(unsigned char* data, size_t size, int compressionlevel = Z_DEFAULT_COMPRESSION) //Z_BEST_COMPRESSION)//Z_BEST_SPEED)
+{
+    z_stream zs;                        // z_stream is zlib's control structure
+    memset(&zs, 0, sizeof(zs));
+
+    int windowsBits = 15;
+    int GZIP_ENCODING = 16;
+    //if (deflateInit2(&zs, compressionlevel) != Z_OK)
+
+    zs.zalloc = Z_NULL;
+    zs.zfree  = Z_NULL;
+    zs.opaque = Z_NULL;
+    if (deflateInit2 (&zs, compressionlevel, Z_DEFLATED, windowsBits | GZIP_ENCODING, 8, Z_DEFAULT_STRATEGY))
+        throw(std::runtime_error("deflateInit failed while compressing."));
+
+    //zs.next_in = (Bytef*)str.data();
+    //zs.avail_in = str.size();           // set the z_stream's input
+    zs.next_in = data;
+    zs.avail_in = size;           // set the z_stream's input
+
+    int ret;
+    size_t chunk = 0xffff;
+    size_t avail_size = chunk;
+    if(size/10 > avail_size)
+        avail_size = size/10;
+    size_t buffer_size = avail_size;
+    //vector<unsigned char> outbuffer(32768);
+    //vector<unsigned char> outbuffer(32678);
+    
+    //vector<unsigned char> _outbuffer(chunk);
+
+    unsigned char* outbuffer = (unsigned char*) malloc(buffer_size*sizeof(unsigned char));
+    
+    size_t current = 0;
+
+    // retrieve the compressed bytes blockwise
+    do {
+        zs.next_out = &(outbuffer[current]);
+        zs.avail_out = avail_size*sizeof(unsigned char);
+
+        ret = deflate(&zs, Z_FINISH);
+
+        if (buffer_size == zs.total_out) 
+        {
+            //printf("resize");
+            // append the block to the output string
+            if(buffer_size*0.5 >= chunk)
+                avail_size=buffer_size*0.5;
+                //outbuffer.resize(outbuffer.size()+32768);
+            buffer_size += avail_size;
+            outbuffer = (unsigned char*) realloc(outbuffer, buffer_size*sizeof(unsigned char)); //outbuffer.resize(buffer_size);
+            //else  
+            //  outbuffer.resize(size_t(outbuffer.size()*1.2));
+            current = zs.total_out;
+        }
+        //else
+        //    outbuffer.resize(zs.total_out);
+    } while (ret == Z_OK);
+
+    //outbuffer.resize(zs.total_out);
+    deflateEnd(&zs);
+
+    vector<unsigned char> _outbuffer(zs.total_out);
+    memcpy(&(_outbuffer[0]), outbuffer, zs.total_out);
+    free(outbuffer);
+
+    if (ret != Z_STREAM_END) {          // an error occurred that was not EOF
+        std::ostringstream oss;
+        oss << "Exception during zlib compression: (" << ret << ") " << zs.msg;
+        throw(std::runtime_error(oss.str()));
+    }
+
+    return _outbuffer;
+}
+
+vector<unsigned char> compress_string(const string& str, int compressionlevel = Z_DEFAULT_COMPRESSION) //Z_BEST_COMPRESSION)//Z_BEST_SPEED)
+{
+    return compress_data((unsigned char*)str.data(), str.size(), compressionlevel); 
+}
+
+
+char* decompress_string(const string& compressedBytes) {  
+    
+    if ( compressedBytes.size() == 0 )
+        return NULL;  
+  
+    size_t full_length = compressedBytes.size();  
+    size_t half_length = compressedBytes.size()/2;  
+  
+    size_t uncompLength = full_length ;  
+    char* uncomp = (char*) calloc( sizeof(char), uncompLength );  
+  
+    z_stream strm;  
+    strm.next_in = (Bytef *) compressedBytes.c_str();  
+    strm.avail_in = compressedBytes.size() ;  
+    strm.total_out = 0;  
+    strm.zalloc = Z_NULL;  
+    strm.zfree = Z_NULL;  
+  
+    bool done = false ;  
+  
+    if (inflateInit2(&strm, (16+MAX_WBITS)) != Z_OK) 
+    {  
+        free( uncomp );  
+        return NULL;  
+    }  
+  
+    while (!done) 
+    {  
+        // If our output buffer is too small  
+        if (strm.total_out >= uncompLength ) 
+            uncomp = (char*) realloc(uncomp, uncompLength += half_length); 
+  
+        strm.next_out = (Bytef *) (uncomp + strm.total_out);  
+        strm.avail_out = uncompLength - strm.total_out;  
+  
+        int err = inflate (&strm, Z_SYNC_FLUSH);  
+        if (err == Z_STREAM_END) 
+            done = true;  
+        else if (err != Z_OK) 
+            break;  
+    }  
+  
+    if (inflateEnd (&strm) != Z_OK) 
+    {  
+        free( uncomp );
+        return NULL;  
+    }
+    uncomp = (char*) realloc(uncomp, strm.total_out); 
+    
+    return uncomp;  
+}
+
 GenModel::GenModel()
 {
     version = "genmodel-0.0.39 build 0001";
@@ -358,16 +613,24 @@ long GenModel::AddModelRow(vector<int>& ind, vector<double>& val, double rhs, ch
 	return 0;
 }
 
-long GenModel::ChangeBulkBounds(int count, int * ind, char * type, double * vals)
+long GenModel::ChangeBulkBounds(size_t count, vector<int>& ind, vector<char>& type, vector<double>& vals)
 {
+    throw string("WriteProblemToLpFile() Not implemented");
 	return 0;
 }
 
-long GenModel::ChangeBulkObjectives(int count, int * ind, double * vals)
+long GenModel::ChangeBulkObjectives(size_t count, vector<int>& ind, vector<double>& vals)
 {
+    throw string("WriteProblemToLpFile() Not implemented");
 	return 0;
 }
 
+long GenModel::ChangeBulkNz(size_t count, vector<int>& rind, vector<int>& cind, vector<double>& vals)
+{
+    throw string("WriteProblemToLpFile() Not implemented");
+    return 0;
+}
+
 long GenModel::WriteProblemToLpFile(string filename)
 {
     throw string("WriteProblemToLpFile() Not implemented");
@@ -399,17 +662,207 @@ string GenModel::GetStatusString()
     return string(cstr);
 }
 
-/*string Serialize()
+string GenModel::Serialize()
+{
+    SetNumbers();
+ 
+    // Serial
+    // nb_vars
+    // vars_obj
+    // vars type
+    // var_ub
+    // var_lb
+    // var_q_size
+    // var_qobj
+    // var_qi
+    // var_qj
+    // nb_consts
+    // consts_lrhs
+    // consts_sense
+    // consts_urhs
+    // consts_nz
+    // matrix_per_row_index
+    // matrix_per_row_value
+
+
+    timespec t1; get_perfo_time(t1);
+    
+    
+    unsigned long nb_qz = vars.qobj.size();
+    size_t var_size = 2*sizeof(unsigned long) + nc*(/*type*/sizeof(char) + /*obj,ub,lb*/ 3*sizeof(double)) + nb_qz*(/*qobj*/ sizeof(double) + /*qi,qj*/ 2*sizeof(long));
+    size_t const_size = sizeof(unsigned long) + nr*(/*type*/sizeof(char) + /*lrhs,urhs*/ 2*sizeof(double));
+    size_t mat_size = nr*sizeof(unsigned long);
+    
+    for(size_t i = 0; i < nr; ++i)
+        mat_size += consts[i].nz*(sizeof(long)+sizeof(double));
+    size_t total_size = var_size+const_size+mat_size;
+
+    unsigned char* data = (unsigned char*) malloc(total_size+1);
+    size_t offset = 0;
+    memcpy(&(data[offset]), &(nc), sizeof(unsigned long)); 
+    offset += sizeof(unsigned long);
+    memcpy(&(data[offset]), &(vars.obj[0]), nc*sizeof(double));
+    offset += nc*sizeof(double);
+    memcpy(&(data[offset]), &(vars.type[0]), nc*sizeof(char));
+    offset += nc*sizeof(char);
+    memcpy(&(data[offset]), &(vars.ub[0]), nc*sizeof(double));
+    offset += nc*sizeof(double);
+    memcpy(&(data[offset]), &(vars.lb[0]), nc*sizeof(double));
+    offset += nc*sizeof(double);
+    //printf("> offset before nq = %lu\n", offset);    
+    memcpy(&(data[offset]), &(nb_qz), sizeof(unsigned long)); 
+    offset += sizeof(unsigned long);
+    memcpy(&(data[offset]), &(vars.qobj[0]), nb_qz*sizeof(double));
+    offset += nb_qz*sizeof(double);
+    memcpy(&(data[offset]), &(vars.qi[0]), nb_qz*sizeof(long));
+    offset += nb_qz*sizeof(long);
+    memcpy(&(data[offset]), &(vars.qj[0]), nb_qz*sizeof(long));
+    offset += nb_qz*sizeof(long);
+
+    //printf("> offset before nr = %lu\n", offset);
+    memcpy(&(data[offset]), &(nr), sizeof(unsigned long)); 
+    offset += sizeof(unsigned long);
+    for(size_t i = 0; i < nr; ++i)
+    {
+        //if (i>0 && i%1000 == 0)
+        //    printf("constraint info %lu / %lu\n", i, nr);
+        memcpy(&(data[offset]), &(consts[i].lrhs), sizeof(double));
+        offset += sizeof(double);
+        memcpy(&(data[offset]), &(consts[i].sense), sizeof(char));
+        offset += sizeof(char);
+        memcpy(&(data[offset]), &(consts[i].urhs), sizeof(double));
+        offset += sizeof(double);
+    }
+    for(size_t i = 0; i < nr; ++i)
+    {
+        //if (i>0 && i%1000 == 0)
+        //    printf("matrix element %lu / %lu\n", i, nr);
+        memcpy(&(data[offset]), &(consts[i].nz), sizeof(unsigned long));
+        offset += sizeof(unsigned long);
+        memcpy(&(data[offset]), &(consts[i].cols[0]), consts[i].nz*sizeof(long));
+        offset += consts[i].nz*sizeof(long);
+        memcpy(&(data[offset]), &(consts[i].coefs[0]), consts[i].nz*sizeof(double));
+        offset += consts[i].nz*sizeof(double);
+    }
+    //printf("> offset at end = %lu\n", offset);
+    data[offset] = '\0';
+    printf("var_size = %lu, const_size = %lu mat_size = %lu, total_size = %lu\n", var_size, const_size, mat_size, total_size);
+    //printf("> nc = %lu, nr = %lu, nq = %lu, nz = %lu\n", nc, nr, vars.qobj.size(), nz);
+
+    timespec t2; get_perfo_time(t2);
+    printf("Serialize : write serilization to memory : %f s.\n", get_timer_diff(t1,t2));    
+
+    vector<unsigned char> compressed_data = compress_data(data, total_size);
+    timespec t3; get_perfo_time(t3);
+    printf("Serialize : compressing serilization : %f s.\n", get_timer_diff(t2,t3));
+    free(data);
+    string serialization_str = base64_encode(&(compressed_data[0]), compressed_data.size());
+    timespec t4; get_perfo_time(t4);
+    printf("Serialize : encoding serilization : %f s.\n", get_timer_diff(t3,t4));
+
+    return serialization_str;
+}
+
+long GenModel::Deserialize(string encoded_compressed_data)
 {
-    string name;
-    vector<ModConsts> consts;
-    ModVars vars;
-    void* solverdata;
-    map<string, long> longParam;
-    map<string, double> dblParam;
-    map<string, bool> boolParam;
-    map<string, string> strParam;
-}*/
+    timespec t1; get_perfo_time(t1);
+    
+    nr = 0;
+    nc = 0;
+    nz = 0;
+    
+    for(size_t i = 0; i < consts.size(); ++i)
+    {
+        consts[i].cols.clear();
+        consts[i].coefs.clear();
+    }
+    consts.clear();    
+
+    vars = ModVars();
+    timespec t2; get_perfo_time(t2);
+    printf("Deserialize : freeing object : %f s.", get_timer_diff(t1,t2));
+
+    string decoded_string = base64_decode(encoded_compressed_data);
+    timespec t3; get_perfo_time(t3);
+    printf("Deserialize : decoding serialization : %f s.", get_timer_diff(t2,t3));
+
+    char* data =  decompress_string(decoded_string);
+    timespec t4; get_perfo_time(t4);
+    printf("Deserialize : decompressing serialization : %f s.", get_timer_diff(t3,t4));
+
+ 
+    size_t offset = 0;
+    memcpy(&nc, &(data[offset]), sizeof(unsigned long));
+    vars.n = nc;
+    offset += sizeof(unsigned long);
+    vars.name.resize(nc, "");
+    vars.obj.resize(nc);
+    memcpy(&(vars.obj[0]), &(data[offset]), nc*sizeof(double));
+    offset += nc*sizeof(double);
+    vars.type.resize(nc);
+    memcpy(&(vars.type[0]), &(data[offset]), nc*sizeof(char));
+    offset += nc*sizeof(char);
+    vars.ub.resize(nc);
+    memcpy(&(vars.ub[0]), &(data[offset]), nc*sizeof(double));
+    offset += nc*sizeof(double);
+    vars.lb.resize(nc);
+    memcpy(&(vars.lb[0]), &(data[offset]), nc*sizeof(double));
+    offset += nc*sizeof(double);
+    //printf("< offset before nq = %lu\n", offset);
+    unsigned long nb_qz = 0;
+    memcpy(&nb_qz, &(data[offset]), sizeof(unsigned long));
+    offset += sizeof(unsigned long);
+    vars.qobj.resize(nb_qz);
+    memcpy(&(vars.qobj[0]), &(data[offset]), nb_qz*sizeof(double));
+    offset += nb_qz*sizeof(double);
+    vars.qi.resize(nb_qz);
+    memcpy(&(vars.qi[0]), &(data[offset]), nb_qz*sizeof(long));
+    offset += nb_qz*sizeof(long);
+    vars.qj.resize(nb_qz);
+    memcpy(&(vars.qj[0]), &(data[offset]), nb_qz*sizeof(long));
+    offset += nb_qz*sizeof(long);
+
+    //printf("< offset before nr = %lu\n", offset);
+    memcpy(&nr, &(data[offset]), sizeof(unsigned long));
+    offset += sizeof(unsigned long);
+    
+    consts.resize(nr);
+    for(size_t i = 0; i < nr; ++i)
+    {
+        memcpy(&(consts[i].lrhs), &(data[offset]), sizeof(double));
+        offset += sizeof(double);
+        memcpy(&(consts[i].sense), &(data[offset]), sizeof(char));
+        offset += sizeof(char);
+        memcpy(&(consts[i].urhs), &(data[offset]), sizeof(double));
+        offset += sizeof(double);
+        consts[i].name = "";
+    }
+    
+    unsigned long r_nz;
+    for(size_t i = 0; i < nr; ++i)
+    {
+        memcpy(&r_nz, &(data[offset]), sizeof(long));
+        offset += sizeof(long);
+        consts[i].cols.resize(r_nz);
+        memcpy(&(consts[i].cols[0]), &(data[offset]), r_nz*sizeof(long));
+        offset += r_nz*sizeof(long);
+        consts[i].coefs.resize(r_nz);
+        memcpy(&(consts[i].coefs[0]), &(data[offset]), r_nz*sizeof(double));
+        offset += r_nz*sizeof(double);
+    }
+    //printf("< offset at end = %lu\n", offset);
+    
+    SetNumbers();
+    
+    free(data);
+
+    //printf("< nc = %lu, nr = %lu, nq = %lu, nz = %lu\n", nc, nr, nb_qz, nz);
+
+    timespec t5; get_perfo_time(t5);
+    printf("Deserialize : filling object : %f s.", get_timer_diff(t4,t5));
+
+    return 0;
+}
 
 long ModVars::AddVar(string nn, double o, double l, double u, char t)
 {