40 DynamicTimeIndexedShootingProblem::DynamicTimeIndexedShootingProblem()
44 DynamicTimeIndexedShootingProblem::~DynamicTimeIndexedShootingProblem() =
default;
46 void DynamicTimeIndexedShootingProblem::InstantiateCostTerms(
const DynamicTimeIndexedShootingProblemInitializer& init)
51 if (parameters_.LossType ==
"L2") loss_type_ = ControlCostLossTermType::L2;
56 if (parameters_.LossType ==
"AdaptiveSmoothL1")
58 smooth_l1_mean_ = Eigen::VectorXd::Zero(scene_->get_num_controls());
59 smooth_l1_std_ = Eigen::VectorXd::Zero(scene_->get_num_controls());
71 if (parameters_.L1Rate.size() == 1)
73 l1_rate_.setConstant(scene_->get_num_controls(), parameters_.L1Rate(0));
75 else if (parameters_.L1Rate.size() == scene_->get_num_controls())
77 l1_rate_ = parameters_.L1Rate;
79 else if (parameters_.L1Rate.size() != 0)
81 ThrowPretty(
"L1Rate has wrong size: expected " << scene_->get_num_controls() <<
", 1, or 0 (default), got " << parameters_.L1Rate.size());
86 l1_rate_.setConstant(scene_->get_num_controls(), 1);
90 if (parameters_.HuberRate.size() == 1)
92 huber_rate_.setConstant(scene_->get_num_controls(), parameters_.HuberRate(0));
94 else if (parameters_.HuberRate.size() == scene_->get_num_controls())
96 huber_rate_ = parameters_.HuberRate;
98 else if (parameters_.HuberRate.size() != 0)
100 ThrowPretty(
"HuberRate has wrong size: expected " << scene_->get_num_controls() <<
", 1, or 0, got " << parameters_.HuberRate.size());
104 huber_rate_.setConstant(scene_->get_num_controls(), 1);
107 control_cost_weight_ = parameters_.ControlCostWeight;
110 void DynamicTimeIndexedShootingProblem::Instantiate(
const DynamicTimeIndexedShootingProblemInitializer& init)
112 this->parameters_ = init;
114 if (!scene_->GetDynamicsSolver())
ThrowPretty(
"DynamicsSolver is not initialised!");
116 const int NX = scene_->get_num_positions() + scene_->get_num_velocities(),
117 NDX = 2 * scene_->get_num_velocities(),
118 NU = scene_->get_num_controls();
119 Qf_ = Eigen::MatrixXd::Identity(NDX, NDX);
120 if (this->parameters_.Qf.rows() > 0)
122 if (this->parameters_.Qf.rows() == NDX)
124 Qf_.diagonal() = this->parameters_.Qf;
128 ThrowNamed(
"Qf dimension mismatch! Expected " << NDX <<
", got " << this->parameters_.Qf.rows());
131 Qf_ *= this->parameters_.Qf_rate;
133 R_ = Eigen::MatrixXd::Identity(scene_->get_num_controls(), scene_->get_num_controls());
134 if (this->parameters_.R.rows() > 0)
136 if (this->parameters_.R.rows() == scene_->get_num_controls())
138 R_.diagonal() = this->parameters_.R;
142 ThrowNamed(
"R dimension mismatch! Expected " << scene_->get_num_controls() <<
", got " << this->parameters_.R.rows());
145 R_ *= this->parameters_.R_rate;
183 bool full_noise_set =
false;
184 Ci_.assign(NX, Eigen::MatrixXd::Zero(NX, NU));
185 if (parameters_.C_rate != 0.0)
189 for (
int i = 0; i < NU; ++i)
190 Ci_.at(NX - NU + i)(NX - NU + i, i) = parameters_.C_rate;
194 ThrowPretty(
"Noise does not work for systems that have NU > NX. This should be fixed in the future.");
198 if (this->parameters_.C.rows() > 0)
200 if (parameters_.C.rows() * parameters_.C.cols() == NX * NU)
202 Eigen::Map<Eigen::MatrixXd> C_map(parameters_.C.data(), NU, NX);
204 for (
int i = 0; i < NX; ++i)
205 Ci_[i].row(i) = C_map.col(i).transpose();
206 full_noise_set =
true;
210 ThrowNamed(
"C dimension mismatch! Expected " << NX <<
"x" << NU <<
", got " << parameters_.C.rows() <<
"x" << parameters_.C.cols());
214 CW_ = this->parameters_.CW_rate * Eigen::MatrixXd::Identity(NX, NX);
215 if (parameters_.CW.rows() > 0)
217 if (parameters_.CW.rows() == NX)
219 CW_.diagonal() = parameters_.CW;
220 full_noise_set =
true;
224 ThrowNamed(
"CW dimension mismatch! Expected " << NX <<
", got " << parameters_.R.rows());
228 if (parameters_.C_rate > 0 || parameters_.CW_rate > 0 || full_noise_set)
230 stochastic_matrices_specified_ =
true;
231 stochastic_updates_enabled_ =
true;
234 T_ = this->parameters_.T;
235 tau_ = this->parameters_.tau;
238 const long double fmod_tau_dt = std::fmod(static_cast<long double>(1000. * tau_), static_cast<long double>(1000. * scene_->GetDynamicsSolver()->get_dt()));
239 if (fmod_tau_dt > 1e-5)
ThrowPretty(
"tau is not a multiple of dt: tau=" << tau_ <<
", dt=" << scene_->GetDynamicsSolver()->get_dt() <<
", mod(" << fmod_tau_dt <<
")");
242 cost.Initialize(this->parameters_.Cost, shared_from_this(), cost_Phi);
244 ApplyStartState(
false);
245 InstantiateCostTerms(init);
246 ReinitializeVariables();
249 void DynamicTimeIndexedShootingProblem::ReinitializeVariables()
251 if (debug_)
HIGHLIGHT_NAMED(
"DynamicTimeIndexedShootingProblem",
"Initialize problem with T=" << T_);
253 const int NX = scene_->get_num_positions() + scene_->get_num_velocities(), NDX = 2 * scene_->get_num_velocities(), NU = scene_->get_num_controls();
255 X_ = Eigen::MatrixXd::Zero(NX, T_);
256 X_star_ = Eigen::MatrixXd::Zero(NX, T_);
257 X_diff_ = Eigen::MatrixXd::Zero(NDX, T_);
258 U_ = Eigen::MatrixXd::Zero(scene_->get_num_controls(), T_ - 1);
261 if (scene_->get_has_quaternion_floating_base())
263 for (
int t = 0; t < T_; ++t)
271 if (this->parameters_.GoalState.rows() > 0)
273 Eigen::MatrixXd goal_state(X_star_);
275 if (this->parameters_.GoalState.rows() == NX)
277 goal_state.col(T_ - 1) = this->parameters_.GoalState;
279 else if (this->parameters_.GoalState.rows() == scene_->get_num_positions())
281 goal_state.col(T_ - 1).head(scene_->get_num_positions()) = this->parameters_.GoalState;
283 else if (this->parameters_.GoalState.rows() == NX * T_)
285 for (
int t = 0; t < T_; ++t)
287 goal_state.col(t) = this->parameters_.GoalState.segment(t * NX, NX);
292 ThrowPretty(
"GoalState has " << this->parameters_.GoalState.rows() <<
" rows, but expected either NX=" << NX <<
" or NQ=" << scene_->get_num_positions() <<
", or NX*T=" << NX * T_);
294 set_X_star(goal_state);
298 if (this->parameters_.StartState.rows() > 0)
300 Eigen::MatrixXd start_state(X_);
301 if (this->parameters_.StartState.rows() == NX)
303 start_state = this->parameters_.StartState.replicate(1, T_);
305 else if (this->parameters_.StartState.rows() == scene_->get_num_positions())
307 for (
int t = 0; t < T_; ++t)
309 start_state.col(t).head(scene_->get_num_positions()) = this->parameters_.StartState;
312 else if (this->parameters_.StartState.rows() == NX * T_)
314 for (
int t = 0; t < T_; ++t)
316 start_state.col(t) = this->parameters_.StartState.segment(t * NX, NX);
321 ThrowPretty(
"StartState has " << this->parameters_.StartState.rows() <<
" rows, but expected either NX=" << NX <<
" or NQ=" << scene_->get_num_positions() <<
", or NX*T=" << NX * T_);
326 Eigen::MatrixXd Q = Eigen::MatrixXd::Identity(NDX, NDX);
327 if (this->parameters_.Q.rows() > 0)
329 if (this->parameters_.Q.rows() == NDX)
331 Q.diagonal() = this->parameters_.Q;
335 ThrowNamed(
"Q dimension mismatch! Expected " << NDX <<
", got " << this->parameters_.Q.rows());
338 Q *= this->parameters_.Q_rate;
345 num_tasks = tasks_.size();
349 for (
int i = 0; i < num_tasks; ++i)
352 length_Phi += tasks_[i]->length;
353 length_jacobian += tasks_[i]->length_jacobian;
358 Phi.assign(T_, y_ref_);
362 dPhi_dx.assign(T_, Eigen::MatrixXd(length_jacobian, scene_->get_num_state_derivative()));
363 dPhi_du.assign(T_, Eigen::MatrixXd(length_jacobian, scene_->get_num_controls()));
368 ddPhi_ddx.assign(T_, Hessian::Constant(length_jacobian, Eigen::MatrixXd::Zero(scene_->get_num_state_derivative(), scene_->get_num_state_derivative())));
369 ddPhi_ddu.assign(T_, Hessian::Constant(length_jacobian, Eigen::MatrixXd::Zero(scene_->get_num_controls(), scene_->get_num_controls())));
370 ddPhi_dxdu.assign(T_, Hessian::Constant(length_jacobian, Eigen::MatrixXd::Zero(scene_->get_num_state_derivative(), scene_->get_num_controls())));
372 cost.ReinitializeVariables(T_, shared_from_this(), cost_Phi);
376 dxdiff_.assign(T_, Eigen::MatrixXd::Zero(NDX, NDX));
377 state_cost_jacobian_.assign(T_, Eigen::VectorXd::Zero(NDX));
378 state_cost_hessian_.assign(T_, Eigen::MatrixXd::Zero(NDX, NDX));
379 general_cost_jacobian_.assign(T_, Eigen::VectorXd::Zero(NDX));
380 general_cost_hessian_.assign(T_, Eigen::MatrixXd::Zero(NDX, NDX));
381 control_cost_jacobian_.assign(T_ - 1, Eigen::VectorXd::Zero(NU));
382 control_cost_hessian_.assign(T_ - 1, Eigen::MatrixXd::Zero(NU, NU));
387 const int& DynamicTimeIndexedShootingProblem::get_T()
const 392 void DynamicTimeIndexedShootingProblem::set_T(
const int& T_in)
396 ThrowNamed(
"Invalid number of timesteps: " << T_in);
399 ReinitializeVariables();
402 const double& DynamicTimeIndexedShootingProblem::get_tau()
const 407 void DynamicTimeIndexedShootingProblem::PreUpdate()
409 PlanningProblem::PreUpdate();
410 for (
int i = 0; i < tasks_.size(); ++i) tasks_[i]->is_used =
false;
416 kinematic_solutions_.clear();
417 kinematic_solutions_.resize(T_);
418 for (
int i = 0; i < T_; ++i) kinematic_solutions_[i] = std::make_shared<KinematicResponse>(*scene_->GetKinematicTree().GetKinematicResponse());
420 if (this->parameters_.WarmStartWithInverseDynamics)
422 for (
int t = 0; t < T_ - 1; ++t)
424 U_.col(t) = scene_->GetDynamicsSolver()->InverseDynamics(X_.col(t));
425 X_.col(t + 1) = scene_->GetDynamicsSolver()->Simulate(X_.col(t), U_.col(t), tau_);
430 Eigen::VectorXd DynamicTimeIndexedShootingProblem::ApplyStartState(
bool update_traj)
432 PlanningProblem::ApplyStartState(update_traj);
436 const Eigen::MatrixXd& DynamicTimeIndexedShootingProblem::get_X()
const 441 Eigen::VectorXd DynamicTimeIndexedShootingProblem::get_X(
int t)
const 443 ValidateTimeIndex(t);
449 if (X_in.rows() != X_.rows() || X_in.cols() != X_.cols())
ThrowPretty(
"Sizes don't match! " << X_.rows() <<
"x" << X_.cols() <<
" vs " << X_in.rows() <<
"x" << X_in.cols());
453 if (scene_->get_has_quaternion_floating_base())
455 for (
int t = 0; t < T_; ++t)
462 const Eigen::MatrixXd& DynamicTimeIndexedShootingProblem::get_U()
const 467 Eigen::VectorXd DynamicTimeIndexedShootingProblem::get_U(
int t)
const 469 ValidateTimeIndex(t);
475 if (U_in.rows() != U_.rows() || U_in.cols() != U_.cols())
ThrowPretty(
"Sizes don't match! " << U_.rows() <<
"x" << U_.cols() <<
" vs " << U_in.rows() <<
"x" << U_in.cols());
479 const Eigen::MatrixXd& DynamicTimeIndexedShootingProblem::get_X_star()
const 486 if (X_star_in.rows() != X_star_.rows() || X_star_in.cols() != X_star_.cols())
ThrowPretty(
"Sizes don't match! " << X_star_.rows() <<
"x" << X_star_.cols() <<
" vs " << X_star_in.rows() <<
"x" << X_star_in.cols());
490 if (scene_->get_has_quaternion_floating_base())
492 for (
int t = 0; t < T_; ++t)
499 const Eigen::MatrixXd& DynamicTimeIndexedShootingProblem::get_Q(
int t)
const 501 ValidateTimeIndex(t);
505 const Eigen::MatrixXd& DynamicTimeIndexedShootingProblem::get_Qf()
const 510 const Eigen::MatrixXd& DynamicTimeIndexedShootingProblem::get_R()
const 517 ValidateTimeIndex(t);
518 if (Q_in.rows() != Q_[t].rows() || Q_in.cols() != Q_[t].cols())
ThrowPretty(
"Dimension mismatch!");
530 if (t >= (T_ - 1) || t < -1)
532 ThrowPretty(
"Requested t=" << t <<
" out of range, needs to be 0 =< t < " << T_ - 1);
539 if (u_in.rows() != scene_->get_num_controls())
541 ThrowPretty(
"Mismatching in size of control vector: " << u_in.rows() <<
" given, expected: " << scene_->get_num_controls());
544 if (x_in.rows() != scene_->get_num_positions() + scene_->get_num_velocities())
546 ThrowPretty(
"Mismatching in size of state vector vector: " << x_in.rows() <<
" given, expected: " << scene_->get_num_positions() + scene_->get_num_velocities());
553 scene_->GetDynamicsSolver()->StateDelta(X_.col(t), X_star_.col(t), X_diff_.col(t));
556 if (num_tasks > 0) UpdateTaskMaps(X_.col(t), U_.col(t), t);
560 scene_->GetKinematicTree().SetKinematicResponse(kinematic_solutions_[t]);
565 std::vector<std::shared_ptr<KinematicResponse>> kinematics_solutions{kinematic_solutions_[t]};
569 kinematics_solutions.emplace_back((t == 0) ? kinematic_solutions_[t] : kinematic_solutions_[t - 1]);
572 PlanningProblem::UpdateMultipleTaskKinematics(kinematics_solutions);
575 X_.col(t + 1) = scene_->GetDynamicsSolver()->Simulate(X_.col(t), U_.col(t), tau_);
578 if (scene_->GetDynamicsSolver()->get_has_state_limits())
580 scene_->GetDynamicsSolver()->ClampToStateLimits(X_.col(t + 1));
584 scene_->GetDynamicsSolver()->StateDelta(X_.col(t + 1), X_star_.col(t + 1), X_diff_.col(t + 1));
587 if (stochastic_matrices_specified_ && stochastic_updates_enabled_)
589 Eigen::VectorXd noise(scene_->get_num_positions() + scene_->get_num_velocities());
590 for (
int i = 0; i < scene_->get_num_positions() + scene_->get_num_velocities(); ++i)
591 noise(i) = standard_normal_noise_(generator_);
593 Eigen::VectorXd control_dependent_noise = std::sqrt(scene_->GetDynamicsSolver()->get_dt()) * get_F(t) * noise;
595 for (
int i = 0; i < scene_->get_num_positions() + scene_->get_num_velocities(); ++i)
596 noise(i) = standard_normal_noise_(generator_);
597 Eigen::VectorXd white_noise = std::sqrt(scene_->GetDynamicsSolver()->get_dt()) * CW_ * noise;
599 X_.col(t + 1) = X_.col(t + 1) + white_noise + control_dependent_noise;
605 if (num_tasks > 0 && t == T_ - 2)
607 UpdateTaskMaps(X_.col(t + 1), Eigen::VectorXd::Zero(scene_->get_num_controls()), t + 1);
610 ++number_of_problem_updates_;
616 if (t >= (T_ - 1) || t < -1)
618 ThrowPretty(
"Requested t=" << t <<
" out of range, needs to be 0 =< t < " << T_ - 1);
625 return Update(X_.col(t), u, t);
632 if (x_in.rows() != scene_->get_num_positions() + scene_->get_num_velocities())
634 ThrowPretty(
"Mismatching in size of state vector vector: " << x_in.rows() <<
" given, expected: " << scene_->get_num_positions() + scene_->get_num_velocities());
638 scene_->GetDynamicsSolver()->StateDelta(X_.col(t), X_star_.col(t), X_diff_.col(t));
642 scene_->GetKinematicTree().SetKinematicResponse(kinematic_solutions_[t]);
647 std::vector<std::shared_ptr<KinematicResponse>> kinematics_solutions{kinematic_solutions_[t]};
651 kinematics_solutions.emplace_back((t == 0) ? kinematic_solutions_[t] : kinematic_solutions_[t - 1]);
654 PlanningProblem::UpdateMultipleTaskKinematics(kinematics_solutions);
656 if (num_tasks > 0) UpdateTaskMaps(X_.col(t), Eigen::VectorXd::Zero(scene_->get_num_controls()), t);
658 ++number_of_problem_updates_;
663 ValidateTimeIndex(t);
668 const Eigen::VectorXd q = scene_->GetDynamicsSolver()->GetPosition(x);
669 scene_->Update(q, static_cast<double>(t) * tau_);
672 Phi[t].SetZero(length_Phi);
676 dPhi_dx[t].setZero();
677 dPhi_du[t].setZero();
682 for (
int i = 0; i < length_jacobian; ++i)
691 for (
int i = 0; i < num_tasks; ++i)
694 if (tasks_[i]->is_used)
698 tasks_[i]->Update(x, u,
699 Phi[t].data.segment(tasks_[i]->start, tasks_[i]->length),
700 dPhi_dx[t].middleRows(tasks_[i]->start_jacobian, tasks_[i]->length_jacobian),
701 dPhi_du[t].middleRows(tasks_[i]->start_jacobian, tasks_[i]->length_jacobian),
702 ddPhi_ddx[t].segment(tasks_[i]->start_jacobian, tasks_[i]->length_jacobian),
703 ddPhi_ddu[t].segment(tasks_[i]->start_jacobian, tasks_[i]->length_jacobian),
704 ddPhi_dxdu[t].segment(tasks_[i]->start_jacobian, tasks_[i]->length_jacobian));
706 else if (flags_ & KIN_J)
708 tasks_[i]->Update(x, u,
709 Phi[t].data.segment(tasks_[i]->start, tasks_[i]->length),
710 dPhi_dx[t].middleRows(tasks_[i]->start_jacobian, tasks_[i]->length_jacobian),
711 dPhi_du[t].middleRows(tasks_[i]->start_jacobian, tasks_[i]->length_jacobian));
715 tasks_[i]->Update(x, u, Phi[t].data.segment(tasks_[i]->start, tasks_[i]->length));
723 cost.Update(Phi[t], dPhi_dx[t], dPhi_du[t], ddPhi_ddx[t], ddPhi_ddu[t], ddPhi_dxdu[t], t);
725 else if (flags_ & KIN_J)
727 cost.Update(Phi[t], dPhi_dx[t], dPhi_du[t], t);
731 cost.Update(Phi[t], t);
735 double DynamicTimeIndexedShootingProblem::GetStateCost(
int t)
const 737 ValidateTimeIndex(t);
738 const double state_cost = X_diff_.col(t).transpose() * Q_[t] * X_diff_.col(t);
739 const double general_cost = cost.ydiff[t].transpose() * cost.S[t] * cost.ydiff[t];
740 return state_cost + general_cost;
743 Eigen::VectorXd DynamicTimeIndexedShootingProblem::GetStateCostJacobian(
int t)
745 ValidateTimeIndex(t);
749 state_cost_jacobian_[t].noalias() = dxdiff_[t].transpose() * Q_[t] * X_diff_.col(t) * 2.0;
753 general_cost_jacobian_[t].noalias() = cost.dPhi_dx[t].transpose() * cost.S[t] * cost.ydiff[t] * 2.0;
755 return state_cost_jacobian_[t] + general_cost_jacobian_[t];
758 Eigen::MatrixXd DynamicTimeIndexedShootingProblem::GetStateCostHessian(
int t)
760 ValidateTimeIndex(t);
764 state_cost_hessian_[t].noalias() = dxdiff_[t].transpose() * Q_[t] * dxdiff_[t];
767 if (scene_->get_has_quaternion_floating_base())
769 Eigen::RowVectorXd xdiffTQ = X_diff_.col(t).transpose() * Q_[t];
771 for (
int i = 0; i < ddxdiff.size(); ++i)
773 state_cost_hessian_[t].noalias() += xdiffTQ(i) * ddxdiff(i);
778 general_cost_hessian_[t].noalias() = cost.dPhi_dx[t].transpose() * cost.S[t] * cost.dPhi_dx[t];
783 Eigen::RowVectorXd ydiffTS = cost.ydiff[t].transpose() * cost.S[t];
784 for (
int i = 0; i < cost.length_jacobian; ++i)
786 general_cost_hessian_[t].noalias() += ydiffTS(i) * cost.ddPhi_ddx[t](i);
790 return 2.0 * state_cost_hessian_[t] + 2.0 * general_cost_hessian_[t];
793 Eigen::MatrixXd DynamicTimeIndexedShootingProblem::GetControlCostHessian(
int t)
795 if (t >= T_ - 1 || t < -1)
797 ThrowPretty(
"Requested t=" << t <<
" out of range, needs to be 0 =< t < " << T_ - 1);
807 control_cost_hessian_[t] = R_ + R_.transpose();
810 for (
int iu = 0; iu < scene_->get_num_controls(); ++iu)
813 control_cost_hessian_[t](iu, iu) +=
smooth_l1_hessian(U_.col(t)[iu], l1_rate_(iu));
818 control_cost_hessian_[t](iu, iu) +=
huber_hessian(U_.col(t)[iu], huber_rate_(iu));
823 return control_cost_weight_ * control_cost_hessian_[t];
826 double DynamicTimeIndexedShootingProblem::GetControlCost(
int t)
const 828 if (t >= T_ - 1 || t < -1)
830 ThrowPretty(
"Requested t=" << t <<
" out of range, needs to be 0 =< t < " << T_ - 1);
842 cost += U_.col(t).cwiseAbs2().cwiseProduct(R_.diagonal()).sum();
845 for (
int iu = 0; iu < scene_->get_num_controls(); ++iu)
855 cost +=
huber_cost(U_.col(t)[iu], huber_rate_(iu));
860 if (!std::isfinite(cost))
864 return control_cost_weight_ * cost;
867 Eigen::VectorXd DynamicTimeIndexedShootingProblem::GetControlCostJacobian(
int t)
869 if (t >= T_ - 1 || t < -1)
871 ThrowPretty(
"Requested t=" << t <<
" out of range, needs to be 0 =< t < " << T_ - 1);
882 control_cost_jacobian_[t].noalias() = R_ * U_.col(t) + R_.transpose() * U_.col(t);
885 for (
int iu = 0; iu < scene_->get_num_controls(); ++iu)
895 control_cost_jacobian_[t](iu) +=
huber_jacobian(U_.col(t)[iu], huber_rate_(iu));
900 return control_cost_weight_ * control_cost_jacobian_[t];
903 Eigen::MatrixXd DynamicTimeIndexedShootingProblem::get_F(
int t)
const 905 if (t >= T_ - 1 || t < -1)
907 ThrowPretty(
"Requested t=" << t <<
" out of range, needs to be 0 =< t < " << T_ - 1);
910 const int NX = scene_->get_num_positions() + scene_->get_num_velocities();
911 Eigen::MatrixXd F(NX, NX);
913 for (
int i = 0; i < NX; ++i)
914 F.col(i) = Ci_[i] * U_.col(t);
920 const Eigen::MatrixXd& DynamicTimeIndexedShootingProblem::GetControlNoiseJacobian(
int column_idx)
const 922 if (column_idx < 0 || column_idx >= scene_->get_num_velocities())
923 ThrowPretty(
"Requested column_idx=" << column_idx <<
" out of range; needs to be 0 <= column_idx < " << scene_->get_num_velocities() - 1);
924 return Ci_[column_idx];
927 void DynamicTimeIndexedShootingProblem::EnableStochasticUpdates()
929 stochastic_updates_enabled_ =
true;
932 void DynamicTimeIndexedShootingProblem::DisableStochasticUpdates()
934 stochastic_updates_enabled_ =
false;
std::vector< TaskVectorEntry > map
double huber_jacobian(double x, double beta)
void NormalizeQuaternionInConfigurationVector(Eigen::Ref< Eigen::VectorXd > q)
double smooth_l1_cost(double x, double beta)
double pseudo_huber_jacobian(double x, double beta)
void SetZero(const int n)
double smooth_l1_hessian(double x, double beta)
double smooth_l1_jacobian(double x, double beta)
const Eigen::Ref< const Eigen::MatrixXd > & MatrixXdRefConst
Eigen::Array< Eigen::MatrixXd, Eigen::Dynamic, 1 > Hessian
void SetDefaultQuaternionInConfigurationVector(Eigen::Ref< Eigen::VectorXd > q)
const Eigen::Ref< const Eigen::VectorXd > & VectorXdRefConst
Convenience wrapper for storing references to sub-matrices/vectors.
double huber_cost(double x, double beta)
#define HIGHLIGHT_NAMED(name, x)
double pseudo_huber_cost(double x, double beta)
double pseudo_huber_hessian(double x, double beta)
void AppendVector(std::vector< Val > &orig, const std::vector< Val > &extra)
double huber_hessian(double x, double beta)
#define REGISTER_PROBLEM_TYPE(TYPE, DERIV)