void Chain_Factorial::update_x_BlockGibbs(){
if(nrows_gibbs == K){
// forward step
FHMM_forward_step(pi, A, emission_probs, P_FHMM, loglik_marginal, k_restricted, n, x, restricted_space);
// now backward sampling
FHMM_backward_sampling(x, P_FHMM, k_restricted, n, restricted_space);
} else{
for(int i=0; i<all_combinations.ncol(); i++){
// Restrict the state space to block Gibbs updates
IntegerVector which_rows_fixed = all_combinations(_, i);
//IntegerVector which_rows_fixed = sample_helper(K, K-nrows_gibbs);
restricted_space = construct_all_restricted_space(k_restricted, which_rows_fixed, mapping);
// forward step
FHMM_forward_step(pi, A, emission_probs, P_FHMM, loglik_marginal, k_restricted, n, x, restricted_space);
// now backward sampling
FHMM_backward_sampling(x, P_FHMM, k_restricted, n, restricted_space);
}
}
// conditional loglikelihood
loglik_cond = loglikelihood(x, emission_probs, n);
convert_x_to_X();
}
void HLFscheduler::get_initial_schedule(const Intree& t,
vector<vector<task_id>>& target) const {
// fetch all tasks, and sort them according to their level
vector<task_id> tasks = t.get_tasks();
vector<task_id> tmp;
for(auto const& it : tasks){
if(t.get_in_degree(it) == 0)
tmp.push_back(it);
}
sort(tmp.begin(), tmp.end(),
[&t](const task_id& a, const task_id& b) -> bool {
return t.get_level(a) > t.get_level(b);
}
);
// compute possible combinations
vector<vector<task_id>> combos;
vector<task_id> dummy;
vector<unsigned int> referencelevels;
unsigned int numtasks = tmp.size();
unsigned int actualprocs = min(processorcount, numtasks);
for(unsigned int i=0; i<actualprocs; ++i){
referencelevels.push_back(t.get_level(tmp[i]));
}
all_combinations(tmp, actualprocs, -1, t, referencelevels, dummy, combos);
for(auto const& it : combos){
target.push_back(it);
}
}
int main(int argc, char *argv[]){
int total_hash_time = 0;
int total_generate_time = 0;
// generate a hash of the supplied string
char output_hash[8];
size_t output_len = 8;
Pearson16(argv[1], strlen(argv[1]), output_hash, output_len);
printf("Original input hash: %s\n", output_hash);
printf("Thinking...\n");
int start_time = time(NULL);
// loop through all possible input data to find
// data that returns a matching hash and track how
// long this takes
const int maxlen = strlen(argv[1]);
char match[maxlen];
char x[maxlen+1];
for(int thislen=1; thislen <= maxlen; thislen++){
x[thislen] = 0;
all_combinations(x, thislen-1, output_hash, match);
}
int end_time = time(NULL);
printf("\nReconstituted original input: %s\n", match);
printf("Elapsed time: %ds\n", end_time - start_time);
return 0;
}
void HLFscheduler::all_combinations(vector<task_id> nums,
unsigned int n,
unsigned int minindex,
const Intree& t,
const vector<unsigned int>& referencelevels,
vector<task_id>& current,
vector<vector<task_id>>& target) const {
if(n==0){
for(unsigned int i=0; i<current.size(); ++i){
if(t.get_level(current[i]) != referencelevels[i])
return;
if(t.get_in_degree(current[i]) > 0)
return;
}
target.push_back(current);
return;
}
if(nums.size() - minindex <= n)
return;
for(unsigned int i=minindex+1; i<nums.size(); ++i){
vector<task_id> newcombo(current);
newcombo.push_back(nums[i]);
all_combinations(nums,
n-1,
i,
t,
referencelevels,
newcombo,
target);
}
}
void all_combinations(char* x, const int len, char* target_hash, char* match)
{
for (char c = 97; c < 122; ++c){
x[len] = c;
if(len>0){
all_combinations(x, len - 1, target_hash, match );
} else {
//printf("\t%d\n", strncmp(x, target_hash, strlen(target_hash)));
// test input candidate
char test_hash[8];
size_t test_hash_len = 8;
Pearson16(x, strlen(x), test_hash, test_hash_len);
if(strncmp(test_hash, target_hash, strlen(test_hash)) == 0){
strcpy(match, x);
}
}
}
}
