/* If you've got a dataset where you are training and testing
using the set of rows specified in "train_and_test_rows" and you
wish to do k-fold cross-validation (k == num_folds) then what
subset of train_and_test_rows should you use as the train set
fold_num'th fold? And which should be the test set?
This function tells you.
It uses a deterministic shuffle and then selects the given rows.
PRE: train_and_test_rows is a natset (see above) (it means
strictly increasing set of natural numbers) (in which case
num_rows is ignored).
OR train_and_test_rows may be NULL, indicating "use all
rows in the set { 0 , 1 , ... num_rows-1 }
POST: *r_train_set is the fold_num'th training set
*r_test_set is the fold_num'th test set.
(Note that the union of these two is the original set of rows).
The resulting sets are both returned in strictly increasing
order.
Note that if you called this function repeatedly with the same number
of folds, but you varied fold_num from 0 up to num_folds on each
call, then the union of all the resulting test_sets would contain the
same set as train_and_test_rows. But all pairs of resulting test_sets
would have an empty intersection.
*/
void make_kfold_rows(ivec *train_and_test_rows,int num_rows,int num_folds,int fold_num,
ivec **r_train_rows,ivec **r_test_rows)
{
int save_seed = int_random(300000);
ivec *srows = (train_and_test_rows==NULL) ? mk_identity_ivec(num_rows) :
mk_copy_ivec(train_and_test_rows);
int srows_size = ivec_size(srows);
int start_i = (int) floor(fold_num * num_rows / (double) num_folds);
int end_i = (int) floor((fold_num+1) * num_rows / (double) num_folds);
int i;
*r_train_rows = mk_ivec(srows_size - (end_i - start_i));
*r_test_rows = mk_ivec(end_i - start_i);
am_srand(12345);
shuffle_ivec(srows);
for ( i = 0 ; i < srows_size ; i++ )
{
ivec *update_me = (i >= start_i && i < end_i) ? *r_test_rows : *r_train_rows;
int update_index = (i < start_i) ? i :
(i < end_i) ? i - start_i : i - (end_i - start_i);
ivec_set(update_me,update_index,ivec_ref(srows,i));
}
free_ivec(srows);
am_srand(save_seed);
ivec_sort(*r_train_rows,*r_train_rows);
ivec_sort(*r_test_rows,*r_test_rows);
}
/* If you've got a dataset where you are training and testing
using the set of rows specified in "train_and_test_rows" and you
wish to make a test-set of size "num_test_rows" and a training-set
of size "num_training_row (= num_tain_and_test - num_test)"
this returns the training and test rows you should use, obtained by
shuffling train_and_test.
PRE: train_and_test_rows is a natset (see above) (it means
strictly increasing set of natural numbers) (in which case
num_rows is ignored).
OR train_and_test_rows may be NULL, indicating "use all
rows in the set { 0 , 1 , ... num_rows-1 }
POST: *r_train_set is the training set
*r_test_set is the test set.
(Note that the union of these two is the original set of rows).
The resulting sets are both returned in strictly increasing
order.
*/
void make_train_and_test_rows(ivec *train_and_test_rows,
int num_rows,int num_test_rows,
ivec **r_train_rows,ivec **r_test_rows)
{
int save_seed = int_random(300000);
ivec *srows = (train_and_test_rows==NULL) ?
mk_identity_ivec(num_rows) :
mk_copy_ivec(train_and_test_rows);
int srows_size = ivec_size(srows);
int i;
*r_train_rows = mk_ivec(srows_size - num_test_rows);
*r_test_rows = mk_ivec(num_test_rows);
am_srand(12345);
shuffle_ivec(srows);
for ( i = 0 ; i < num_test_rows ; i++ )
ivec_set(*r_test_rows,i,ivec_ref(srows,i));
for ( i = num_test_rows ; i < srows_size ; i++ )
ivec_set(*r_train_rows,i-num_test_rows,ivec_ref(srows,i));
free_ivec(srows);
am_srand(save_seed);
ivec_sort(*r_train_rows,*r_train_rows);
ivec_sort(*r_test_rows,*r_test_rows);
}
int main(int argc,char **argv) {
int i;
int_random(time(NULL));
for(i=0;i<1000;i++) printf("%i\n",random_word()%1000);
return 0;
}
// creates one table with distinct_count distinct values
atable_ptr_t TableGenerator::int_distinct(size_t row_count, size_t column_count, size_t distinct_count) {
size_t x = row_count / distinct_count;
std::vector<c_atable_ptr_t > tables;
const auto& base_table = int_random(distinct_count, column_count);
tables.push_back(base_table);
for (size_t i = 0; i <= x; i++) {
tables.push_back(base_table);
}
size_t fill_up = row_count - x * distinct_count;
if (fill_up > 0) {
const auto& fill_up_table = int_random(fill_up, column_count);
tables.push_back(fill_up_table);
}
const auto& result = TableMerger(new DefaultMergeStrategy(), new SequentialHeapMerger()).merge(tables);
return result[0];
}
void test(int nb_cnst, int nb_var, int nb_elem)
{
lmm_system_t Sys = NULL;
lmm_constraint_t *cnst = xbt_new0(lmm_constraint_t, nb_cnst);
lmm_variable_t *var = xbt_new0(lmm_variable_t, nb_var);
int *used = xbt_new0(int, nb_cnst);
int i, j, k;
Sys = lmm_system_new(1);
for (i = 0; i < nb_cnst; i++) {
cnst[i] = lmm_constraint_new(Sys, NULL, float_random(10.0));
}
for (i = 0; i < nb_var; i++) {
var[i] = lmm_variable_new(Sys, NULL, 1.0, -1.0, nb_elem);
for (j = 0; j < nb_cnst; j++)
used[j] = 0;
for (j = 0; j < nb_elem; j++) {
k = int_random(nb_cnst);
if (used[k]) {
j--;
continue;
}
lmm_expand(Sys, cnst[k], var[i], float_random(1.0));
used[k] = 1;
}
}
printf("Starting to solve\n");
date = xbt_os_time() * 1000000;
lmm_solve(Sys);
date = xbt_os_time() * 1000000 - date;
for (i = 0; i < nb_var; i++)
lmm_variable_free(Sys, var[i]);
lmm_system_free(Sys);
free(cnst);
free(var);
free(used);
}
ADTListItem list_random_item(ADTList list) {
return (list->head) ? list_item_at(list, int_random(0, list_size(list) - 1)) : NULL;
}
static void test(int nb_cnst, int nb_var, int nb_elem, unsigned int pw_base_limit, unsigned int pw_max_limit,
float rate_no_limit, int max_share, int mode)
{
lmm_system_t Sys = NULL;
lmm_constraint_t *cnst = xbt_new0(lmm_constraint_t, nb_cnst);
lmm_variable_t *var = xbt_new0(lmm_variable_t, nb_var);
int *used = xbt_new0(int, nb_cnst);
int i;
int j;
int k;
int l;
int concurrency_share;
Sys = lmm_system_new(1);
for (i = 0; i < nb_cnst; i++) {
cnst[i] = lmm_constraint_new(Sys, NULL, float_random(10.0));
if(rate_no_limit>float_random(1.0))
//Look at what happens when there is no concurrency limit
l=-1;
else
//Badly logarithmically random concurrency limit in [2^pw_base_limit+1,2^pw_base_limit+2^pw_max_limit]
l=(1<<pw_base_limit)+(1<<int_random(pw_max_limit));
lmm_constraint_concurrency_limit_set(cnst[i],l );
}
for (i = 0; i < nb_var; i++) {
var[i] = lmm_variable_new(Sys, NULL, 1.0, -1.0, nb_elem);
//Have a few variables with a concurrency share of two (e.g. cross-traffic in some cases)
concurrency_share=1+int_random(max_share);
lmm_variable_concurrency_share_set(var[i],concurrency_share);
for (j = 0; j < nb_cnst; j++)
used[j] = 0;
for (j = 0; j < nb_elem; j++) {
k = int_random(nb_cnst);
if (used[k]>=concurrency_share) {
j--;
continue;
}
lmm_expand(Sys, cnst[k], var[i], float_random(1.5));
lmm_expand_add(Sys, cnst[k], var[i], float_random(1.5));
used[k]++;
}
}
fprintf(stderr,"Starting to solve(%i)\n",myrand()%1000);
date = xbt_os_time() * 1000000;
lmm_solve(Sys);
date = xbt_os_time() * 1000000 - date;
if(mode==2){
fprintf(stderr,"Max concurrency:\n");
l=0;
for (i = 0; i < nb_cnst; i++) {
j=lmm_constraint_concurrency_maximum_get(cnst[i]);
k=lmm_constraint_concurrency_limit_get(cnst[i]);
xbt_assert(k<0 || j<=k);
if(j>l)
l=j;
fprintf(stderr,"(%i):%i/%i ",i,j,k);
lmm_constraint_concurrency_maximum_reset(cnst[i]);
xbt_assert(!lmm_constraint_concurrency_maximum_get(cnst[i]));
if(i%10==9)
fprintf(stderr,"\n");
}
fprintf(stderr,"\nTotal maximum concurrency is %i\n",l);
lmm_print(Sys);
}
for (i = 0; i < nb_var; i++)
lmm_variable_free(Sys, var[i]);
lmm_system_free(Sys);
free(cnst);
free(var);
free(used);
}