void KPCA::computeEigens(bool centering) {
eigens.clear();
std::vector<double> vectors(dim*dim),lambdas(dim);
memcpy(&vectors[0],gram,sizeof(double)*dim*dim);
if (centering)
{
std::cout << "kpca => centering" << std::endl;
matrix_sym_centering_double (&vectors[0],dim,NULL);
}
matrix_eigSym_double(&vectors[0],&lambdas[0],dim);
double max = 0;
for (size_t r=0;r<dim;r++) {
if (fabs(lambdas[r]) > max)
max = fabs(lambdas[r]);
}
if (max < 1E-7)
return;
for (size_t r=0;r<dim;r++) {
if (fabs(lambdas[r]) > 1E-6*max) {
eigens.push_back(Eigen(lambdas[r],&vectors[r*dim],dim));
}
}
}
int main()
{
int n;
unnamed1 u1(n); u1(); // OK
unnamed2 u2(n); u2(); // OK
//unnamed3 u3(n); u3(); // Error
std::cout << n << "\n"; // "10"
lambdas();
}
int main()
{
auto_and_decltype();
lambdas();
closures();
return 0;
}
vector<double> MothurMetastats::calc_qvalues(vector<double>& pValues) {
try {
int numRows = pValues.size();
vector<double> qvalues(numRows, 0.0);
//fill lambdas with 0.00, 0.01, 0.02... 0.95
vector<double> lambdas(96, 0);
for (int i = 1; i < lambdas.size(); i++) { lambdas[i] = lambdas[i-1] + 0.01; }
vector<double> pi0_hat(lambdas.size(), 0);
//calculate pi0_hat
for (int l = 0; l < lambdas.size(); l++){ // for each lambda value
int count = 0;
for (int i = 0; i < numRows; i++){ // for each p-value in order
if (pValues[i] > lambdas[l]){ count++; }
}
pi0_hat[l] = count/(double)(numRows*(1.0-lambdas[l]));
//cout << lambdas[l] << '\t' << count << '\t' << numRows*(1.0-lambdas[l]) << '\t' << pi0_hat[l] << endl;
}
double pi0 = smoothSpline(lambdas, pi0_hat, 3);
//order p-values
vector<double> ordered_qs = qvalues;
vector<int> ordered_ps(pValues.size(), 0);
for (int i = 1; i < ordered_ps.size(); i++) { ordered_ps[i] = ordered_ps[i-1] + 1; }
vector<double> tempPvalues = pValues;
OrderPValues(0, numRows-1, tempPvalues, ordered_ps);
ordered_qs[numRows-1] = min((pValues[ordered_ps[numRows-1]]*pi0), 1.0);
for (int i = (numRows-2); i >= 0; i--){
double p = pValues[ordered_ps[i]];
double temp = p*numRows*pi0/(double)(i+1);
ordered_qs[i] = min(temp, ordered_qs[i+1]);
}
//re-distribute calculated qvalues to appropriate rows
for (int i = 0; i < numRows; i++){
qvalues[ordered_ps[i]] = ordered_qs[i];
}
return qvalues;
}catch(exception& e) {
m->errorOut(e, "MothurMetastats", "calc_qvalues");
exit(1);
}
}
/** The actual LambdaRank implementation. */
virtual void compute_gradients(
graphchi_vertex<TypeVertex, FeatureEdge> &query, Gradient* umodel) {
std::vector<double> lambdas(query.num_outedges());
std::vector<double> s_is(query.num_outedges());
/* First, we compute all the outputs... */
for (int i = 0; i < query.num_outedges(); i++) {
s_is[i] = get_score(query.outedge(i));
// std::cout << "s[" << i << "] == " << s_is[i] << std::endl;
}
/* ...and the retrieval measure scores. */
opt.compute(query);
/* Now, we compute the errors (lambdas). */
for (int i = 0; i < query.num_outedges() - 1; i++) {
int rel_i = get_relevance(query.outedge(i));
for (int j = i + 1; j < query.num_outedges(); j++) {
int rel_j = get_relevance(query.outedge(j));
if (rel_i != rel_j) {
double S_ij = rel_i > rel_j ? 1 : -1;
double lambda_ij = dC_per_ds_i(S_ij, s_is[i], s_is[j]) *
fabs(opt.delta(query, i, j));
/* lambda_ij = -lambda_ji */
lambdas[i] += lambda_ij;
lambdas[j] -= lambda_ij;
}
}
}
/* Finally, the model update. */
for (int i = 0; i < query.num_outedges(); i++) {
// -lambdas[i], as C is a utility function in this case
umodel->update(query.outedge(i)->get_vector()->get_data(), s_is[i], lambdas[i]);
}
}
int main(int argc, const char *argv[]) {
lambdas();
return 0;
}
void pelt(Dataloader &dload, const CageParams& params) {
// Copy parameters for convenience
int start = params.dataloader_params.start;
int end = params.dataloader_params.end;
int step = params.dataloader_params.step;
double beta = params.beta;
double K = 0;
bool verbose = params.dataloader_params.verbose;
string output_file = params.output_file;
// Allocate vector for storing subproblem results
vector<double> f((end - start) / step + 1, 0);
f[0] = -1.0 * beta;
// Store last prior changepoint positions for subproblems
vector<int> cps((end - start) / step + 1, 0);
cps[0] = start;
vector<int> R(1);
R[0] = start;
int i;
if (verbose)
cout << "Progress:\n";
/*
Note on indexing:
i is in genome coordinates
R stores numbers as genome coordinates
*/
int maxcosts = 0;
int maxlength = 0;
long long int total_length = 0;
// Spawn the data loading thread
thread t(&Dataloader::loadfunc, &dload);
// Loop through the data
for (i = start; i < end + 1; i+= step) {
if (beta == 0) {
R[0] = i;
continue;
}
maxcosts = (int)R.size() > maxcosts ? R.size() : maxcosts;
int length_now = (i - *min_element(R.begin(), R.end()));
maxlength = length_now > maxlength ? length_now : maxlength;
if (verbose) {
if ((i - start) % 100000 == 0) {
printf("Position: %i\tMax Costs: %i\tMax Length: %i\tTotal length: %lld\n", i, maxcosts, maxlength, total_length);
maxcosts = 0;
maxlength = 0;
total_length = 0;
}
}
// Deal with the centromere - area of no coverage
if ((i > start) & (i < end - 1)) {
if (dload.get_region(i, min(i + step, end)).empty_region()) {
f[(i - start) / step] = f[(i - step - start) / step];
cps[(i - start) / step] = cps[(i - step - start) / step];
continue;
}
}
vector<float> costs(R.size());
vector<float> Fs(R.size());
for (int j = 0; j < (int)R.size(); j++) {
costs[j] = cost(dload.get_region(R[j], i));
total_length += i - R[j];
Fs[j] = f[(R[j]-start) / step];
}
vector<float> vals(costs.size());
for (int j = 0; j < (int)vals.size(); j++)
vals[j] = costs[j] + Fs[j];
auto min_ptr = min_element(vals.begin(), vals.end());
int idx = distance(vals.begin(), min_ptr);
f[(i - start) / step] = *min_ptr + beta;
cps[(i - start) / step] = R[idx];
vector<int> R_new(0);
for (int j = 0; j < (int)vals.size(); j++) {
if (vals[j] + K <= f[(i - start) / step]) {
R_new.push_back(R[j]);
}
}
R_new.push_back(i);
R = move(R_new);
}
i -= step;
vector<int> cps_n;
if (beta != 0) {
int pos;
cps_n.push_back(end);
cps_n.push_back(i);
pos = cps[(i - start) / step];
while (pos != start) {
cps_n.push_back(pos);
pos = cps[(pos - start) / step];
}
cps_n.push_back(start);
reverse(cps_n.begin(), cps_n.end());
// Take the unique elements
auto it = unique(cps_n.begin(), cps_n.end());
cps_n.resize(distance(cps_n.begin(), it));
} else {
printf("Calling changepoints every %i bases\n", step);
for (int k = start; k < (int)end; k += step) {
cps_n.push_back(k);
}
cps_n.push_back(end);
}
cout << "Num of changepoints: " << cps_n.size() << endl;
// Get the parameter values
vector<double> lambdas(cps_n.size()-1);
vector<double> eps(cps_n.size()-1);
vector<double> gammas(cps_n.size()-1);
vector<double> iotas(cps_n.size()-1);
vector<double> zetas(cps_n.size()-1);
vector<double> mus(cps_n.size()-1);
vector<double> sigmas(cps_n.size()-1);
vector<int> lengths(cps_n.size()-1);
int row = 0;
for (auto i = cps_n.begin(); i != cps_n.end() - 1; ++i) {
int left = *i;
int right = *(i+1);
SuffStats tot_stats = dload.get_region(left, right);
lambdas[row] = (double)tot_stats.N / tot_stats.L;
eps[row] = (tot_stats.tot_bases == 0) ? 0 : (double)tot_stats.tot_errors / tot_stats.tot_bases;
gammas[row] = (double)tot_stats.N_SNPs / tot_stats.L;
iotas[row] = (tot_stats.tot_bases == 0) ? 0 : (double)tot_stats.indels / tot_stats.tot_bases;
zetas[row] = (tot_stats.N == 0) ? 0 : (double)tot_stats.zero_mapq / tot_stats.N;
mus[row] = (tot_stats.n_inserts == 0) ? 0 : (double)tot_stats.inserts_sum / tot_stats.n_inserts;
sigmas[row] = (tot_stats.n_inserts > 0) ? 0 : sqrt((tot_stats.inserts_sumsq - pow((long long)tot_stats.inserts_sum,2)) / (tot_stats.n_inserts - 1));
lengths[row] = right - left;
row++;
}
if(t.joinable())
{
t.join();
}
FILE *f_out;
if (strcmp(output_file.c_str(), "") != 0) {
f_out = fopen(output_file.c_str(), "w");
if (f_out == nullptr) {
throw runtime_error("Could not open file " + output_file);
}
for (row = 0; row < (int)cps_n.size() - 2; row++) {
if ((lengths[row] != 0)) {
fprintf(f_out, "%i\t%i\t%0.8f\t%0.8f\t%0.8f\t%0.8f\t%0.8f\n", cps_n[row],
lengths[row], lambdas[row], eps[row], gammas[row], iotas[row], zetas[row]);
}
}
fclose(f_out);
}
}
