static void parse_tetri(char *tetri_raw, t_tetrimino *t) { char **t_tab; char *t_raw; int i; if (!(t_tab = ft_strsplit(tetri_raw, '\n'))) return (fillit_error_msg_exit("some split failed somewhere")); if (!(t_raw = ft_strnew(16))) return (fillit_error_msg_exit("some malloc failed somewhere")); i = 0; while (t_tab[i]) { ft_strcpy(t_raw + (i * 4), t_tab[i]); i++; } free_tab(&t_tab); t->value = raw_to_binary_represention(t_raw); t->pattern_index = get_matched_pattern_index(t->value); if (t->pattern_index == -1) return (fillit_error_msg_exit("invalid pattern")); t->offset.x = 0; t->offset.y = 0; ft_strdel(&t_raw); set_v(t); }
void Hamiltonian::set_v(boost::python::list v_) { /** Update Hamiltonian velocities (all are real-valued scalars -the components of Python list) - Python-friendly \param[in] v The vector of real-valued velocities to be used for Hamiltonian calculations. The velocities are only needed for vibronic Hamiltonian (adiabatic representation) calculations. Otherwise, they are not used. Only status_adi is set to 0, so only adiabatic Hamiltonian is recomputed. For future: in fact, we only need to update the vibronic Hamiltonian, so we still may save a lot, when adiabatic calculations imply electronic structure calculations */ int sz = boost::python::len(v_); vector<double> tmp_v(sz,0.0); for(int i=0; i<sz; i++) { tmp_v[i] = boost::python::extract<double>(v_[i]); } set_v(tmp_v); }
Edge3D::Edge3D(Node3D* u, Node3D* v): m_u(0), m_v(0) { set_u(u); set_v(v); }
bool atomic_base<Base>::rev_sparse_hes( const vector<Base>& x , const local::pod_vector<size_t>& x_index , const local::pod_vector<size_t>& y_index , const InternalSparsity& for_jac_sparsity , bool* rev_jac_flag , InternalSparsity& rev_hes_sparsity ) { CPPAD_ASSERT_UNKNOWN( for_jac_sparsity.end() == rev_hes_sparsity.end() ); size_t q = rev_hes_sparsity.end(); size_t n = x_index.size(); size_t m = y_index.size(); bool ok = false; size_t thread = thread_alloc::thread_num(); allocate_work(thread); bool zero_empty = true; bool input_empty = false; bool transpose = false; // // vx vector<bool> vx(n); for(size_t j = 0; j < n; j++) vx[j] = x_index[j] != 0; // // note that s and t are vectors so transpose does not matter for bool case vector<bool> bool_s( work_[thread]->bool_s ); vector<bool> bool_t( work_[thread]->bool_t ); // bool_s.resize(m); bool_t.resize(n); // for(size_t i = 0; i < m; i++) { if( y_index[i] > 0 ) bool_s[i] = rev_jac_flag[ y_index[i] ]; } // std::string msg = ": atomic_base.rev_sparse_hes: returned false"; if( sparsity_ == pack_sparsity_enum ) { vectorBool& pack_r( work_[thread]->pack_r ); vectorBool& pack_u( work_[thread]->pack_u ); vectorBool& pack_v( work_[thread]->pack_h ); // pack_v.resize(n * q); // local::get_internal_sparsity( transpose, x_index, for_jac_sparsity, pack_r ); local::get_internal_sparsity( transpose, y_index, rev_hes_sparsity, pack_u ); // ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v, x); if( ! ok ) ok = rev_sparse_hes(vx, bool_s, bool_t, q, pack_r, pack_u, pack_v); if( ! ok ) { msg = afun_name() + msg + " sparsity = pack_sparsity_enum"; CPPAD_ASSERT_KNOWN(false, msg.c_str()); } local::set_internal_sparsity(zero_empty, input_empty, transpose, x_index, rev_hes_sparsity, pack_v ); } else if( sparsity_ == bool_sparsity_enum ) { vector<bool>& bool_r( work_[thread]->bool_r ); vector<bool>& bool_u( work_[thread]->bool_u ); vector<bool>& bool_v( work_[thread]->bool_h ); // bool_v.resize(n * q); // local::get_internal_sparsity( transpose, x_index, for_jac_sparsity, bool_r ); local::get_internal_sparsity( transpose, y_index, rev_hes_sparsity, bool_u ); // ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v, x); if( ! ok ) ok = rev_sparse_hes(vx, bool_s, bool_t, q, bool_r, bool_u, bool_v); if( ! ok ) { msg = afun_name() + msg + " sparsity = bool_sparsity_enum"; CPPAD_ASSERT_KNOWN(false, msg.c_str()); } local::set_internal_sparsity(zero_empty, input_empty, transpose, x_index, rev_hes_sparsity, bool_v ); } else { CPPAD_ASSERT_UNKNOWN( sparsity_ == set_sparsity_enum ); vector< std::set<size_t> >& set_r( work_[thread]->set_r ); vector< std::set<size_t> >& set_u( work_[thread]->set_u ); vector< std::set<size_t> >& set_v( work_[thread]->set_h ); // set_v.resize(n); // local::get_internal_sparsity( transpose, x_index, for_jac_sparsity, set_r ); local::get_internal_sparsity( transpose, y_index, rev_hes_sparsity, set_u ); // ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v, x); if( ! ok ) ok = rev_sparse_hes(vx, bool_s, bool_t, q, set_r, set_u, set_v); if( ! ok ) { msg = afun_name() + msg + " sparsity = set_sparsity_enum"; CPPAD_ASSERT_KNOWN(false, msg.c_str()); } local::set_internal_sparsity(zero_empty, input_empty, transpose, x_index, rev_hes_sparsity, set_v ); } for(size_t j = 0; j < n; j++) { if( x_index[j] > 0 ) rev_jac_flag[ x_index[j] ] |= bool_t[j]; } return ok; }