static void assign_from_expression (mesh_t const & mesh, D & data, T & t, RHS rhs) { // access to the data . Beware, we view it as a *matrix* NOT an array... (crucial for assignment to scalars !) for (size_t u=0; u<mesh.size(); ++u) { target_view_t( data(tqa::range(),tqa::range(),u)) = rhs(mesh[u]); } t = rhs( local::tail::omega(t.shape(),t.size())); // if f is an expression, replace the placeholder with a simple tail. If f is a function callable on freq_infty, // it uses the fact that tail_non_view_t can be casted into freq_infty }
static typename gf_t::data_t make_data(mesh_t const &m, target_shape_t) { return std::vector<Target>(m.size()); }
void add_face(mesh_t& mesh, const mesh_vertex_coord_t& p1, const mesh_vertex_coord_t& p2, const mesh_vertex_coord_t& p3, const mesh_vertex_coord_t& p4) { mesh.emplace_back(p1, p2, p3); mesh.emplace_back(p3, p4, p1); }
bool at_end() const { return (_index == m->size()); }
operator cast_t() const { return m->index_to_point(_index); }
mesh_point operator-() const { return mesh_point{*m, {m->_modulo(-index()[0], 0), m->_modulo(-index()[1], 1), m->_modulo(-index()[2], 2)}}; }
// explicit is important for g[ {1,2}] to disambiguate the mesh_point_t and the mesh_index_t explicit mesh_point(mesh_t const& mesh, mesh_t::index_t const& index) : index3_generator(mesh.get_dimensions(), index), m(&mesh) {}
static data_t make(mesh_t const &m, target_shape_t shape, aux_t ml) { data_t A(join(m.size_of_components(), shape), ml); A() = 0; return A; }
auto __as_meshpt(mesh_t const &m, typename mesh_t::index_t const &r) { return m.modulo_reduce(r); }
linear_index_t linear_index() const { return m->index_to_linear(index()); }
operator domain_pt_t() const { return m->index_to_point(index()); }
static typename gf_t::data_t make(mesh_t const &m, target_shape_t, aux_t) { auto s = m.size_of_components(); std::vector<Target> v(s[1]); return std::vector<std::vector<Target>>(s[0], v); }