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);
}
