Guile bindings.

Types

• template <class T>
using c_string = std::unique_ptr< T, c_deleter >
• using main_function_type = void(*)(int, char **)

Classes

• template <class T>
class vtb::guile::Aspect

  Aspect that extends Guile-unaware classes and provides a pointer to the corresponding wrapper object.
• template <int N>
class vtb::guile::Grid_wrapper
• template <class T>
class vtb::guile::Traits
• template <class T>
class vtb::guile::Wrapper

  Foreign object wrapper.

Structs

• template <class T>
struct vtb::guile::Uniform_vector_traits
• struct vtb::guile::Uniform_vector_traits< double >
• struct vtb::guile::Uniform_vector_traits< float >
• struct vtb::guile::Uniform_vector_traits< int >
• struct vtb::guile::c_deleter

Functions

• template <class T>
allocate(const char * name) -> T *
• template <class T>
allocate_pointerless(const char * name) -> T *
• assets_define() -> void
• compartment_to_string(SCM object) -> SCM

  Convert compartment to human-readable string.
• template <class T, class ... Args>
construct_pointerless(const char * name, Args ... args) -> T *
• convert_asset(SCM s_asset, SCM rest) -> SCM

  Convert asset asset using options. Options are specified as rest argument. Output format is specified as output-format option.
• default_policy() -> SCM

  Get default policy.
• template <class Pointer>
define_procedure(const char * name, const char * documentation, Pointer ptr) -> void
• template <int Req, class Pointer>
define_procedure(const char * name, std::array< const char *, Req > req, const char * documentation, Pointer ptr) -> void
• template <int Req, int Opt, class Pointer>
define_procedure(const char * name, std::array< const char *, Req > req, std::array< const char *, Opt > opt, const char * documentation, Pointer ptr) -> void
• template <int Req, int Opt, int Rest, class Pointer>
define_procedure(const char * name, std::array< const char *, Req > req, std::array< const char *, Opt > opt, std::array< const char *, Rest > rest, const char * documentation, Pointer ptr) -> void
• template <class T>
define_type(const char * name) -> SCM
• export_asset(SCM s_asset, SCM rest) -> SCM

  Export asset asset to file using options. Options are specified as rest argument. File path is specified as output-path option.
• export_polyhedron(SCM polyhedron, SCM path, SCM rest) -> SCM

  Export polyhedron to the file specified by path using options.
• template <class T>
finalize(SCM object) -> void
• template <class T>
from_scm(SCM x) -> T
• from_scm< bool >(SCM x) -> bool
• from_scm< double >(SCM x) -> double
• from_scm< float >(SCM x) -> float
• from_scm< int >(SCM x) -> int
• generate_compartments(SCM hull, SCM nrooms) -> SCM

  Generate ship compartments for hull using 3-d grid of size nrooms.
• template <int N>
get_grid_wrapper(SCM object) -> Grid_wrapper< N > *
• template <class T>
get_object(SCM object) -> T *
• template <class T>
get_pointer(SCM object) -> T *
• get_testbed() -> SCM

  Get the current instance of virtual testbed.
• get_wrapper(SCM object) -> Wrapper< std::any > *
• template <class T>
get_wrapper(SCM object) -> Wrapper< T > *
• grid_define() -> void
• grid_dimensions(SCM x) -> int
• template <class T, int N>
grid_from_scm(SCM x) -> vtb::core::Grid< T, N >
• template <class T, int N>
grid_make(const vtb::core::Grid< T, N > & grid) -> SCM
• grid_max(SCM object) -> SCM

  Get grid upper bound.
• grid_min(SCM object) -> SCM

  Get grid lower bound.
• grid_select(SCM object, SCM indices) -> SCM

  Construct new grid by selecting dimensions from the existing grid.
• grid_to_string(SCM object) -> SCM

  Convert grid to human-readable string.
• import_asset(SCM rest) -> SCM

  Import an asset from file using options. Options are specified as rest argument. File path is specified as input-path option.
• import_compartments(SCM path, SCM rest) -> SCM

  Import ship compartments from the file specified by path using options.
• import_hull(SCM path, SCM rest) -> SCM

  Import ship hull from the file specified by path using options.
• import_polyhedron(SCM path, SCM rest) -> SCM

  Import polyhedron from the file specified by path using options.
• is_bound(SCM s) -> bool
• is_grid(SCM object) -> bool
• is_list(SCM s) -> bool
• is_string(SCM s) -> bool
• is_symbol(SCM s) -> bool
• length(SCM s) -> int
• main(int argc, char * argv, main_function_type main) -> void
• make_anlt_wind_solver(SCM rest) -> SCM

  Construct ANLT wind generator and solver.
• make_calm_sea_generator() -> SCM

  Construct calm sea wavy surface generator.
• make_compartment(SCM polyhedron, SCM rest) -> SCM

  Construct ship compartment using polyhedron and optional name.
• make_gerstner_solver(SCM rest) -> SCM

  Construct Gerstner solver.
• make_grid(SCM rest) -> SCM

  Construct multidimensional rectangular grid.
• template <class T>
make_object(SCM type) -> SCM
• make_object(SCM type, const std::any & any) -> SCM
• make_object(SCM type, std::any && any) -> SCM
• template <class T>
make_object(SCM type, std::unique_ptr< T > && ptr) -> SCM
• template <class T>
make_object(SCM type, Aspect< T > * ptr) -> SCM
• template <class T>
make_object(SCM type, Wrapper< T > * wrapper) -> SCM
• make_opencl_context(SCM rest) -> SCM
• make_plane_wave_generator(SCM rest) -> SCM

  Construct plane wave wavy surface generator.
• make_ship(SCM rest) -> SCM

  Construct ship from hull, compartments and mass/displacement/draught.
• make_testbed(SCM rest) -> SCM

  Construct virtual testbed.
• template <class T>
make_type(const char * name) -> SCM
• make_wave(SCM type, SCM rest) -> SCM

  Construct wave from amplitude, length and direction using dispersion relation.
• template <class T>
make_wrapper() -> Wrapper< T > *
• make_wrapper(const std::any & any) -> Wrapper< std::any > *
• make_wrapper(std::any && any) -> Wrapper< std::any > *
• template <class T>
make_wrapper(std::unique_ptr< T > && ptr) -> Wrapper< std::unique_ptr< T > > *
• template <class T>
make_wrapper(Aspect< T > * ptr) -> Wrapper< T > *
• misc_define() -> void
• opencl_platforms() -> SCM
• policy_define() -> void
• policy_from_scm(SCM rhs) -> vtb::core::Policy
• polyhedron_bounding_box(SCM object) -> SCM

  Compute bounding box of the polyhedron.
• polyhedron_bounds(SCM object, SCM dimension) -> SCM

  Compute the extent of the polyhedron in specified dimension.
• polyhedron_centroid(SCM object) -> SCM

  Compute centroid of the polyhedron.
• polyhedron_empty(SCM object) -> SCM

  Check if polyhedron is not initialised.
• polyhedron_flip(SCM object, SCM arg) -> SCM

  Flip the polyhedron relative to the origin in a specified dimension.
• polyhedron_flip_self(SCM object, SCM arg) -> SCM

  Flip the polyhedron relative to the origin in a specified dimension.
• polyhedron_mirror(SCM object, SCM arg) -> SCM

  Mirror the polyhedron relative to the origin in a specified dimension.
• polyhedron_mirror_self(SCM object, SCM arg) -> SCM

  Mirror the polyhedron relative to the origin in a specified dimension.
• polyhedron_move(SCM object, SCM arg) -> SCM

  Move the polyhedron to a specified amount in three dimensions.
• polyhedron_move_self(SCM object, SCM arg) -> SCM

  Move the polyhedron to a specified amount in three dimensions.
• polyhedron_normalise(SCM object) -> SCM

  Compute vertex and face normals.
• polyhedron_normalise_self(SCM object) -> SCM

  Compute vertex and face normals.
• polyhedron_reorder(SCM object) -> SCM

  Fix face winding.
• polyhedron_reorder_self(SCM object) -> SCM

  Fix face winding.
• polyhedron_rotate(SCM object, SCM arg1, SCM arg2) -> SCM

  Rotate the polyhedron relative to the origin in a specified dimension by an angle that is multiple of 90 degrees.
• polyhedron_rotate_self(SCM object, SCM arg1, SCM arg2) -> SCM

  Rotate the polyhedron relative to the origin in a specified dimension by an angle that is multiple of 90 degrees.
• polyhedron_scale(SCM object, SCM arg) -> SCM

  Scale the polyhedron by a specified factor in three dimensions.
• polyhedron_scale_self(SCM object, SCM arg) -> SCM

  Scale the polyhedron by a specified factor in three dimensions.
• polyhedron_signed_volume(SCM object) -> SCM

  Compute signed volume of the polyhedron.
• polyhedron_signed_volume_below(SCM object, SCM dimension, SCM level) -> SCM

  Compute signed volume of the polyhedron below certain level of dimension.
• polyhedron_unique(SCM object) -> SCM

  Remove redundant vertices and faces.
• polyhedron_unique_self(SCM object) -> SCM

  Remove redundant vertices and faces.
• polyhedron_volume(SCM object) -> SCM

  Compute absolute volume of the polyhedron.
• quaternion_define() -> void
• template <class T>
quaternion_from_scm(SCM x) -> vtb::geometry::Quaternion< T >
• template <class T>
quaternion_to_scm(vtb::geometry::Quaternion< T > q) -> SCM
• set_testbed(SCM other) -> SCM

  Replace the current instance of virtual testbed with other.
• ship_compartment_flood(SCM object, SCM name, SCM volume) -> SCM

  Flood one of the compartments.
• ship_compartments(SCM object) -> SCM

  Get ship compartments.
• ship_mass(SCM object) -> SCM

  Get ship mass.
• ship_quaternion(SCM object) -> SCM

  Get ship quaternion.
• ship_quaternion_set(SCM object, SCM q) -> SCM

  Set ship quaternion.
• statistics_columns(SCM object) -> SCM

  Get all columns names.
• statistics_current_row(SCM object) -> SCM

  Get the current row of all columns as an associative list.
• supported_asset_options() -> SCM

  Get a list of supported options for importing, exporting and convert assets.
• supported_policies() -> SCM

  Get a list of supported policies.
• symbol_equal(SCM a, SCM b) -> bool
• testbed_grid(SCM object) -> SCM

  Get simulation grid.
• testbed_gui_pause() -> SCM

  Pause real-time simulation (and screen recording).
• testbed_gui_start() -> SCM

  Start real-time simulation.
• testbed_gui_start_recording() -> SCM

  Start screen recording.
• testbed_gui_stop() -> SCM

  Stop real-time simulation (and screen recording).
• testbed_gui_stop_recording() -> SCM

  Stop screen recording.
• testbed_policy(SCM object, SCM s_policy) -> SCM

  Set testbed policy.
• testbed_reset(SCM object) -> SCM

  Reset testbed state.
• testbed_statistics(SCM object) -> SCM

  Get simulation statistics.
• testbed_step(SCM object, SCM dt) -> SCM

  Simulate one time step dt.
• testbed_time_instant(SCM object) -> SCM

  Get current simulation time instant.
• throw_error(const char * message) -> void
• to_c_string(SCM s) -> c_string< char >
• to_scm(vtb::core::Policy rhs) -> SCM
• template <int N>
to_scm(const blitz::TinyVector< double, N > & x) -> SCM
• to_scm(const std::string & x) -> SCM
• to_scm(const char * x) -> SCM
• to_scm(double x) -> SCM
• to_scm(float x) -> SCM
• to_scm(uint64_t x) -> SCM
• to_scm(int64_t x) -> SCM
• to_scm(uint32_t x) -> SCM
• to_scm(int32_t x) -> SCM
• to_scm(bool x) -> SCM
• template <int N>
to_scm(const blitz::TinyVector< float, N > & x) -> SCM
• to_string(SCM s) -> std::string
• template <class T, int N>
to_vector(SCM x) -> blitz::TinyVector< T, N >
• template <class T>
to_wrapper(SCM object) -> Wrapper< T > *
• vtestbed_gc() -> SCM

  Run garbage collection and all object destructors.
• wave_define() -> void