Core components.

Types

• template <class T, int N>
using Array = ::blitz::Array< T, N >
• template <class T>
using Array1 = Array< T, 1 >
• template <class T>
using Array2 = Array< T, 2 >
• template <class T>
using Array3 = Array< T, 3 >
• template <class T>
using Array4 = Array< T, 4 >
• template <class T, int N>
using Matrix = blitz::TinyMatrix< T, N, N >
• template <class T, int N>
using Vector = blitz::TinyVector< T, N >
• template <class T>
using Vector1 = Vector< T, 1 >
• template <class T>
using Vector2 = Vector< T, 2 >
• template <class T>
using Vector3 = Vector< T, 3 >
• template <class T>
using Vector4 = Vector< T, 4 >
• template <class T, int N>
using Wave_statistics_vector = blitz::TinyVector< Wave_statistics< T >, N >
• using bstream = ::vtb::base::bstream
• using int1 = Vector< int, 1 >
• using int2 = Vector< int, 2 >
• using int3 = Vector< int, 3 >
• using int4 = Vector< int, 4 >
• using mask_array = std::vector< bool >
• using rect2 = blitz::RectDomain< 2 >
• using rect3 = blitz::RectDomain< 3 >
• using rect4 = blitz::RectDomain< 4 >

Enumerations

• enum Centre_of_rotation
• enum Policy
• enum Solver_type

Classes

• template <class T>
class vtb::core::ANLT_wind_solver
• template <class T>
class vtb::core::ANLT_wind_solver_opencl
• template <class T>
class vtb::core::ANLT_wind_solver_openmp
• template <class T, int N>
class vtb::core::ARMA_wavy_surface_generator_base
• template <class T>
class vtb::core::ARMA_wind_solver
• template <class T, int N>
class vtb::core::AR_wavy_surface_generator

  Based on autoregerssive model.
• class vtb::core::Assumptions
• template <class T, int N>
class vtb::core::Autocovariance_matrix_generator

  Autocovariate matrix generator that reduces the size of ACF to match AR model order.
• template <class T>
class vtb::core::Autocovariance_matrix_generator< T, 3 >
• template <class T>
class vtb::core::Autocovariance_matrix_generator< T, 4 >
• template <class T>
class vtb::core::Barycentric_function
• template <class T, int N>
class vtb::core::Bisection
• template <class T>
class vtb::core::Bisection< T, 1 >
• template <class T>
class vtb::core::Calm_sea_generator

  Calm sea generator.
• template <class T, int N>
class vtb::core::Chirp_Z_transform
• template <class T, int N>
class vtb::core::Choi_yule_walker_solver

  Computes AR model coefficients using an order-recursvive method from [2].
• template <class T>
class vtb::core::Circular_buffer

  Fixed-size circular buffer. Used as time series storage.
• template <class T>
class vtb::core::Compartment
• template <class T>
class vtb::core::Compartment_array
• template <class T, int N>
class vtb::core::Convolution

  Multidimensional convolution based on Fourier transform.
• template <class T>
class vtb::core::Equilibrium_position_solver
• template <class T>
class vtb::core::Euler_solver

  Euler initial value problem solver.
• template <class T>
class vtb::core::External_excitation_solver
• template <class T, int N>
class vtb::core::Fixed_point_iteration_yule_walker_solver

  Multi-dimensional solver that determines MA model coefficients from ACF.
• template <class T>
class vtb::core::Flooding_solver
• template <class T, int N>
class vtb::core::Fourier_transform

  $N$-dimensional Fourier transform.
• template <class T, int N>
class vtb::core::Fourier_transform_base

  Base class for all Fourier transforms.
• template <class T, int N>
class vtb::core::Gauss_yule_walker_solver
• template <class T, int N>
class vtb::core::Gerstner_solver

  Trochoidal waves solver named after Gerstner.
• template <class T>
class vtb::core::Gerstner_solver_opencl
• template <class T>
class vtb::core::Gerstner_solver_openmp
• template <class T, int N>
class vtb::core::Grid

  A region defined by start and end index and lower and upper bound for each dimension.
• template <class T, int N, class Function, class Return = T>
class vtb::core::Grid_interpolation
• template <class T>
class vtb::core::Hull
• class vtb::core::Invalid_ARMA_process
• template <class T, int N>
class vtb::core::Irregular_wave_surface_generator

  Wavy surface generator that produces elevation grid for multiple waves.
• template <class T, int N>
class vtb::core::LIPO_solver

  Multi-dimensional optimisation of non-convex functions.
• template <class T, int N>
class vtb::core::Linear_function
• template <class T, class Return = T>
class vtb::core::Linear_function_irregular

  Nearest neighbour weighted interpolation for 3-d fields.
• template <class T, int N>
class vtb::core::Linear_interpolation
• template <class T, Policy P>
class vtb::core::Linear_velocity_potential_solver

  Uses formulae from linear wavy theory.
• template <class T>
class vtb::core::Linear_velocity_potential_solver_base

  Base class for linear velocity potential solver.
• template <class T>
class vtb::core::Linear_velocity_potential_solver_opencl
• template <class T, int N>
class vtb::core::Linear_wave
• template <class T, int N>
class vtb::core::MA_wavy_surface_generator

  Based on moving-average model.
• template <class T>
class vtb::core::Mass_array
• template <class T, int N>
class vtb::core::No_wave

  Calm sea.
• template <class T, class Wave, Policy P = Policy::OpenMP>
class vtb::core::Plane_wave_generator

  Wavy surface generator that produces elevation grid for individual wave.
• template <class T, class Wave>
class vtb::core::Plane_wave_generator_opencl
• template <class T, class Wave>
class vtb::core::Plane_wave_generator_openmp
• template <class T>
class vtb::core::Polynomial
• template <class T, int N>
class vtb::core::Propagating_cosine_wave

  Propagating plane wave which has cosine shape.
• template <class T, int N>
class vtb::core::Propagating_stokes_wave

  Propagating third-order Stokes wave.
• template <class T>
class vtb::core::Propeller
• template <class T>
class vtb::core::Propulsor
• template <class T>
class vtb::core::RKF45

  Runge—Khutta—Fehlberg initial value problem solver.
• template <class T>
class vtb::core::Radial_basis_function

  Radial basis function interpolation.
• template <class T>
class vtb::core::Rudder
• template <class T, int N>
class vtb::core::Shallow_water_wave
• template <class T>
class vtb::core::Ship

  Rigid ship with a mass and translational and angular velocity.
• template <class T, int N>
class vtb::core::Ship_hull_panel

  Triangular ship hull panel (face).
• template <class T>
class vtb::core::Ship_motion_equation

  System of ordinary differential equations of translational and angular ship motion.
• template <class T>
class vtb::core::Ship_motion_solver
• template <class T, int N>
class vtb::core::Standing_cosine_wave

  Standing plane wave which has cosine shape.
• template <class T>
class vtb::core::Statistics
• class vtb::core::Statistics_base
• template <class T, int N>
class vtb::core::Testbed

  Main class for interacting with virtual testbed.
• template <class T, int N>
class vtb::core::Velocity_potential_solver

  Base class for all velocity potential solvers.
• template <class T, int N>
class vtb::core::Wave_base

  Base class for water waves.
• template <class T>
class vtb::core::Wave_pressure_solver

  Base class for all wave pressure solvers.
• template <class T>
class vtb::core::Wave_pressure_solver_opencl
• template <class T>
class vtb::core::Wave_pressure_solver_openmp
• template <class T>
class vtb::core::Wave_table
• template <class T>
class vtb::core::Wave_table_base
• template <class T>
class vtb::core::Wavy_surface_generator

  Base class for wavy surface generators.
• template <class T, int N>
class vtb::core::Wetted_surface_solver
• template <class T, int N>
class vtb::core::Wetted_surface_solver_opencl
• template <class T, int N>
class vtb::core::Wetted_surface_solver_openmp
• template <class T>
class vtb::core::Wind_generator
• template <class T>
class vtb::core::Wind_param
• template <class T, int N>
class vtb::core::Yule_walker_solver

Structs

• template <class T>
struct vtb::core::Mass

  Mass attached to specified point in space.
• template <class T>
struct vtb::core::Wave_half

  A half of the wave with length, number and height of the full wave.
• template <class T>
struct vtb::core::Wave_statistics
• template <class T>
struct vtb::core::is_complex

Variables

• constexpr const Policy default_policy

Functions

• template <class T, int N>
acf_variance(const blitz::Array< T, N > & acf) -> T
• template <class T, int N>
auto_covariance(const blitz::Array< T, N > & rhs) -> blitz::Array< T, N >

  Computes autocovariance function of three-dimensional field.
• template <class T, int N>
autoregression_white_noise_variance(const blitz::Array< T, N > & acf, const blitz::Array< T, N > & phi) -> T
• template <class T, class F>
bisection(T a, T b, F func, T arg_eps, T func_eps, int max_iter) -> T

  One-dimensional bisection.
• template <class T, int N, class F>
bisection(blitz::TinyVector< T, N > a, blitz::TinyVector< T, N > b, F func, const blitz::TinyVector< T, N > & arg_eps, const blitz::TinyVector< T, N > & func_eps, int max_iter) -> blitz::TinyVector< T, N >
• template <class T>
chop_right(const blitz::Array< T, 4 > & rhs, T eps) -> blitz::TinyVector< int, 4 >
• template <class T>
chop_right(const blitz::Array< T, 3 > & rhs, T eps) -> blitz::TinyVector< int, 3 >
• template <class T>
clamp(const Grid< T, 3 > & grid_xyz, const std::vector< Ship_hull_panel< T, 3 >> & panels, Vector< int, 3 > min_shape, Vector< bool, 3 > power_of_two = Vector< bool, 3 >(false)) -> Grid< T, 3 >

  Determine minimum and maximum indices for calculating derivatives using panels and slice the grid.
• template <class T, int N>
clamp(const blitz::TinyVector< T, N > x, const Grid< T, N > & grid) -> blitz::TinyVector< T, N >
• template <class T>
clamp_domain(const Grid< T, 3 > & grid_xyz, const std::vector< Ship_hull_panel< T, 3 >> & panels, Vector< int, 3 > min_shape, Vector< bool, 3 > power_of_two = Vector< bool, 3 >(false)) -> blitz::RectDomain< 3 >
• template <class T>
copy(const std::unique_ptr< T > & ptr) -> std::unique_ptr< T >
• template <class T, int N>
correlation(blitz::Array< T, N > lhs, blitz::Array< T, N > rhs) -> blitz::Array< T, N >
• template <class T, int N>
correlation(blitz::Array< T, N > lhs, blitz::Array< T, N > rhs, Chirp_Z_transform< std::complex< T >, N > & fft) -> blitz::Array< T, N >
• template <class T, int N, class Wave>
courant_number(const Wave & wave, const Grid< T, N > & grid) -> T
• template <class T, int N, class Wave>
courant_number_sum(const Wave & wave, const Grid< T, N > & grid) -> T
• template <class T, int N>
covariance(blitz::Array< T, N > lhs, blitz::Array< T, N > rhs) -> blitz::Array< T, N >
• template <class T, int N>
covariance(blitz::Array< T, N > lhs, blitz::Array< T, N > rhs, Chirp_Z_transform< std::complex< T >, N > & fft) -> blitz::Array< T, N >
• template <class T, int N>
derivative(const blitz::TinyVector< int, N > & idx, int dimension, const T delta, const Array< T, N > & func) -> T
• template <class T, int N>
derivative(const blitz::TinyVector< int, N > & idx, int idx_min, int idx_max, int dimension, const T delta, const Array< T, N > & func) -> T
• template <class T, int N>
derivative(Array< T, N > func, const T delta, int dimension) -> Array< T, N >
• template <class T, int N>
derivative(Array< T, N > func, const T delta, int dimension, Array< T, N > & result) -> void
• template <class T>
find_extrema(blitz::Array< T, 1 > func, const Grid< T, 1 > & grid) -> std::vector< blitz::TinyVector< T, 2 > >

  Find coordinates of minima and maxima of a function.
• template <class T>
find_wave_halves(const std::vector< blitz::TinyVector< T, 2 >> & extrema) -> std::vector< Wave_half< T > >

  Find wave halves from function extrema computed previously.
• template <class T>
find_wave_number_range(blitz::Array< T, 2 > surface, const Grid< T, 2 > & grid) -> Grid< T, 2 >

  Find minimum and maximum wave number for two-dimensional surface.
• template <class T>
find_wave_number_range(const std::vector< Wave_half< T >> & halves) -> Grid< T, 1 >
• template <class T>
find_wave_number_range(const std::vector< Wave_half< T >> & halves, T & min_wave_number, T & max_wave_number) -> void

  Find minimum and maximum wave number from wave halves computed previously.
• template <class T, class ... Args>
flatten(const Args &... args) -> Mass_array< T >
• template <class T>
fma(T a, T x, T b) -> T
• template <class T, int N>
fourier_transform(blitz::Array< T, N > & x, int sign, Wave_table< T > waves) -> void
• template <class T, int N, class Function>
generate(const Grid< T, N > & grid, Function func) -> blitz::Array< T, N >
• template <class T, int N, class Function>
generate(const Grid< T, N > & grid, blitz::Array< T, N > & result, Function func) -> void
• template <class T>
generate(const Grid< T, 1 > & grid) -> blitz::Array< T, 1 >
• template <class T, int N, class Wave>
generate_wave(const Grid< T, N > & grid, Wave wave) -> Array< T, N >
• template <class T, int N, class Wave>
generate_wave(const Grid< T, N > & grid, Array< T, N > & result, Wave wave) -> void
• template <class T, int N, class Wave>
generate_wave(T t, const Grid< T, N > & grid, Wave wave) -> Array< T, N >
• template <class T, int N, class Wave>
generate_wave(T t, const Grid< T, N > & grid, Array< T, N > & result, Wave wave) -> void

  Generate wavy surface for specified wave and spatio-temporal grid.
• template <class T>
gradient(const blitz::TinyVector< int, 4 > & idx, const blitz::TinyVector< T, 4 > & delta, const Array< T, 4 > & func) -> blitz::TinyVector< T, 4 >
• template <class T>
gradient(const blitz::TinyVector< int, 3 > & idx, const blitz::TinyVector< T, 3 > & delta, const Array< T, 3 > & func) -> blitz::TinyVector< T, 3 >
• template <class T, int N>
gradient(const blitz::TinyVector< int, N > & idx, const blitz::TinyVector< T, N > & delta, const Array< T, N > & func) -> blitz::TinyVector< T, N >
• template <class T>
intersect(const vtb::geometry::Triangle< T, 3 > & panel, const Vector< T, 3 > & water_level, std::vector< vtb::geometry::Triangle< T, 3 >> * wet_panels, std::vector< vtb::geometry::Triangle< T, 3 >> * dry_panels, std::vector< vtb::geometry::Line_segment< T, 3 >> * waterline) -> void
• template <class T>
is_negative_infinity(T x) -> bool
• template <class T>
is_positive_infinity(T x) -> bool
• template <class T, int N>
linear_wave_angular_frequency(T length, Vector< T, N > normal) -> T
• template <class T, int N>
linear_wave_angular_frequency(const Vector< T, N > & wave_vector) -> T
• template <class T>
make_anlt_wind_solver(Policy policy) -> std::unique_ptr< ANLT_wind_solver< T > >
• template <class T, Policy P>
make_anlt_wind_solver() -> std::unique_ptr< ANLT_wind_solver< T > >
• template <class T>
make_calm_sea_generator() -> std::unique_ptr< Wavy_surface_generator< T > >
• template <class T, int N>
make_gerstner_solver(Policy policy) -> std::unique_ptr< Gerstner_solver< T, N > >
• template <class T, int N, Policy P>
make_gerstner_solver() -> std::unique_ptr< Gerstner_solver< T, N > >
• template <class T>
make_plane_wave_generator(std::any wave, Policy policy) -> std::unique_ptr< Wavy_surface_generator< T > >
• template <class T, class Wave, Policy P>
make_plane_wave_generator() -> std::unique_ptr< Plane_wave_generator< T, Wave, P > >
• template <class T, class Wave, Policy P>
make_plane_wave_generator(const Wave & wave) -> std::unique_ptr< Plane_wave_generator< T, Wave, P > >
• template <class T>
make_plane_wave_generator_opencl(std::any wave) -> std::unique_ptr< Wavy_surface_generator< T > >
• template <class T>
make_plane_wave_generator_openmp(std::any wave) -> std::unique_ptr< Wavy_surface_generator< T > >
• template <class T, int N, Policy P>
make_velocity_potential_solver() -> std::unique_ptr< Velocity_potential_solver< T, N > >
• template <class T, Policy P>
make_wave_pressure_solver() -> std::unique_ptr< Wave_pressure_solver< T > >
• template <class T, int N, Policy P>
make_wetted_surface_solver() -> std::unique_ptr< Wetted_surface_solver< T, N > >
• template <class T, int N>
moving_average_white_noise_variance(const blitz::Array< T, N > & acf, const blitz::Array< T, N > & theta) -> T
• template <class T>
num_roots_inside_unit_disk(Polynomial< T > p) -> int

  Finds the number of polynomial roots inside the unit disk.
• template <class T>
operator<<(std::ostream & out, const Wave_half< T > & rhs) -> std::ostream &
• template <class T>
operator<<(std::ostream & out, const Wave_statistics< T > & rhs) -> std::ostream &
• template <class T>
operator<<(std::ostream & out, const Ship< T > & rhs) -> std::ostream &
• template <class T>
operator<<(std::ostream & out, const Compartment< T > & rhs) -> std::ostream &
• template <class T>
pow2(const std::complex< T > & x) -> std::complex< T >
• pow2(double x) -> double
• pow2(float x) -> float
• template <class T, int N>
scale(blitz::Array< T, N > x) -> T

  Return the difference between largest and smallest value in the array.
• template <class T>
schur_transform(const Polynomial< T > & p) -> auto

  Schur transform for polynomials with complex coefficients.
• template <class T, int N>
shallow_water_wave_angular_frequency(T length, Vector< T, N > normal, T depth) -> T
• template <class T, int N>
shallow_water_wave_angular_frequency(const blitz::TinyVector< T, N > & k, T depth) -> T
• template <class T, int N>
stokes_wave_angular_frequency(const Vector< T, N > & wave_vector, T amplitude) -> T
• supported_policies() -> std::vector< Policy >

  Get a list of supported policies.
• template <class T>
swap(Polynomial< T > & lhs, Polynomial< T > & rhs) -> void
• template <class T>
swap(Circular_buffer< T > & lhs, Circular_buffer< T > & rhs) -> void
• template <class T>
temporal_wave_statistics(blitz::Array< T, 1 > surface, const Grid< T, 1 > & grid) -> Wave_statistics< T >
• template <class T, int N>
validate_process(blitz::Array< T, N > phi) -> void

  Check AR (MA) process stationarity (invertibility).
• template <class T>
wave_normal(T direction) -> Vector< T, 2 >
• template <class T, int N>
wave_number(T length, Vector< T, N > normal) -> Vector< T, N >
• template <class T, int N>
wave_number_grid(const Wave_statistics_vector< T, N > & waves) -> Grid< T, N >
• template <class T>
wave_statistics(blitz::Array< T, 2 > surface, const Grid< T, 2 > & grid) -> Wave_statistics_vector< T, 2 >