Merge pull request #8 from iamtheburd/allow-bigger-numbers

Tyler Burdsall · web-flow · commit 38842d0f2256 · 2018-11-14T10:45:19.000-08:00
Allow bigger numbers
diff --git a/src/combigen.cpp b/src/combigen.cpp
@@ -22,7 +22,14 @@ int main(int argc, char* argv[])
                 if (optarg)
                 {
                     istringstream iss (optarg);
+		    string s = optarg;
+		    if (s.at(0) == '-')
+		    {
+		        display_help();
+			exit(-1);
+		    }
                     iss >> args.entry_at;
+		    args.entry_at_provided = true;
                     args_provided = true;
                 }
                 break;
@@ -158,7 +165,7 @@ static const void display_help(void)
          << "   -v             Display version number" << "\n";
 }
 
-static const void generate_all(const long &max_size, const generation_args &args)
+static const void generate_all(const unsigned long long &max_size, const generation_args &args)
 {
     if (!args.display_json)
     {
@@ -171,8 +178,8 @@ static const void generate_all(const long &max_size, const generation_args &args
     {
         cout << "[\n";
     }
-    const long last = max_size - 1;
-    for (long i = 0; i < max_size; ++i)
+    const unsigned long long last = max_size - 1;
+    for (unsigned long long i = 0; i < max_size; ++i)
     {
         vector<string> result = lazy_cartesian_product::entry_at(args.pc.combinations, i);
         output_result(result, args, true);
@@ -187,7 +194,7 @@ static const void generate_all(const long &max_size, const generation_args &args
     }
 }
 
-static const void generate_random_samples(const vector<long> &range, const generation_args &args)
+static const void generate_random_samples(const vector<unsigned long long> &range, const generation_args &args)
 {
     if (!args.display_json)
     {
@@ -200,7 +207,7 @@ static const void generate_random_samples(const vector<long> &range, const gener
     {
         cout << "[\n";
     }
-    for (const long &i: range)
+    for (const unsigned long long &i: range)
     {
         vector<string> result = lazy_cartesian_product::entry_at(args.pc.combinations, i);
         output_result(result, args, true);
@@ -215,7 +222,7 @@ static const void generate_random_samples(const vector<long> &range, const gener
     }
 }
 
-static const void generate_random_samples_performance_mode( const generation_args &args)
+static const void generate_random_samples_performance_mode(const generation_args &args)
 {
     const vector<vector<string>> results = lazy_cartesian_product::generate_samples(args.pc.combinations, args.sample_size);
     
@@ -267,13 +274,13 @@ static const void output_result(const vector<string> &result, const generation_a
     }
     else
     {
-        const long key_size = args.pc.keys.size();
+        const unsigned long long key_size = args.pc.keys.size();
         if (!for_optimization) 
         {
             cout << "[\n";
         }
         json entry;
-        for (long j = 0; j < key_size; ++j)
+        for (unsigned long long j = 0; j < key_size; ++j)
         {
             entry[args.pc.keys[j]] = result[j];
         }
@@ -287,23 +294,23 @@ static const void output_result(const vector<string> &result, const generation_a
 
 static const void parse_args(const generation_args &args)
 {
-    long max_size = lazy_cartesian_product::compute_max_size(args.pc.combinations);
+    unsigned long long max_size = lazy_cartesian_product::compute_max_size(args.pc.combinations);
     if (args.generate_all_combinations)
     {
         generate_all(max_size, args);
         exit(0);
     }
     else
     {
-        if (args.sample_size == 0 && args.entry_at > -1 && !args.generate_all_combinations)
+        if (args.sample_size == 0 && args.entry_at_provided && !args.generate_all_combinations)
         {
             vector<string> result = lazy_cartesian_product::entry_at(args.pc.combinations, args.entry_at);
             output_result(result, args, false);
             exit(0);
         }
-        else if (args.sample_size > 0)
+        else if (args.sample_size >= 0)
         {
-            const long n = args.sample_size;
+            const unsigned long long n = args.sample_size;
             if (n > max_size)
             {
                 cerr << "ERROR: Sample size cannot be greater than maximum possible combinations\n";
@@ -315,7 +322,7 @@ static const void parse_args(const generation_args &args)
             }
             else
             {
-                vector<long> range = lazy_cartesian_product::generate_random_indices(n, max_size);
+                vector<unsigned long long> range = lazy_cartesian_product::generate_random_indices(n, max_size);
                 generate_random_samples(range, args);
             }
             exit(0);
diff --git a/src/combigen.h b/src/combigen.h
@@ -53,18 +53,19 @@ struct generation_args
     possible_combinations           pc;
     string                          input;
     string                          delim = ",";
-    long                            entry_at = -1;
-    long                            sample_size = 0;
+    unsigned long long              entry_at = 0;
+    unsigned long long              sample_size = 0;
     bool                            generate_all_combinations = false;
     bool                            display_keys = false;
     bool                            display_json = false;
     bool                            perf_mode = false;
+    bool	                    entry_at_provided = false;
 };
 
 static const void                   display_csv_keys(const vector<string> &keys, const string &delim);
 static const void                   display_help(void);
-static const void                   generate_all(const long &max_size, const generation_args &args);
-static const void                   generate_random_samples(const vector<long> &range, const generation_args &args);
+static const void                   generate_all(const unsigned long long &max_size, const generation_args &args);
+static const void                   generate_random_samples(const vector<unsigned long long> &range, const generation_args &args);
 static const void                   generate_random_samples_performance_mode(const generation_args &args);
 static const void                   output_result(const vector<string> &result, const generation_args &args, const bool &for_optimization);
 static const void                   parse_args(const generation_args &args);
diff --git a/src/lib/iamtheburd/lazy-cartesian-product b/src/lib/iamtheburd/lazy-cartesian-product
@@ -1 +1 @@
-Subproject commit 5de55b1e4f40e68d4bcad05eebad1b0f080a6dd2
+Subproject commit 7dfae2dd583fcc98412bcebe2a373ebf7dd8d2d2
diff --git a/src/lib/nlohmann/json b/src/lib/nlohmann/json
@@ -1 +1 @@
-Subproject commit d456a2d7774b31a13bf3aa02d56a8ae145bd0e20
+Subproject commit 6708f22cd4d604035b20ddc081a705042b1d4ab0

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,14 @@ int main(int argc, char* argv[])`
`22`	`22`	`if (optarg)`
`23`	`23`	`{`
`24`	`24`	`istringstream iss (optarg);`
	`25`	`+ string s = optarg;`
	`26`	`+ if (s.at(0) == '-')`
	`27`	`+ {`
	`28`	`+ display_help();`
	`29`	`+ exit(-1);`
	`30`	`+ }`
`25`	`31`	`iss >> args.entry_at;`
	`32`	`+ args.entry_at_provided = true;`
`26`	`33`	`args_provided = true;`
`27`	`34`	`}`
`28`	`35`	`break;`
`@@ -158,7 +165,7 @@ static const void display_help(void)`
`158`	`165`	`<< " -v Display version number" << "\n";`
`159`	`166`	`}`
`160`	`167`
`161`		`-static const void generate_all(const long &max_size, const generation_args &args)`
	`168`	`+static const void generate_all(const unsigned long long &max_size, const generation_args &args)`
`162`	`169`	`{`
`163`	`170`	`if (!args.display_json)`
`164`	`171`	`{`
`@@ -171,8 +178,8 @@ static const void generate_all(const long &max_size, const generation_args &args`
`171`	`178`	`{`
`172`	`179`	`cout << "[\n";`
`173`	`180`	`}`
`174`		`- const long last = max_size - 1;`
`175`		`- for (long i = 0; i < max_size; ++i)`
	`181`	`+ const unsigned long long last = max_size - 1;`
	`182`	`+ for (unsigned long long i = 0; i < max_size; ++i)`
`176`	`183`	`{`
`177`	`184`	`vector<string> result = lazy_cartesian_product::entry_at(args.pc.combinations, i);`
`178`	`185`	`output_result(result, args, true);`
`@@ -187,7 +194,7 @@ static const void generate_all(const long &max_size, const generation_args &args`
`187`	`194`	`}`
`188`	`195`	`}`
`189`	`196`
`190`		`-static const void generate_random_samples(const vector<long> &range, const generation_args &args)`
	`197`	`+static const void generate_random_samples(const vector<unsigned long long> &range, const generation_args &args)`
`191`	`198`	`{`
`192`	`199`	`if (!args.display_json)`
`193`	`200`	`{`
`@@ -200,7 +207,7 @@ static const void generate_random_samples(const vector<long> &range, const gener`
`200`	`207`	`{`
`201`	`208`	`cout << "[\n";`
`202`	`209`	`}`
`203`		`- for (const long &i: range)`
	`210`	`+ for (const unsigned long long &i: range)`
`204`	`211`	`{`
`205`	`212`	`vector<string> result = lazy_cartesian_product::entry_at(args.pc.combinations, i);`
`206`	`213`	`output_result(result, args, true);`
`@@ -215,7 +222,7 @@ static const void generate_random_samples(const vector<long> &range, const gener`
`215`	`222`	`}`
`216`	`223`	`}`
`217`	`224`
`218`		`-static const void generate_random_samples_performance_mode( const generation_args &args)`
	`225`	`+static const void generate_random_samples_performance_mode(const generation_args &args)`
`219`	`226`	`{`
`220`	`227`	`const vector<vector<string>> results = lazy_cartesian_product::generate_samples(args.pc.combinations, args.sample_size);`
`221`	`228`
`@@ -267,13 +274,13 @@ static const void output_result(const vector<string> &result, const generation_a`
`267`	`274`	`}`
`268`	`275`	`else`
`269`	`276`	`{`
`270`		`- const long key_size = args.pc.keys.size();`
	`277`	`+ const unsigned long long key_size = args.pc.keys.size();`
`271`	`278`	`if (!for_optimization)`
`272`	`279`	`{`
`273`	`280`	`cout << "[\n";`
`274`	`281`	`}`
`275`	`282`	`json entry;`
`276`		`- for (long j = 0; j < key_size; ++j)`
	`283`	`+ for (unsigned long long j = 0; j < key_size; ++j)`
`277`	`284`	`{`
`278`	`285`	`entry[args.pc.keys[j]] = result[j];`
`279`	`286`	`}`
`@@ -287,23 +294,23 @@ static const void output_result(const vector<string> &result, const generation_a`
`287`	`294`
`288`	`295`	`static const void parse_args(const generation_args &args)`
`289`	`296`	`{`
`290`		`- long max_size = lazy_cartesian_product::compute_max_size(args.pc.combinations);`
	`297`	`+ unsigned long long max_size = lazy_cartesian_product::compute_max_size(args.pc.combinations);`
`291`	`298`	`if (args.generate_all_combinations)`
`292`	`299`	`{`
`293`	`300`	`generate_all(max_size, args);`
`294`	`301`	`exit(0);`
`295`	`302`	`}`
`296`	`303`	`else`
`297`	`304`	`{`
`298`		`- if (args.sample_size == 0 && args.entry_at > -1 && !args.generate_all_combinations)`
	`305`	`+ if (args.sample_size == 0 && args.entry_at_provided && !args.generate_all_combinations)`
`299`	`306`	`{`
`300`	`307`	`vector<string> result = lazy_cartesian_product::entry_at(args.pc.combinations, args.entry_at);`
`301`	`308`	`output_result(result, args, false);`
`302`	`309`	`exit(0);`
`303`	`310`	`}`
`304`		`- else if (args.sample_size > 0)`
	`311`	`+ else if (args.sample_size >= 0)`
`305`	`312`	`{`
`306`		`- const long n = args.sample_size;`
	`313`	`+ const unsigned long long n = args.sample_size;`
`307`	`314`	`if (n > max_size)`
`308`	`315`	`{`
`309`	`316`	`cerr << "ERROR: Sample size cannot be greater than maximum possible combinations\n";`
`@@ -315,7 +322,7 @@ static const void parse_args(const generation_args &args)`
`315`	`322`	`}`
`316`	`323`	`else`
`317`	`324`	`{`
`318`		`- vector<long> range = lazy_cartesian_product::generate_random_indices(n, max_size);`
	`325`	`+ vector<unsigned long long> range = lazy_cartesian_product::generate_random_indices(n, max_size);`
`319`	`326`	`generate_random_samples(range, args);`
`320`	`327`	`}`
`321`	`328`	`exit(0);`