options set_config_option(options const & opts, char const * in) { if (!in) return opts; while (*in && std::isspace(*in)) ++in; std::string in_str(in); auto pos = in_str.find('='); if (pos == std::string::npos) throw lean::exception("invalid -D parameter, argument must contain '='"); lean::name opt = lean::string_to_name(in_str.substr(0, pos)); std::string val = in_str.substr(pos+1); auto decls = lean::get_option_declarations(); auto it = decls.find(opt); if (it != decls.end()) { switch (it->second.kind()) { case lean::BoolOption: if (val == "true") return opts.update(opt, true); else if (val == "false") return opts.update(opt, false); else throw lean::exception(lean::sstream() << "invalid -D parameter, invalid configuration option '" << opt << "' value, it must be true/false"); case lean::IntOption: case lean::UnsignedOption: return opts.update(opt, atoi(val.c_str())); default: throw lean::exception(lean::sstream() << "invalid -D parameter, configuration option '" << opt << "' cannot be set in the command line, use set_option command"); } } else { throw lean::exception(lean::sstream() << "invalid -D parameter, unknown configuration option '" << opt << "'"); } }
static bool has_show(options const & opts, name const & kind, unsigned & line, unsigned & col) { if (opts.get_bool(kind)) { line = opts.get_unsigned("line", 0); col = opts.get_unsigned("column", 0); return true; } else { return false; } }
context(const benchmark_info& info, const options& opts) : d_timer_on(false) , d_start() , d_duration() , d_benchtime(std::chrono::seconds(opts.get_benchtime())) , d_num_iterations(1) , d_num_threads(opts.get_cpu()) , d_num_bytes(0) , d_benchmark(info) {}
void display(options& opt, spec::runner::result const& res) { // stdout is default so this is valid std::ostream output( std::cout.rdbuf() ); bool file_output = false; std::ofstream file_stream; std::string const& format = opt.format(); std::string const& output_method = opt.output_method(); boost::shared_ptr<output_format::base> outformat; std::string file_extension; if( output_method == "stderr" ) output.rdbuf( std::cerr.rdbuf() ); else if( output_method == "file" ) file_output = true; // Add you output format the same way as bellow DON'T FORGET TO ADD // FILE EXTENSION // --------------------------------------------------------------------------- if( format == "compiler" ) { outformat.reset( new output_format::compiler() ); file_extension = ".txt"; } // --------------------------------------------------------------------------- else if( format == "xml" ) { outformat.reset( new output_format::xml() ); file_extension = ".xml"; } // --------------------------------------------------------------------------- else { throw std::runtime_error( "output format not supported" ); } if( file_output ) { std::string filename = opt.filename()+file_extension; file_stream.open(filename.c_str(), std::ios_base::out|std::ios_base::trunc); if( file_stream.is_open() ) output.rdbuf( file_stream.rdbuf() ); } spec::output out( outformat, res, output ); out.display(); }
std::size_t TestFixture::runTests(const options& args) { std::string classname(args.which_test()); std::string testname(""); if (classname.find("::") != std::string::npos) { testname = classname.substr(classname.find("::") + 2); classname.erase(classname.find("::")); } countTests = 0; errmsg.str(""); const std::list<TestFixture *> &tests = TestRegistry::theInstance().tests(); for (std::list<TestFixture *>::const_iterator it = tests.begin(); it != tests.end(); ++it) { if (classname.empty() || (*it)->classname == classname) { (*it)->processOptions(args); (*it)->run(testname); } } std::cout << "\n\nTesting Complete\nNumber of tests: " << countTests << std::endl; std::cout << "Number of todos: " << todos_counter; if (succeeded_todos_counter > 0) std::cout << " (" << succeeded_todos_counter << " succeeded)"; std::cout << std::endl; // calling flush here, to do all output before the error messages (in case the output is buffered) std::cout.flush(); std::cerr << "Tests failed: " << fails_counter << std::endl << std::endl; std::cerr << errmsg.str(); std::cerr.flush(); return fails_counter; }
options join(options const & opts1, options const & opts2) { sexpr r = opts2.m_value; for_each(opts1.m_value, [&](sexpr const & p) { if (!opts2.contains(to_name(car(p)))) r = cons(p, r); }); return options(r); }
/* * The run_benchmarks function will run the registered benchmarks. */ void run_benchmarks(const options& opts) { std::regex match_r(opts.get_bench()); auto benchmarks = registration::get_ptr()->get_benchmarks(); for (auto& info : benchmarks) { if (std::regex_match(info.get_name(), match_r)) { context c(info, opts); auto r = c.run(); std::cout << std::setw(35) << std::left << info.get_name() << r.to_string() << std::endl; } } }
int parse_options(int argc, const char** argv, options& opts) { eagine::program_args args(argc, argv); for(auto a = args.first(); a; a = a.next()) { if(a.is_help_arg()) { opts.print_usage(std::cout); return 1; } else if(!parse_argument(a, opts)) { opts.print_usage(std::cerr); return 2; } } if(!opts.check(std::cerr)) { opts.print_usage(std::cerr); return 3; } return 0; }
bool parse_argument(eagine::program_arg& a, options& opts) { if(!opts.parse(a, std::cerr)) { std::cerr << "Failed to parse argument '" << a.get() << "'" << std::endl; return false; } return true; }
bool options::operator==(const options &rhs) { // iterate over options in the first list for (entry *curentry = m_entrylist.first(); curentry != nullptr; curentry = curentry->next()) if (!curentry->is_header()) { // if the values differ, return false if (strcmp(curentry->value(), rhs.value(curentry->name())) != 0) return false; } return true; }
void display_pos(std::ostream & out, options const & o, char const * strm_name, unsigned line, unsigned pos) { out << strm_name << ":"; if (o.get_bool("flycheck", false)) { // generate valid line and column for flycheck mode if (line == static_cast<unsigned>(-1)) line = 1; if (pos == static_cast<unsigned>(-1)) pos = 0; } if (line != static_cast<unsigned>(-1)) out << line << ":"; if (pos != static_cast<unsigned>(-1)) out << pos << ":"; }
void augd::createsslctxs(sslctxs& sslctxs, const options& options, char* frobpass) { const char* contexts = options.get("ssl.contexts", 0); if (contexts) { istringstream is(contexts); string name; while (is >> name) sslctxs.insert(make_pair(name, createsslctx(name, options, frobpass))); } }
int main (int argc, const char * argv[]) { multiHMM models; opt.set_parameters(commandline,opt_size,usage); opt.parse_commandline(argc,argv); if (!opt.optset("-seq")){ cerr << "No sequence file defined in command line input\n Please check syntax.\n"; //cout << usage << endl; } if (!opt.optset("-model")){ cerr << "No model/models file defined in command line input\n Please check syntax.\n"; //cout << usage << endl; } else{ models.importModels(opt.sopt("-model")); } //for(int i=0;i<models.size();i++){ // models[i].print_model(); //} seqs.load_fastq(models, opt.sopt("-seq")); //int count=1; while(1){ seqSet *job = seqs.getJob(); job->getSidd(); //cout << "Seq:\t" << count <<endl; //count++; job->print_seq(); //cout << job->model <endl; delete job; } return 0; }
bool get_elaborator_lift_coercions(options const & opts) { return opts.get_bool(*g_elaborator_lift_coercions, LEAN_DEFAULT_ELABORATOR_LIFT_COERCIONS); }
bool get_elaborator_fail_missing_field(options const & opts) { return opts.get_bool(*g_elaborator_fail_missing_field, LEAN_DEFAULT_ELABORATOR_FAIL_MISSING_FIELD); }
bool get_elaborator_flycheck_goals(options const & opts) { return opts.get_bool(*g_elaborator_flycheck_goals, LEAN_DEFAULT_ELABORATOR_FLYCHECK_GOALS); }
bool get_elaborator_ignore_instances(options const & opts) { return opts.get_bool(*g_elaborator_ignore_instances, LEAN_DEFAULT_ELABORATOR_IGNORE_INSTANCES); }
bool get_elaborator_local_instances(options const & opts) { return opts.get_bool(*g_elaborator_local_instances, LEAN_DEFAULT_ELABORATOR_LOCAL_INSTANCES); }
int hpx_main(int argc, char* argv[]) { printf("Running\n"); // auto test_fut = hpx::async([]() { // while(1){hpx::this_thread::yield();} // }); // test_fut.get(); try { if (opts.process_options(argc, argv)) { auto all_locs = hpx::find_all_localities(); std::vector<hpx::future<void>> futs; futs.reserve(all_locs.size()); for (auto i = all_locs.begin(); i != all_locs.end(); ++i) { futs.push_back(hpx::async < initialize_action > (*i, opts)); } hpx::when_all(futs).get(); node_client root_id = hpx::new_ < node_server > (hpx::find_here()); node_client root_client(root_id); if (opts.found_restart_file) { set_problem(null_problem); const std::string fname = opts.restart_filename; printf("Loading from %s...\n", fname.c_str()); if (opts.output_only) { const std::string oname = opts.output_filename; root_client.get_ptr().get()->load_from_file_and_output(fname, oname); } else { root_client.get_ptr().get()->load_from_file(fname); root_client.regrid(root_client.get_gid(), true).get(); } printf("Done. \n"); } else { for (integer l = 0; l < opts.max_level; ++l) { root_client.regrid(root_client.get_gid(), false).get(); printf("---------------Created Level %i---------------\n\n", int(l + 1)); } root_client.regrid(root_client.get_gid(), false).get(); printf("---------------Regridded Level %i---------------\n\n", int(opts.max_level)); } std::vector < hpx::id_type > null_sibs(geo::direction::count()); printf("Forming tree connections------------\n"); root_client.form_tree(root_client.get_gid(), hpx::invalid_id, null_sibs).get(); if (gravity_on) { //real tstart = MPI_Wtime(); root_client.solve_gravity(false).get(); // printf("Gravity Solve Time = %e\n", MPI_Wtime() - tstart); } printf("...done\n"); if (!opts.output_only) { // set_problem(null_problem); root_client.start_run(opts.problem == DWD && !opts.found_restart_file).get(); } root_client.report_timing(); } } catch (...) { throw; } printf("Exiting...\n"); return hpx::finalize(); }
bool get_apply_class_instance(options const & opts) { return opts.get_bool(*g_apply_class_instance, LEAN_DEFAULT_APPLY_CLASS_INSTANCE); }
void TestFixture::processOptions(const options& args) { quiet_tests = args.quiet(); gcc_style_errors = args.gcc_style_errors(); }
void HDDP(options & probdata, options & nominal, int & go_to_step, int & current_iter, bool & converged){ double rho; cout << "Iteration " << current_iter << ": "; switch (go_to_step){ // Step 1: Computation of First and Second Order STMs case 1: cout << "Step 1: Computation of First and Second Order STMS \n"; ComputeSTMs(nominal); go_to_step = 2; break; // Step 2: Backward Sweep case 2: cout << "Step 2: Backward Sweep \n"; BackwardSweep(nominal); go_to_step = 3; break; // Step 3: Convergence Check case 3: cout << "Step 3: Convergence Check \n"; if ((abs(nominal.ER(0, 0)) < nominal.tol && (nominal.f < nominal.tol) && (nominal.delta <= nominal.delta_min + 1e-6)) || (nominal.delta <= nominal.delta_min + 1e-6)){ cout << "I think we're done here \n"; //cout << "Feasible Solution Within Tolerance \n"; converged = 1; break; } cout << nominal.ER(0, 0) << " " << nominal.J << " " << nominal.h << " " << nominal.f << " " << nominal.delta << "\n"; cout << probdata.ER(0, 0) << " " << probdata.J << " " << probdata.h << " " << probdata.f << " " << probdata.delta << "\n"; go_to_step = 4; break; // Step 4: Forward Pass case 4: current_iter++; probdata = nominal; cout << "Step 4: Forward Pass \n"; ForwardPass(probdata, nominal); go_to_step = 5; break; // Step 5: Trust Region Update case 5: cout << "Step 5: Trust Region Update \n"; eval_J(probdata); rho = (probdata.J - nominal.J) / probdata.ER(0, 0); if (current_iter < 0){ cout << "Accepted rho = " << rho << "\n"; go_to_step = 6; break; } //(.8 < rho && rho < 1.2){ else if (probdata.J < nominal.J){ cout << "Accepted rho = " << rho << "\n"; go_to_step = 6; break; } // second chance else { nominal.delta = max(nominal.delta*(1. - nominal.kappa), nominal.delta_min); cout << "Rejected rho = " << rho << "\n"; go_to_step = 2; break; } // Step 6: Nominal Solution Update case 6: cout << "Step 6: Nominal Solution Update \n"; rho = (probdata.J - nominal.J) / probdata.ER(0, 0); probdata.Multipliers += nominal.delta_l; /**/ // Update rule from Niu if (probdata.psi.norm() >= nominal.psi.norm()/1.2){ probdata.s = max(1.2*probdata.s, 1.2*probdata.Multipliers.norm()); } else { probdata.s = max(probdata.s, 1.2*probdata.Multipliers.norm()); } eval_J(probdata); nominal = probdata; if (.8 < rho && rho < 1.2){ nominal.delta = min(probdata.delta*pow((1. + probdata.kappa),2.0), probdata.delta_max); go_to_step = 1; // 2 to re-use STM } else if (rho > 0){ nominal.delta = min(probdata.delta*pow((1. + probdata.kappa), 1.0), probdata.delta_max); go_to_step = 1; } else { nominal.delta = max(nominal.delta*(1. - nominal.kappa), nominal.delta_min); go_to_step = 1; } WriteTrajectory(nominal, current_iter); break; } }
transfer_nodes( size_t s, vec3i const & fsize, options const & op, task_manager & tm, size_t fwd_p, size_t bwd_p, bool is_out ) : nodes(s,fsize,op,tm,fwd_p,bwd_p,false,is_out) , biases_(s) , func_() , fwd_dispatch_(s) , bwd_dispatch_(s) , fwd_accumulators_(s) , bwd_accumulators_(s) , fs_(s) , fwd_done_(s) , waiter_(s) { for ( size_t i = 0; i < nodes::size(); ++i ) { fwd_accumulators_[i] = std::make_unique<forward_accumulator>(fsize); bwd_accumulators_[i] = std::make_unique<backward_accumulator>(fsize); } auto type = op.require_as<std::string>("type"); if ( type == "transfer" ) { func_ = get_transfer_function(op); // initialize biases real eta = op.optional_as<real>("eta", 0.0001); real mom = op.optional_as<real>("momentum", 0.0); real wd = op.optional_as<real>("weight_decay", 0.0); for ( auto& b: biases_ ) { b = std::make_unique<bias>(eta, mom, wd); } std::string bias_values; if ( op.contains("biases") ) { bias_values = op.require_as<std::string>("biases"); } else { real biases_raw[nodes::size()]; if ( op.contains("init") ) { auto initf = get_initializator(op); initf->initialize( biases_raw, nodes::size() ); } else { std::fill_n(biases_raw, nodes::size(), 0); } bias_values = std::string( reinterpret_cast<char*>(biases_raw), sizeof(real) * nodes::size() ); } load_biases(biases_, bias_values); } else { ZI_ASSERT(type=="sum"); } }
bool get_parser_show_errors(options const & opts) { return opts.get_bool(g_parser_show_errors, LEAN_DEFAULT_PARSER_SHOW_ERRORS); }
bool get_find_expensive(options const & opts) { return opts.get_bool(*g_find_expensive, LEAN_DEFAULT_FIND_EXPENSIVE); }
unsigned get_find_max_steps(options const & opts) { return opts.get_unsigned(*g_find_max_steps, LEAN_DEFAULT_FIND_MAX_STEPS); }
option_base::option_base(options &parent, pstring help) : m_help(help) { parent.register_option(this); }
double get_meng_paulson_c(options const & o) { return o.get_double(*g_meng_paulson_c, LEAN_DEFAULT_MENG_PAULSON_C); }
inline edges::edges( nodes * in, nodes * out, options const & opts, vec3i const & stride, vec3i const & in_size, task_manager & tm, filter_tag ) : options_(opts) , size_(in_size) , tm_(tm) { size_t n = in->num_out_nodes(); size_t m = out->num_in_nodes(); ZI_ASSERT((n>0)&&m>0); edges_.resize(n*m); filters_.resize(n*m); waiter_.set(n*m); real eta = opts.optional_as<real>("eta", 0.1); real mom = opts.optional_as<real>("momentum", 0.0); real wd = opts.optional_as<real>("weight_decay", 0.0); auto sz = opts.require_as<ovec3i>("size"); size_ = sz; for ( size_t k = 0; k < n*m; ++k ) { filters_[k] = std::make_unique<filter>(sz, eta, mom, wd); } std::string filter_values; if ( opts.contains("filters") ) { filter_values = opts.require_as<std::string>("filters"); } else { size_t n_values = n*m*size_[0]*size_[1]*size_[2]; real * filters_raw = new real[n_values]; auto initf = get_initializator(opts); initf->initialize( filters_raw, n*m*size_[0]*size_[1]*size_[2] ); filter_values = std::string( reinterpret_cast<char*>(filters_raw), sizeof(real) * n_values ); delete [] filters_raw; } load_filters(filters_, size_, filter_values); int does_fft = options_.optional_as<int>("fft", "1"); auto repeat = options_.optional_as<ovec3i>("repeat", "1,1,1"); if ( size_ == vec3i::one ) does_fft = 0; for ( size_t i = 0, k = 0; i < n; ++i ) { for ( size_t j = 0; j < m; ++j, ++k ) { if ( repeat == ovec3i::one ) { if ( does_fft ) { edges_[k] = std::make_unique<fft_filter_edge> (in, i, out, j, tm_, stride, *filters_[k]); } else { edges_[k] = std::make_unique<filter_edge> (in, i, out, j, tm_, stride, *filters_[k]); } } else { if ( does_fft ) { edges_[k] = std::make_unique<fft_filter_ds_edge> (in, i, out, j, tm_, stride, repeat, *filters_[k]); } else { edges_[k] = std::make_unique<filter_ds_edge> (in, i, out, j, tm_, stride, repeat, *filters_[k]); } } } } }
void BackwardSweep(options & nominal){ double x, y, z, xdot, ydot, zdot; double xf, yf, zf, xdotf, ydotf, zdotf; double l0, l1, l2, l3, l4, l5; // Extract some information x = nominal.traj[nominal.nstages][1]; y = nominal.traj[nominal.nstages][2]; z = nominal.traj[nominal.nstages][3]; xdot = nominal.traj[nominal.nstages][4]; ydot = nominal.traj[nominal.nstages][5]; zdot = nominal.traj[nominal.nstages][6]; xf = nominal.r_target[0]; yf = nominal.r_target[1]; zf = nominal.r_target[2]; xdotf = nominal.v_target[0]; ydotf = nominal.v_target[1]; zdotf = nominal.v_target[2]; l0 = nominal.Multipliers(0); l1 = nominal.Multipliers(1); l2 = nominal.Multipliers(2); l3 = nominal.Multipliers(3); l4 = nominal.Multipliers(4); l5 = nominal.Multipliers(5); // Compute Terminal Cost Derivatives Matrix<double> Vl(6, 1), Vll(6, 6, 0.0), Vx(7, 1), Vxx(7, 7, 0.0), Vxl(7, 6); Vl(0,0) = pow(x - xf, 2.0); Vl(1,0) = pow(y - yf, 2.0); Vl(2,0) = pow(z - zf, 2.0); Vl(3,0) = pow(xdot - xdotf, 2.0); Vl(4,0) = pow(ydot - ydotf, 2.0); Vl(5,0) = pow(zdot - zdotf, 2.0); Vx(0,0) = l0*(x*2.0 - xf*2.0); Vx(1,0) = l1*(y*2.0 - yf*2.0); Vx(2,0) = l2*(z*2.0 - zf*2.0); Vx(3,0) = l3*(xdot*2.0 - xdotf*2.0); Vx(4,0) = l4*(ydot*2.0 - ydotf*2.0); Vx(5,0) = l5*(zdot*2.0 - zdotf*2.0); Vx(6,0) = -1.0*nominal.s; Vxx(0,0) = l0*2.0; Vxx(1,1) = l1*2.0; Vxx(2,2) = l2*2.0; Vxx(3,3) = l3*2.0; Vxx(4,4) = l4*2.0; Vxx(5,5) = l5*2.0; Vxl(0,0) = x*2.0 - xf*2.0; Vxl(1,1) = y*2.0 - yf*2.0; Vxl(2,2) = z*2.0 - zf*2.0; Vxl(3,3) = xdot*2.0 - xdotf*2.0; Vxl(4,4) = ydot*2.0 - ydotf*2.0; Vxl(5,5) = zdot*2.0 - zdotf*2.0; // Start Sweeping Matrix<double> lx(7, 1), lxx(7,7), lu(3, 1), luu(3,3), lux(3, 7); nominal.ER = 0.0; for (int stage = nominal.nstages - 1; stage >= 0; stage--){ Matrix<double> identity(3, 3), G, K, A, B, C; // Stage Cost Derivatives lx = 0.0; lxx = 0.0; lux = 0.0; lu = 0.0; luu = 0.0; Matrix<double> u_stage(3, 1); u_stage(0, 0) = nominal.traj[stage][8]; u_stage(1, 0) = nominal.traj[stage][9]; u_stage(2, 0) = nominal.traj[stage][10]; /* for (int i = 0; i < 3; i++){ lu(0, i) = .01*nominal.delta_u[stage](i,0); luu(i, i) = .01*1.0; } */ // Partition the STM Matrix<double> STM = nominal.STMs[stage]; Matrix<double> STMx(7,7), STMu(7,3); for (int i = 0; i < 7; i++) for (int j = 0; j < 7; j++) STMx(i, j) = STM(i, j); for (int i = 0; i < 7; i++) for (int j = 0; j < 3; j++) STMu(i, j) = STM(i, 7 + j); // Partition the STT vector< Matrix<double> > STT, STTxx(7, Matrix<double>(7, 7)), STTuu(3, Matrix<double>(7, 3)), STTux(7, Matrix<double>(7, 3)); for (int i = 0; i < 10; i++) STT.push_back(nominal.STTs[stage + i]); for (int i = 0; i < 7; i++) for (int j = 0; j < 7; j++) for (int k = 0; k < 7; k++) STTxx[i](j, k) = STT[i](j, k); for (int i = 0; i < 3; i++) for (int j = 0; j < 7; j++) for (int k = 0; k < 3; k++) STTuu[i](j, k) = STT[7+i](j,7+k); for (int i = 0; i < 7; i++) for (int j = 0; j < 7; j++) for (int k = 0; k < 3; k++) STTux[i](j, k) = STT[i](j,7+k); // Cost-to-go Derivative Mapping Matrix<double> Jx(7, 1), Jxx(7, 7), Ju(3, 1), Juu(3, 3), Jux(3,7), Jl(1,6), Jll(6,6), Jxl(7,6), Jul(3,6); Matrix<double> Jxx_temp(7, 7), Juu_temp(3, 3), Jux_temp(3, 7); // tensor multiplication for (int i = 0; i < 7; i++){ Jxx_temp.assign_column(i, (Vx.transpose()*STTxx[i]).transpose()); Jux_temp.assign_column(i, (Vx.transpose()*STTux[i]).transpose()); } for (int i = 0; i < 3; i++){ Juu_temp.assign_column(i, (Vx.transpose()*STTuu[i]).transpose()); } Jx = (lx.transpose() + Vx.transpose()*STMx).transpose(); Ju = (lu.transpose() + Vx.transpose()*STMu).transpose(); Jxx = lxx + STMx.transpose() * Vxx * STMx + Jxx_temp; Juu.print_to_screen(); Juu = luu + STMu.transpose() * Vxx * STMu + Juu_temp; Juu.print_to_screen(); Jux = lux + STMu.transpose() * Vxx * STMx + Jux_temp; // Multiplier partials Jl = Vl; Jll = Vll; Matrix<double> VXL(10, 6), JX(10, 6); for (int i = 0; i < 7; i++) for (int j = 0; j < 6; j++) VXL(i, j) = Vxl(i, j); JX = (VXL.transpose()*STM).transpose(); for (int i = 0; i < 7; i++) for (int j = 0; j < 6; j++) Jxl(i, j) = JX(i, j); for (int i = 0; i < 3; i++) for (int j = 0; j < 6; j++) Jul(i, j) = JX(7 + i, j); // TRQP Matrix<double> Juu_inv(3,3); Matrix<double> A_unc(3,1); TRQP(Juu, Ju.transpose(), nominal.delta); Juu_inv = Juu.inverse(); A_unc = Juu_inv*Ju*-1.0; // unconstrained control update for dx = dl = 0 Matrix<double> u_unc(3,1); double u_unc_mag; u_unc = u_stage + A_unc; u_unc_mag = u_unc.norm(); if (u_unc_mag > nominal.Tmax){ // enforce hard constraints with quadratic programming double gc; gc = u_unc_mag - nominal.Tmax; // constraint derivatives Matrix<double> gu(3, 1), gx(7, 1, 0.0); gu(0, 0) = u_unc(0, 0) / u_unc_mag; gu(1, 0) = u_unc(1, 0) / u_unc_mag; gu(2, 0) = u_unc(2, 0) / u_unc_mag; identity.construct_identity_matrix(); G = (gu.transpose()*Juu_inv*gu).inverse()*gu.transpose()*Juu_inv; K = Juu_inv*(identity - gu*G); A = K*Ju*-1.0 - G.transpose()*gc*nominal.delta / max(nominal.delta, (G.transpose()*gc).norm()); B = K.transpose()*Jux*-1.0 - G.transpose()*gx.transpose(); C = K.transpose()*Jul*-1.0; /* // interior-point method Matrix<double> D(3, 3); for (int i = 0; i < 3; i++){ if (Ju(0, i) < 0.0){ D(i, i) = 1.0 / sqrt(nominal.Tmax - (u_stage(i, 0) + A(i, 0))); } else if (Ju(0, i) >= 0.0){ D(i, i) = 1.0 / sqrt((u_stage(i, 0) + A(i, 0)) + nominal.Tmax); } } Juu = (D.inverse())*Juu*(D.inverse().transpose()); TRQP(Juu, Ju, nominal.delta); Juu_inv = Juu.inverse(); A = Juu_inv*Ju.transpose()*-1.0; B = Juu_inv*Jxu.transpose()*-1.0; C = Juu_inv*Jul*-1.0; */ } else { A = A_unc;// -Juu_inv*Ju.transpose(); B = Juu_inv*Jux*-1.0; C = Juu_inv*Jul*-1.0; } // Control Update //B = B*nominal.delta / max(nominal.delta, (B*nominal.dx_prev[stage]).norm()); //C = C*nominal.delta / max(nominal.delta, (C*nominal.delta_l.transpose()).norm()); B = B*A.norm()*10. / max(A.norm()*10., (B*nominal.dx_prev[stage]).norm()); //C = C*A.norm()*10. / max(A.norm()*10., (C*nominal.delta_l.transpose()).norm()); nominal.As[stage] = A; nominal.Bs[stage] = B; nominal.Cs[stage] = C; nominal.ER += Ju.transpose()*A + A.transpose()*Juu*A*0.5; Vx = Jx + (Ju.transpose()*B + A.transpose()*Juu*B + A.transpose()*Jux).transpose(); Vxx = Jxx + B.transpose()*Juu*B + B.transpose()*Jux + Jux.transpose()*B; Vxl = Jxl + B.transpose()*Juu*C + B.transpose()*Jul + Jux.transpose()*C; Vl = Jl + (Ju.transpose()*C + A.transpose()*Juu*C + A.transpose()*Jul).transpose(); Vll = Jll + C.transpose()*Juu*C + C.transpose()*Jul + Jul.transpose()*C; } // TRQP for Multiplier Update Matrix<double> mVll, mVl; mVll = Vll*-1.0; mVl = Vl*-1.0; //- mVl wasn't working TRQP(mVll, mVl.transpose(), nominal.delta); nominal.delta_l = mVll.inverse()*mVl*-1.0; nominal.delta_l = nominal.delta_l.transpose(); Vll = mVll*-1.0; nominal.ER += Vl.transpose()*nominal.delta_l.transpose() + nominal.delta_l*Vll*nominal.delta_l.transpose()*0.5; }