🥮 mooncakes.io

    moonbit-plasma

    A MoonBit plasma numerics toolkit for teaching, research prototypes, and lightweight engineering calculations.

    plasma
    simulation
    pic
    vlasov
    numerics
    Download zip
    Version
    0.2.2
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    62

    No dependencies

    #moonbit-plasma

    moonbit-plasma is a pure MoonBit toolkit for deterministic one-dimensional electrostatic plasma models. It provides inspectable numerical kernels for teaching laboratories, research prototypes, regression fixtures, and lightweight engineering calculations.

    #Project positioning

    The library provides a composable path from physical parameters to a reproducible result: construct a grid and species, sample particles or a distribution, deposit charge, solve the electrostatic field, advance the state, and export diagnostics. Its scope is intentionally explicit: this is a 1D electrostatic toolkit, not a claim of a validated MPI/GPU production solver.

    #Core capabilities

    • SI plasma relations, thermal scales, damping estimates, beta, and Alfvén-related helpers.
    • Periodic grids, interpolation, profiles, finite-difference derivatives, and periodic or bounded Poisson solvers.
    • PIC with NGP/CIC/TSC shape functions, multiple species, deterministic sampling, and boundary policies.
    • Simplified Vlasov-Poisson advection with density, velocity marginal, entropy, kinetic energy, positivity, and mass diagnostics.
    • Boris and Verlet integration, analytic fields, collision models, fluid fluxes, spectra, phase-space histograms, and invariant checks.
    • Stable CSV snapshots, benchmark records, verification bundles, and generated public API summaries.

    #Quick start

    moon update
moon check --deny-warn
moon test --deny-warn
moon run cmd/main

    ///|
    test {
      let grid = Grid1D::new(8, 1.0)
      let state = PicState::new(grid, two_stream_particles(16, 1.0, 1.0e5))
      let next = state.run(1.0e-12, 2)
      assert_eq(next.particles.length(), 16)
    }

    #CLI

    moon run cmd/main prints benchmark rows, an aggregate summary, and a deterministic fingerprint. The reported workload is cells × particles × steps; errors are calculated from each run. Custom experiments can use SimulationScenario, PipelineConfig, ExperimentConfig, or PicConfig and export CSV through the library.

    #Architecture

    AreaRepresentative modules
    Physical relations and unitsconstants.mbt, formulas.mbt, physics_relations_ext.mbt, units.mbt
    Grid and field numericsgrid*.mbt, interpolation.mbt, field*.mbt, poisson.mbt, solver_tools.mbt
    Particle and distribution modelspic*.mbt, multispecies.mbt, sampling.mbt, shapes.mbt, vlasov*.mbt
    Boundaries and dynamicsboundary*.mbt, integrators.mbt, magnetic.mbt, collisions.mbt, fluid.mbt
    Analysis and exportmoments.mbt, diagnostics*.mbt, spectra.mbt, phase_space.mbt, dataset.mbt, serialization.mbt
    Reproducibilityscenarios.mbt, orchestration.mbt, benchmark_report.mbt, reproducibility.mbt, verification_bundle.mbt

    Public interfaces are generated with moon info --target all into pkg.generated.mbti.

    #Benchmarks

    The deterministic tiny, medium, and large PIC scenarios report configured sizes, computed charge error, energy drift, work units, and a checksum. Run:

    moon run cmd/main

    The checked-in benchmark report records the output observed during verification; rerun it after changing the toolchain or numerical kernels.

    #Tests and numerical boundaries

    The suite exercises formulas, degenerate grids, periodic wrapping, field reconstruction, charge deposition, Poisson residuals, shape partition of unity, deterministic sampling, species totals, particle boundaries, Vlasov moments, PIC stepping, spectra, phase-space counts, serialization, and benchmark contracts.

    moon test acceptance_test.mbt
moon test advanced_test.mbt
moon test benchmark_test.mbt
moon test physics_test.mbt
moon test system_test.mbt

    #CI and release

    GitHub Actions tests Linux, macOS, and Windows with the current stable MoonBit installer. It runs dependency update, format verification, warning-free checks across stable targets, all tests, generated API verification, and the CLI smoke test. A separate benchmark workflow uploads CLI output, and the release workflow publishes the package to Mooncakes after the same checks.

    #License

    Apache-2.0. See LICENSE.

    ApiEntry

    source
    pub(all) struct ApiEntry {
      name : String
      category : String
      description : String
    } derive(ToJson, 
    Debug    )

    BenchmarkRecord

    source
    pub(all) struct BenchmarkRecord {
      name : String
      cells : Int
      particles : Int
      steps : Int
      work_units : Int
      final_particles : Int
      charge_error : Double
      energy_drift : Double
    } derive(ToJson, 
    Debug    )

    BenchmarkSample

    source
    pub(all) struct BenchmarkSample {
      name : String
      cells : Int
      particles : Int
      steps : Int
      energy : Double
    } derive(ToJson, 
    Debug    )

    BenchmarkSuite

    source
    pub(all) struct BenchmarkSuite {
      records : Array[BenchmarkRecord]
    } derive(ToJson, 
    Debug    )

    BenchmarkSuite::maximum_charge_error

    source
    fn BenchmarkSuite::maximum_charge_error(suite : BenchmarkSuite) -> Double

    BenchmarkSuite::maximum_energy_drift

    source
    fn BenchmarkSuite::maximum_energy_drift(suite : BenchmarkSuite) -> Double

    BenchmarkSuite::total_work

    source
    fn BenchmarkSuite::total_work(suite : BenchmarkSuite) -> Int

    Boundary1D

    source
    pub(all) enum Boundary1D {
      Periodic
      Reflecting
      Absorbing
    } derive(Eq, ToJson, 
    Debug    )

    BoundaryBatchResult

    source
    pub(all) struct BoundaryBatchResult {
      alive : Array[Particle]
      absorbed : Int
      reflected : Int
      wrapped : Int
    } derive(ToJson, 
    Debug    )

    BoundaryResult

    source
    pub(all) struct BoundaryResult {
      x : Double
      v : Double
      alive : Bool
    } derive(ToJson, 
    Debug    )

    CflReport

    source
    pub(all) struct CflReport {
      recommended_dt : Double
      max_displacement : Double
      stable : Bool
    } derive(ToJson, 
    Debug    )

    CollisionKind

    source
    pub(all) enum CollisionKind {
      Elastic
      Drag
      Langevin
      Thermalize
    } derive(Eq, ToJson, 
    Debug    )

    CollisionModel

    source
    pub(all) struct CollisionModel {
      kind : CollisionKind
      rate : Double
      background_velocity : Double
      thermal_speed : Double
    } derive(ToJson, 
    Debug    )

    ConservationReport

    source
    pub(all) struct ConservationReport {
      initial_charge : Double
      final_charge : Double
      charge_drift : Double
      initial_energy : Double
      final_energy : Double
      energy_drift : Double
      particle_count_preserved : Bool
    } derive(ToJson, 
    Debug    )

    ElectricFieldKind

    source
    pub(all) enum ElectricFieldKind {
      Constant
      Sinusoidal
      Gaussian
      Linear
      Pulse
    } derive(Eq, ToJson, 
    Debug    )

    ElectricFieldModel

    source
    pub(all) struct ElectricFieldModel {
      kind : ElectricFieldKind
      amplitude : Double
      offset : Double
      wave_number : Double
      center : Double
      width : Double
      slope : Double
    } derive(ToJson, 
    Debug    )

    EnsembleMember

    source
    pub(all) struct EnsembleMember {
      id : Int
      seed : Int
      diagnostics : Array[PicDiagnostics]
    } derive(ToJson, 
    Debug    )

    EnsembleSummary

    source
    pub(all) struct EnsembleSummary {
      members : Int
      mean_final_energy : Double
      spread_final_energy : Double
      mean_charge_error : Double
      maximum_particle_loss : Int
    } derive(ToJson, 
    Debug    )

    ExperimentConfig

    source
    pub(all) struct ExperimentConfig {
      name : String
      grid : Grid1D
      steps : Int
      dt : Double
    } derive(ToJson, 
    Debug    )

    ExperimentConfig::new

    source
    fn ExperimentConfig::new(name : String, grid : Grid1D, steps : Int, dt : Double) -> ExperimentConfig

    ExperimentReport

    source
    pub(all) struct ExperimentReport {
      name : String
      samples : Array[ExperimentSample]
      final_state : PicState
    } derive(ToJson, 
    Debug    )

    ExperimentSample

    source
    pub(all) struct ExperimentSample {
      step : Int
      time : Double
      particles : Int
      total_charge : Double
      kinetic_energy : Double
      field_energy : Double
      total_energy : Double
      charge_error : Double
    } derive(ToJson, 
    Debug    )

    Field1D

    source
    pub(all) struct Field1D {
      grid : Grid1D
      charge_density : Array[Double]
      electric : Array[Double]
      potential : Array[Double]
    } derive(ToJson, 
    Debug    )

    Field1D::charge_neutrality_error

    source
    fn Field1D::charge_neutrality_error(field : Field1D) -> Double

    Field1D::electric_energy

    source
    fn Field1D::electric_energy(field : Field1D) -> Double

    Field1D::electric_range

    source
    fn Field1D::electric_range(field : Field1D) -> (Double, Double)

    Field1D::new

    source
    fn Field1D::new(grid : Grid1D) -> Field1D

    Field1D::potential_range

    source
    fn Field1D::potential_range(field : Field1D) -> (Double, Double)

    FluidFlux

    source
    pub(all) struct FluidFlux {
      mass : Double
      momentum : Double
      energy : Double
    } derive(ToJson, 
    Debug    )

    FluidState

    source
    pub(all) struct FluidState {
      density : Double
      velocity : Double
      pressure : Double
      energy : Double
    } derive(ToJson, 
    Debug    )

    FluidState::new

    source
    fn FluidState::new(density : Double, velocity : Double, pressure : Double, energy : Double) -> FluidState

    Grid1D

    source
    pub(all) struct Grid1D {
      cells : Int
      length : Double
      dx : Double
    } derive(ToJson, 
    Debug    )

    Grid1D::cell_index

    source
    fn Grid1D::cell_index(grid : Grid1D, x : Double) -> Int

    Grid1D::cell_width

    source
    fn Grid1D::cell_width(grid : Grid1D) -> Double

    Grid1D::cells_count

    source
    fn Grid1D::cells_count(grid : Grid1D) -> Int

    Grid1D::domain_length

    source
    fn Grid1D::domain_length(grid : Grid1D) -> Double

    Grid1D::is_valid

    source
    fn Grid1D::is_valid(grid : Grid1D) -> Bool

    Grid1D::new

    source
    fn Grid1D::new(cells : Int, length : Double) -> Grid1D

    Grid1D::position

    source
    fn Grid1D::position(grid : Grid1D, index : Int) -> Double

    Grid1D::wrap

    source
    fn Grid1D::wrap(grid : Grid1D, x : Double) -> Double

    GridDescriptor

    source
    pub(all) struct GridDescriptor {
      grid : Grid1D
      cell_centers : Array[Double]
      cell_edges : Array[Double]
    } derive(ToJson, 
    Debug    )

    GridReduction

    source
    pub(all) struct GridReduction {
      source_cells : Int
      target_cells : Int
      source_length : Double
      values : Array[Double]
    } derive(ToJson, 
    Debug    )

    HealthCheck

    source
    pub(all) struct HealthCheck {
      name : String
      passed : Bool
      metric : Double
      threshold : Double
      message : String
    } derive(ToJson, 
    Debug    )

    InterpolationMode

    source
    pub(all) enum InterpolationMode {
      Nearest
      Linear
      Quadratic
    } derive(Eq, ToJson, 
    Debug    )

    InterpolationResult

    source
    pub(all) struct InterpolationResult {
      value : Double
      left : Int
      right : Int
      fraction : Double
    } derive(ToJson, 
    Debug    )

    InvariantCheck

    source
    pub(all) struct InvariantCheck {
      name : String
      passed : Bool
      observed : Double
      tolerance : Double
    } derive(ToJson, 
    Debug    )

    MagneticField3D

    source
    pub(all) struct MagneticField3D {
      origin : Vector3
      uniform : Vector3
      gradient : Vector3
    } derive(ToJson, 
    Debug    )

    MagneticField3D::flux_through_area

    source
    fn MagneticField3D::flux_through_area(field : MagneticField3D, position : Vector3, normal : Vector3, area : Double) -> Double

    MagneticField3D::magnitude

    source
    fn MagneticField3D::magnitude(field : MagneticField3D, position : Vector3) -> Double

    MagneticField3D::sample

    source
    fn MagneticField3D::sample(field : MagneticField3D, position : Vector3) -> Vector3

    Matrix2

    source
    pub(all) struct Matrix2 {
      a11 : Double
      a12 : Double
      a21 : Double
      a22 : Double
    } derive(ToJson, 
    Debug    )

    Matrix2::add

    source
    fn Matrix2::add(a : Matrix2, b : Matrix2) -> Matrix2

    Matrix2::determinant

    source
    fn Matrix2::determinant(matrix : Matrix2) -> Double

    Matrix2::identity

    source
    fn Matrix2::identity() -> Matrix2

    Matrix2::inverse

    source
    fn Matrix2::inverse(matrix : Matrix2) -> Matrix2

    Matrix2::multiply

    source
    fn Matrix2::multiply(a : Matrix2, b : Matrix2) -> Matrix2

    Matrix2::multiply_vector

    source
    fn Matrix2::multiply_vector(matrix : Matrix2, vector : MatrixVector2) -> MatrixVector2

    Matrix2::new

    source
    fn Matrix2::new(a11 : Double, a12 : Double, a21 : Double, a22 : Double) -> Matrix2

    Matrix2::scale

    source
    fn Matrix2::scale(a : Matrix2, factor : Double) -> Matrix2

    Matrix2::transpose

    source
    fn Matrix2::transpose(matrix : Matrix2) -> Matrix2

    Matrix2::zero

    source
    fn Matrix2::zero() -> Matrix2

    MatrixVector2

    source
    pub(all) struct MatrixVector2 {
      x : Double
      y : Double
    } derive(Eq, ToJson, 
    Debug    )

    MatrixVector2::add

    source

    MatrixVector2::distance

    source
    fn MatrixVector2::distance(a : MatrixVector2, b : MatrixVector2) -> Double

    MatrixVector2::dot

    source
    fn MatrixVector2::dot(a : MatrixVector2, b : MatrixVector2) -> Double

    MatrixVector2::new

    source
    fn MatrixVector2::new(x : Double, y : Double) -> MatrixVector2

    MatrixVector2::norm

    source
    fn MatrixVector2::norm(a : MatrixVector2) -> Double

    MatrixVector2::scale

    source
    fn MatrixVector2::scale(a : MatrixVector2, factor : Double) -> MatrixVector2

    Moments1D

    source
    pub(all) struct Moments1D {
      density : Array[Double]
      momentum : Array[Double]
      temperature_like : Array[Double]
    } derive(ToJson, 
    Debug    )

    MultiSpeciesState

    source
    pub(all) struct MultiSpeciesState {
      grid : Grid1D
      populations : Array[SpeciesPopulation]
      charge_density : Array[Double]
      field : Field1D
      time : Double
    } derive(ToJson, 
    Debug    )

    MultiSpeciesState::current_density

    source
    fn MultiSpeciesState::current_density(state : MultiSpeciesState) -> Array[Double]

    MultiSpeciesState::flatten

    source

    MultiSpeciesState::kinetic_energy

    source
    fn MultiSpeciesState::kinetic_energy(state : MultiSpeciesState) -> Double

    MultiSpeciesState::new

    source

    MultiSpeciesState::number_density

    source
    fn MultiSpeciesState::number_density(state : MultiSpeciesState) -> Array[Double]

    MultiSpeciesState::particle_count

    source
    fn MultiSpeciesState::particle_count(state : MultiSpeciesState) -> Int

    MultiSpeciesState::population

    source
    fn MultiSpeciesState::population(state : MultiSpeciesState, index : Int) -> SpeciesPopulation?

    MultiSpeciesState::run

    source
    fn MultiSpeciesState::run(state : MultiSpeciesState, dt : Double, steps : Int) -> MultiSpeciesState

    MultiSpeciesState::species_count

    source
    fn MultiSpeciesState::species_count(state : MultiSpeciesState) -> Int

    MultiSpeciesState::step

    source
    fn MultiSpeciesState::step(state : MultiSpeciesState, dt : Double) -> MultiSpeciesState

    MultiSpeciesState::total_charge

    source
    fn MultiSpeciesState::total_charge(state : MultiSpeciesState) -> Double

    MultiSpeciesState::total_energy

    source
    fn MultiSpeciesState::total_energy(state : MultiSpeciesState) -> Double

    MultiSpeciesState::total_mass

    source
    fn MultiSpeciesState::total_mass(state : MultiSpeciesState) -> Double

    NumericTable

    source
    pub(all) struct NumericTable {
      columns : Array[String]
      rows : Array[Array[Double]]
    } derive(ToJson, 
    Debug    )

    NumericTable::add_row

    source
    fn NumericTable::add_row(table : NumericTable, row : Array[Double]) -> Unit

    NumericTable::column

    source
    fn NumericTable::column(table : NumericTable, index : Int) -> String?

    NumericTable::column_count

    source
    fn NumericTable::column_count(table : NumericTable) -> Int

    NumericTable::new

    source
    fn NumericTable::new(columns : Array[String]) -> NumericTable

    NumericTable::row

    source
    fn NumericTable::row(table : NumericTable, index : Int) -> Array[Double]?

    NumericTable::row_count

    source
    fn NumericTable::row_count(table : NumericTable) -> Int

    NumericTable::to_csv

    source
    fn NumericTable::to_csv(table : NumericTable) -> String

    NumericTable::transpose

    source
    fn NumericTable::transpose(table : NumericTable) -> NumericTable

    Observable

    source
    pub(all) struct Observable {
      name : String
      unit : String
      values : Array[Double]
    } derive(ToJson, 
    Debug    )

    Observable::count

    source
    fn Observable::count(observable : Observable) -> Int

    Observable::maximum

    source
    fn Observable::maximum(observable : Observable) -> Double

    Observable::mean

    source
    fn Observable::mean(observable : Observable) -> Double

    Observable::minimum

    source
    fn Observable::minimum(observable : Observable) -> Double

    Observable::new

    source
    fn Observable::new(name : String, unit : String, values : Array[Double]) -> Observable

    Observable::normalize

    source
    fn Observable::normalize(observable : Observable) -> Observable

    Observable::range

    source
    fn Observable::range(observable : Observable) -> Double

    Observable::scale

    source
    fn Observable::scale(observable : Observable, factor : Double) -> Observable

    Observable::shift

    source
    fn Observable::shift(observable : Observable, amount : Double) -> Observable

    Observable::summary

    source
    fn Observable::summary(observable : Observable) -> SeriesSummary

    Observable::to_csv

    source
    fn Observable::to_csv(observable : Observable) -> String

    Particle

    source
    pub(all) struct Particle {
      x : Double
      v : Double
      weight : Double
      charge : Double
      mass : Double
    } derive(ToJson, 
    Debug    )

    Particle::new

    source
    fn Particle::new(x~ : Double, v~ : Double, weight? : Double, charge? : Double, mass? : Double) -> Particle

    PhaseSpaceGrid

    source
    pub(all) struct PhaseSpaceGrid {
      x_bins : Int
      v_bins : Int
      x_min : Double
      x_max : Double
      v_min : Double
      v_max : Double
      counts : Array[Int]
    } derive(ToJson, 
    Debug    )

    PhaseSpaceGrid::index

    source
    fn PhaseSpaceGrid::index(grid : PhaseSpaceGrid, x_index : Int, v_index : Int) -> Int

    PhaseSpaceGrid::new

    source
    fn PhaseSpaceGrid::new(x_bins : Int, v_bins : Int, x_min : Double, x_max : Double, v_min : Double, v_max : Double) -> PhaseSpaceGrid

    PhaseSpaceGrid::total_count

    source
    fn PhaseSpaceGrid::total_count(grid : PhaseSpaceGrid) -> Int

    PhaseSpaceGrid::v_index

    source
    fn PhaseSpaceGrid::v_index(grid : PhaseSpaceGrid, v : Double) -> Int

    PhaseSpaceGrid::v_width

    source
    fn PhaseSpaceGrid::v_width(grid : PhaseSpaceGrid) -> Double

    PhaseSpaceGrid::x_index

    source
    fn PhaseSpaceGrid::x_index(grid : PhaseSpaceGrid, x : Double) -> Int

    PhaseSpaceGrid::x_width

    source
    fn PhaseSpaceGrid::x_width(grid : PhaseSpaceGrid) -> Double

    PicConfig

    source
    pub(all) struct PicConfig {
      grid : Grid1D
      dt : Double
      steps : Int
      shape : ShapeKind
      boundary : Boundary1D
    } derive(ToJson, 
    Debug    )

    PicConfig::new

    source
    fn PicConfig::new(grid : Grid1D, dt : Double, steps : Int) -> PicConfig

    PicConfig::validate

    source
    fn PicConfig::validate(config : PicConfig) -> ValidationReport

    PicConfig::with_boundary

    source
    fn PicConfig::with_boundary(config : PicConfig, boundary : Boundary1D) -> PicConfig

    PicConfig::with_shape

    source
    fn PicConfig::with_shape(config : PicConfig, shape : ShapeKind) -> PicConfig

    PicDiagnostics

    source
    pub(all) struct PicDiagnostics {
      time : Double
      particles : Int
      total_charge : Double
      kinetic_energy : Double
      field_energy : Double
      center_of_mass : Double
      mean_velocity : Double
      velocity_variance : Double
    } derive(ToJson, 
    Debug    )

    PicDiagnostics::from_state

    source
    fn PicDiagnostics::from_state(state : PicState) -> PicDiagnostics

    PicDiagnostics::total_energy

    source
    fn PicDiagnostics::total_energy(d : PicDiagnostics) -> Double

    PicQuality

    source
    pub(all) struct PicQuality {
      finite : Bool
      nonnegative_density : Bool
      energy_drift : Double
      charge_error : Double
    } derive(ToJson, 
    Debug    )

    PicSeriesSummary

    source
    pub(all) struct PicSeriesSummary {
      samples : Int
      particles_initial : Int
      particles_final : Int
      charge_drift : Double
      energy_drift : Double
      maximum_field : Double
    } derive(ToJson, 
    Debug    )

    PicState

    source
    pub(all) struct PicState {
      grid : Grid1D
      particles : Array[Particle]
      field : Field1D
      time : Double
    } derive(ToJson, 
    Debug    )

    PicState::new

    source
    fn PicState::new(grid : Grid1D, particles : Array[Particle]) -> PicState

    PicState::run

    source
    fn PicState::run(state : PicState, dt : Double, steps : Int) -> PicState

    PicState::step

    source
    fn PicState::step(state : PicState, dt : Double) -> PicState

    PipelineConfig

    source
    pub(all) struct PipelineConfig {
      name : String
      grid : Grid1D
      particles : Int
      steps : Int
      dt : Double
      shape : ShapeKind
      boundary : Boundary1D
    } derive(ToJson, 
    Debug    )

    PipelineConfig::new

    source
    fn PipelineConfig::new(name : String, grid : Grid1D, particles : Int, steps : Int, dt : Double) -> PipelineConfig

    PipelineConfig::with_boundary

    source
    fn PipelineConfig::with_boundary(config : PipelineConfig, boundary : Boundary1D) -> PipelineConfig

    PipelineConfig::with_shape

    source
    fn PipelineConfig::with_shape(config : PipelineConfig, shape : ShapeKind) -> PipelineConfig

    PipelineFrame

    source
    pub(all) struct PipelineFrame {
      step : Int
      state : PicState
      diagnostics : PicDiagnostics
    } derive(ToJson, 
    Debug    )

    PipelineResult

    source
    pub(all) struct PipelineResult {
      config : PipelineConfig
      frames : Array[PipelineFrame]
    } derive(ToJson, 
    Debug    )

    PipelineResult::charge_errors

    source
    fn PipelineResult::charge_errors(result : PipelineResult) -> Array[Double]

    PipelineResult::energies

    source
    fn PipelineResult::energies(result : PipelineResult) -> Array[Double]

    PipelineResult::final_frame

    source
    fn PipelineResult::final_frame(result : PipelineResult) -> PipelineFrame?

    PipelineResult::times

    source
    fn PipelineResult::times(result : PipelineResult) -> Array[Double]

    PlasmaBenchmarkCase

    source
    pub(all) struct PlasmaBenchmarkCase {
      name : String
      cells : Int
      particles : Int
      steps : Int
      initial_energy : Double
      final_energy : Double
      charge_error : Double
    } derive(ToJson, 
    Debug    )

    PlasmaBenchmarkReport

    source
    pub(all) struct PlasmaBenchmarkReport {
      cases : Array[PlasmaBenchmarkCase]
      total_steps : Int
    } derive(ToJson, 
    Debug    )

    PoissonResult

    source
    pub(all) struct PoissonResult {
      potential : Array[Double]
      residual : Double
      iterations : Int
      converged : Bool
    } derive(ToJson, 
    Debug    )

    Profile1D

    source
    pub(all) struct Profile1D {
      kind : ProfileKind
      base : Double
      amplitude : Double
      center : Double
      width : Double
      wave_number : Double
      floor : Double
    } derive(ToJson, 
    Debug    )

    ProfileKind

    source
    pub(all) enum ProfileKind {
      Constant
      Gaussian
      Sinusoid
      Ramp
      DoubleHump
      TopHat
    } derive(Eq, ToJson, 
    Debug    )

    QualityMetric

    source
    pub(all) struct QualityMetric {
      name : String
      value : Double
      tolerance : Double
      passed : Bool
    } derive(ToJson, 
    Debug    )

    RandomStream

    source
    pub(all) struct RandomStream {
      state : Int
    } derive(ToJson, 
    Debug    )

    RandomStream::new

    source
    fn RandomStream::new(seed : Int) -> RandomStream

    RandomStream::next_int

    source
    fn RandomStream::next_int(stream : RandomStream) -> Int

    RandomStream::next_signed

    source
    fn RandomStream::next_signed(stream : RandomStream) -> Double

    RandomStream::next_unit

    source
    fn RandomStream::next_unit(stream : RandomStream) -> Double

    RelaxationResult

    source
    pub(all) struct RelaxationResult {
      values : Array[Double]
      residuals : Array[Double]
      iterations : Int
      converged : Bool
    } derive(ToJson, 
    Debug    )

    ReproducibilityManifest

    source
    pub(all) struct ReproducibilityManifest {
      name : String
      seed : Int
      cells : Int
      particles : Int
      steps : Int
      dt : Double
      shape : String
      boundary : String
      toolchain : String
    } derive(ToJson, 
    Debug    )

    ResultFingerprint

    source
    pub(all) struct ResultFingerprint {
      sample_count : Int
      work_units : Int
      charge_error : Double
      energy_drift : Double
      checksum : Int
    } derive(ToJson, 
    Debug    )

    SamplingConfig

    source
    pub(all) struct SamplingConfig {
      count : Int
      seed : Int
      drift : Double
      spread : Double
      profile : Profile1D
    } derive(ToJson, 
    Debug    )

    SamplingConfig::new

    source
    fn SamplingConfig::new(count : Int, seed : Int, drift : Double, spread : Double) -> SamplingConfig

    SamplingConfig::sample

    source
    fn SamplingConfig::sample(config : SamplingConfig, grid : Grid1D) -> Array[Particle]

    SamplingConfig::validate

    source

    SeriesSummary

    source
    pub(all) struct SeriesSummary {
      name : String
      count : Int
      minimum : Double
      maximum : Double
      mean : Double
      rms : Double
      span : Double
    } derive(ToJson, 
    Debug    )

    ShapeContribution

    source
    pub(all) struct ShapeContribution {
      index : Int
      weight : Double
    } derive(ToJson, 
    Debug    )

    ShapeKind

    source
    pub(all) enum ShapeKind {
      NGP
      CIC
      TSC
    } derive(Eq, ToJson, 
    Debug    )

    ShapeWeights

    source
    pub(all) struct ShapeWeights {
      contributions : Array[ShapeContribution]
      total : Double
      count : Int
    } derive(ToJson, 
    Debug    )

    SimulationScenario

    source
    pub(all) struct SimulationScenario {
      name : String
      grid : Grid1D
      particles : Int
      steps : Int
      dt : Double
      boundary : Boundary1D
      shape : ShapeKind
      seed : Int
    } derive(ToJson, 
    Debug    )

    Species

    source
    pub(all) struct Species {
      name : String
      charge : Double
      mass : Double
    } derive(ToJson, 
    Debug    )

    Species::electron

    source
    fn Species::electron() -> Species

    Species::gyro_frequency

    source
    fn Species::gyro_frequency(species : Species, magnetic_field_t : Double) -> Double

    Species::ion

    source
    fn Species::ion(name : String, charge_state : Int, mass_kg : Double) -> Species

    Species::plasma_frequency

    source
    fn Species::plasma_frequency(species : Species, density_m3 : Double) -> Double

    Species::proton

    source
    fn Species::proton() -> Species

    Species::thermal_velocity

    source
    fn Species::thermal_velocity(species : Species, temperature_k : Double) -> Double

    SpeciesPopulation

    source
    pub(all) struct SpeciesPopulation {
      species : Species
      particles : Array[Particle]
    } derive(ToJson, 
    Debug    )

    SpeciesPopulation::charge

    source
    fn SpeciesPopulation::charge(population : SpeciesPopulation) -> Double

    SpeciesPopulation::count

    source
    fn SpeciesPopulation::count(population : SpeciesPopulation) -> Int

    SpeciesPopulation::mass

    source
    fn SpeciesPopulation::mass(population : SpeciesPopulation) -> Double

    SpeciesPopulation::new

    source
    fn SpeciesPopulation::new(species : Species, particles : Array[Particle]) -> SpeciesPopulation

    SpectrumBin

    source
    pub(all) struct SpectrumBin {
      mode : Int
      frequency : Double
      real : Double
      imaginary : Double
      power : Double
    } derive(ToJson, 
    Debug    )

    TimeSeries

    source
    pub(all) struct TimeSeries {
      name : String
      times : Array[Double]
      values : Array[Double]
    } derive(ToJson, 
    Debug    )

    TimeSeries::derivative

    source
    fn TimeSeries::derivative(series : TimeSeries) -> Array[Double]

    TimeSeries::difference

    source
    fn TimeSeries::difference(first : TimeSeries, second : TimeSeries) -> TimeSeries

    TimeSeries::integral

    source
    fn TimeSeries::integral(series : TimeSeries) -> Double

    TimeSeries::is_monotonic_time

    source
    fn TimeSeries::is_monotonic_time(series : TimeSeries) -> Bool

    TimeSeries::last_time

    source
    fn TimeSeries::last_time(series : TimeSeries) -> Double

    TimeSeries::last_value

    source
    fn TimeSeries::last_value(series : TimeSeries) -> Double

    TimeSeries::length

    source
    fn TimeSeries::length(series : TimeSeries) -> Int

    TimeSeries::maximum

    source
    fn TimeSeries::maximum(series : TimeSeries) -> Double

    TimeSeries::mean

    source
    fn TimeSeries::mean(series : TimeSeries) -> Double

    TimeSeries::minimum

    source
    fn TimeSeries::minimum(series : TimeSeries) -> Double

    TimeSeries::moving_average

    source
    fn TimeSeries::moving_average(series : TimeSeries, width : Int) -> Array[Double]

    TimeSeries::new

    source
    fn TimeSeries::new(name : String) -> TimeSeries

    TimeSeries::push

    source
    fn TimeSeries::push(series : TimeSeries, time : Double, value : Double) -> Unit

    TimeSeries::resample

    source
    fn TimeSeries::resample(series : TimeSeries, count : Int) -> TimeSeries

    TimeSeries::scale

    source
    fn TimeSeries::scale(series : TimeSeries, factor : Double) -> TimeSeries

    TimeSeries::shift

    source
    fn TimeSeries::shift(series : TimeSeries, amount : Double) -> TimeSeries

    TimeSeries::summary

    source
    fn TimeSeries::summary(series : TimeSeries) -> SeriesSummary

    TimeSeries::time_span

    source
    fn TimeSeries::time_span(series : TimeSeries) -> Double

    TimeSeries::to_csv

    source
    fn TimeSeries::to_csv(series : TimeSeries) -> String

    UnitScales

    source
    pub(all) struct UnitScales {
      length : Double
      density : Double
      time : Double
      mass : Double
      charge : Double
      temperature : Double
      magnetic : Double
    } derive(ToJson, 
    Debug    )

    UnitScales::si

    source
    fn UnitScales::si(length : Double, density : Double, time : Double) -> UnitScales

    ValidationIssue

    source
    pub(all) struct ValidationIssue {
      code : String
      message : String
      value : Double
    } derive(ToJson, 
    Debug    )

    ValidationReport

    source
    pub(all) struct ValidationReport {
      valid : Bool
      issues : Array[ValidationIssue]
    } derive(ToJson, 
    Debug    )

    Vector3

    source
    pub(all) struct Vector3 {
      x : Double
      y : Double
      z : Double
    } derive(Eq, ToJson, 
    Debug    )

    Vector3::add

    source
    fn Vector3::add(a : Vector3, b : Vector3) -> Vector3

    Vector3::component_max

    source
    fn Vector3::component_max(a : Vector3, b : Vector3) -> Vector3

    Vector3::component_min

    source
    fn Vector3::component_min(a : Vector3, b : Vector3) -> Vector3

    Vector3::cross

    source
    fn Vector3::cross(a : Vector3, b : Vector3) -> Vector3

    Vector3::distance

    source
    fn Vector3::distance(a : Vector3, b : Vector3) -> Double

    Vector3::dot

    source
    fn Vector3::dot(a : Vector3, b : Vector3) -> Double

    Vector3::new

    source
    fn Vector3::new(x : Double, y : Double, z : Double) -> Vector3

    Vector3::norm

    source
    fn Vector3::norm(a : Vector3) -> Double

    Vector3::normalized

    source
    fn Vector3::normalized(a : Vector3) -> Vector3

    Vector3::scale

    source
    fn Vector3::scale(a : Vector3, factor : Double) -> Vector3

    Vector3::sub

    source
    fn Vector3::sub(a : Vector3, b : Vector3) -> Vector3

    Vector3::zero

    source
    fn Vector3::zero() -> Vector3

    VerificationBundle

    source
    pub(all) struct VerificationBundle {
      scenario : SimulationScenario
      manifest : ReproducibilityManifest
      fingerprint : ResultFingerprint
      metrics : Array[QualityMetric]
      invariants : Array[InvariantCheck]
    } derive(ToJson, 
    Debug    )

    VerificationBundle::invariant_report

    source
    fn VerificationBundle::invariant_report(bundle : VerificationBundle) -> String

    VerificationBundle::metric_report

    source
    fn VerificationBundle::metric_report(bundle : VerificationBundle) -> String

    VerificationBundle::passed

    source
    fn VerificationBundle::passed(bundle : VerificationBundle) -> Bool

    VerificationBundle::reproducibility_report

    source
    fn VerificationBundle::reproducibility_report(bundle : VerificationBundle) -> String

    VerificationBundle::summary

    source
    fn VerificationBundle::summary(bundle : VerificationBundle) -> String

    VerificationBundle::to_csv

    source
    fn VerificationBundle::to_csv(bundle : VerificationBundle) -> String

    VerificationBundle::work_units

    source
    fn VerificationBundle::work_units(bundle : VerificationBundle) -> Int

    VerletState

    source
    pub(all) struct VerletState {
      position : Double
      velocity : Double
      acceleration : Double
    } derive(ToJson, 
    Debug    )

    VerletState::new

    source
    fn VerletState::new(position : Double, velocity : Double, acceleration : Double) -> VerletState

    VlasovConfig

    source
    pub(all) struct VlasovConfig {
      grid : Grid1D
      velocity_min : Double
      velocity_max : Double
      velocity_bins : Int
      dt : Double
    } derive(ToJson, 
    Debug    )

    VlasovConfig::dv

    source
    fn VlasovConfig::dv(config : VlasovConfig) -> Double

    VlasovConfig::new

    source
    fn VlasovConfig::new(grid : Grid1D, velocity_min~ : Double, velocity_max~ : Double, velocity_bins~ : Int, dt~ : Double) -> VlasovConfig

    VlasovConfig::velocity

    source
    fn VlasovConfig::velocity(config : VlasovConfig, bin : Int) -> Double

    VlasovState

    source
    pub(all) struct VlasovState {
      config : VlasovConfig
      distribution : Array[Double]
      charge_density : Array[Double]
      time : Double
    } derive(ToJson, 
    Debug    )

    VlasovState::step

    source
    fn VlasovState::step(state : VlasovState) -> VlasovState

    VlasovStepReport

    source
    pub(all) struct VlasovStepReport {
      before_mass : Double
      after_mass : Double
      mass_error : Double
      minimum : Double
      maximum : Double
      time : Double
    } derive(ToJson, 
    Debug    )

    VlasovSummary

    source
    pub(all) struct VlasovSummary {
      density_mean : Double
      density_minimum : Double
      density_maximum : Double
      momentum_mean : Double
      kinetic_energy : Double
      entropy : Double
    } derive(ToJson, 
    Debug    )

    accelerate_particles

    source
    fn accelerate_particles(particles : ArrayView[Particle], acceleration : Double, dt : Double) -> Array[Particle]

    acceleration_from_field

    source
    fn acceleration_from_field(particle : Particle, electric : Double) -> Double

    acceptance_benchmark_csv

    source
    fn acceptance_benchmark_csv() -> String

    acceptance_benchmark_summary

    source
    fn acceptance_benchmark_summary() -> String

    acceptance_fingerprint_csv

    source
    fn acceptance_fingerprint_csv() -> String

    acoustic_mach

    source
    fn acoustic_mach(velocity : Double, sound : Double) -> Double

    add_profile

    source
    fn add_profile(a : ArrayView[Double], b : ArrayView[Double]) -> Array[Double]

    advance_leapfrog

    source
    fn advance_leapfrog(position : Double, velocity : Double, acceleration : Double, dt : Double) -> (Double, Double)

    advance_particles

    source
    fn advance_particles(grid : Grid1D, particles : ArrayView[Particle], electric : ArrayView[Double], dt : Double) -> Array[Particle]

    advance_verlet

    source
    fn advance_verlet(state : VerletState, dt : Double, next_acceleration : Double) -> VerletState

    alfven_speed

    source
    fn alfven_speed(magnetic_field : Double, density : Double, mass : Double) -> Double

    all_close

    source
    fn all_close(a : ArrayView[Double], b : ArrayView[Double], absolute : Double, relative : Double) -> Bool

    all_metrics_pass

    source
    fn all_metrics_pass(metrics : ArrayView[QualityMetric]) -> Bool

    analysis_summary

    source
    fn analysis_summary(values : ArrayView[Double]) -> String

    angular_frequency

    source
    fn angular_frequency(charge : Double, magnetic : Vector3, mass : Double) -> Double

    angular_frequency_from_frequency

    source
    fn angular_frequency_from_frequency(frequency : Double) -> Double

    api_catalog

    source
    fn api_catalog() -> Array[ApiEntry]

    api_catalog_categories

    source
    fn api_catalog_categories() -> Array[String]

    api_catalog_contains

    source
    fn api_catalog_contains(name : String) -> Bool

    api_catalog_to_csv

    source
    fn api_catalog_to_csv() -> String

    apply_boundary

    source
    fn apply_boundary(grid : Grid1D, boundary : Boundary1D, x : Double, v : Double) -> BoundaryResult

    apply_boundary_to_particle

    source
    fn apply_boundary_to_particle(grid : Grid1D, boundary : Boundary1D, particle : Particle) -> Particle?

    apply_collision

    source
    fn apply_collision(particle : Particle, model : CollisionModel, dt : Double, noise : Double) -> Particle

    apply_collisions

    source
    fn apply_collisions(particles : ArrayView[Particle], model : CollisionModel, dt : Double, noise : ArrayView[Double]) -> Array[Particle]

    apply_drag

    source
    fn apply_drag(particle : Particle, rate : Double, dt : Double, background_velocity : Double) -> Particle

    apply_particle_boundary_batch

    source
    fn apply_particle_boundary_batch(grid : Grid1D, boundary : Boundary1D, particles : ArrayView[Particle]) -> BoundaryBatchResult

    apply_reflecting_position

    source
    fn apply_reflecting_position(grid : Grid1D, x : Double, v : Double) -> (Double, Double)

    approximate_log

    source
    fn approximate_log(value : Double) -> Double

    assess_pic_cfl

    source
    fn assess_pic_cfl(grid : Grid1D, maximum_speed~ : Double, dt~ : Double, safety_factor~ : Double) -> CflReport

    assess_pic_quality

    source
    fn assess_pic_quality(state : PicState) -> PicQuality

    assess_vlasov_cfl

    source
    fn assess_vlasov_cfl(config : VlasovConfig) -> CflReport

    autocorrelation

    source
    fn autocorrelation(signal : ArrayView[Double], lag : Int) -> Double

    autocorrelation_series

    source
    fn autocorrelation_series(signal : ArrayView[Double]) -> Array[Double]

    average_reductions

    source
    fn average_reductions(reductions : ArrayView[GridReduction]) -> Array[Double]

    backward_difference

    source
    fn backward_difference(grid : Grid1D, values : ArrayView[Double], index : Int) -> Double

    benchmark_fingerprint_suite

    source
    fn benchmark_fingerprint_suite(suite : BenchmarkSuite) -> Array[ResultFingerprint]

    benchmark_health

    source
    fn benchmark_health(record : BenchmarkRecord) -> Array[HealthCheck]

    benchmark_record_to_json_like

    source
    fn benchmark_record_to_json_like(record : BenchmarkRecord) -> String

    benchmark_report_csv

    source
    fn benchmark_report_csv(report : PlasmaBenchmarkReport) -> String

    benchmark_scenario

    source
    fn benchmark_scenario(scenario : SimulationScenario) -> BenchmarkRecord

    benchmark_suite

    source
    fn benchmark_suite() -> BenchmarkSuite

    benchmark_suite_summary

    source
    fn benchmark_suite_summary(suite : BenchmarkSuite) -> String

    benchmark_suite_to_csv

    source
    fn benchmark_suite_to_csv(suite : BenchmarkSuite) -> String

    benchmark_to_csv

    source
    fn benchmark_to_csv(sample : BenchmarkSample) -> String

    boltzmann_constant

    source
    let boltzmann_constant : Double

    boris_position

    source
    fn boris_position(position : Vector3, velocity : Vector3, dt : Double) -> Vector3

    boris_push

    source
    fn boris_push(velocity : Vector3, electric : Vector3, magnetic : Vector3, dt : Double, charge : Double, mass : Double) -> Vector3

    boundary_loss_fraction

    source
    fn boundary_loss_fraction(result : BoundaryBatchResult, original_count : Int) -> Double

    boundary_name

    source
    fn boundary_name(boundary : Boundary1D) -> String

    boundary_positions

    source
    fn boundary_positions(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

    boundary_reflection_fraction

    source
    fn boundary_reflection_fraction(result : BoundaryBatchResult, original_count : Int) -> Double

    boundary_valid

    source
    fn boundary_valid(grid : Grid1D, particles : ArrayView[Particle]) -> Bool

    boundary_velocity_flux

    source
    fn boundary_velocity_flux(grid : Grid1D, particles : ArrayView[Particle]) -> Double

    boundary_wrap_fraction

    source
    fn boundary_wrap_fraction(result : BoundaryBatchResult, original_count : Int) -> Double

    build_verification_bundle

    source
    fn build_verification_bundle(scenario : SimulationScenario, toolchain : String) -> VerificationBundle

    center_of_mass

    source
    fn center_of_mass(grid : Grid1D, particles : ArrayView[Particle]) -> Double

    central_difference

    source
    fn central_difference(grid : Grid1D, values : ArrayView[Double], index : Int) -> Double

    central_interpolate

    source
    fn central_interpolate(first : Double, second : Double, fraction : Double) -> Double

    cfl_ratio

    source
    fn cfl_ratio(report : CflReport) -> Double

    charge_conservation_error

    source
    fn charge_conservation_error(grid : Grid1D, densities : ArrayView[Array[Double]], expected : Double) -> Double

    charge_neutralize

    source
    fn charge_neutralize(_grid : Grid1D, density : ArrayView[Double]) -> Array[Double]

    charge_series

    source
    fn charge_series(grid : Grid1D, densities : ArrayView[Array[Double]]) -> Array[Double]

    clamp

    source
    fn clamp(value : Double, low : Double, high : Double) -> Double

    clamp_index

    source
    fn clamp_index(index : Int, length : Int) -> Int

    clamp_int

    source
    fn clamp_int(value : Int, low : Int, high : Int) -> Int

    clamp_time_step

    source
    fn clamp_time_step(value : Double, minimum : Double, maximum : Double) -> Double

    cli_help

    source
    fn cli_help() -> String

    collision_energy_loss

    source
    fn collision_energy_loss(particle : Particle, after : Particle) -> Double

    collision_frequency

    source
    fn collision_frequency(density : Double, charge : Double, mass : Double, temperature : Double, log_lambda : Double) -> Double

    collision_model

    source
    fn collision_model(kind : CollisionKind, rate : Double, background_velocity : Double, thermal_speed : Double) -> CollisionModel

    collision_probability

    source
    fn collision_probability(rate : Double, dt : Double) -> Double

    collision_rate_for_species

    source
    fn collision_rate_for_species(species : Species, density : Double, temperature : Double, log_lambda : Double) -> Double

    collision_summary

    source
    fn collision_summary(particles : ArrayView[Particle], model : CollisionModel, dt : Double) -> (Double, Double)

    collision_temperature

    source
    fn collision_temperature(particles : ArrayView[Particle], mass : Double) -> Double

    combine_electric_models

    source
    fn combine_electric_models(first : ElectricFieldModel, second : ElectricFieldModel) -> ElectricFieldModel

    compare_metric_sets

    source
    fn compare_metric_sets(first : ArrayView[QualityMetric], second : ArrayView[QualityMetric]) -> Double

    compare_scenarios

    source
    fn compare_scenarios(first : SimulationScenario, second : SimulationScenario) -> Bool

    config_to_csv

    source
    fn config_to_csv(config : PicConfig) -> String

    conservation_report

    source
    fn conservation_report(charges : ArrayView[Double], energies : ArrayView[Double]) -> ConservationReport

    constant_electric_field

    source
    fn constant_electric_field(value : Double) -> ElectricFieldModel

    convergence_order

    source
    fn convergence_order(errors : ArrayView[Double], step_ratio : Double) -> Double

    copy_values

    source
    fn copy_values(values : ArrayView[Double]) -> Array[Double]

    correlation

    source
    fn correlation(first : ArrayView[Double], second : ArrayView[Double]) -> Double

    coulomb_logarithm

    source
    fn coulomb_logarithm(debye_length_m : Double, impact_parameter_m : Double) -> Double

    covariance

    source
    fn covariance(first : ArrayView[Double], second : ArrayView[Double]) -> Double

    csv_escape

    source
    fn csv_escape(value : String) -> String

    csv_header

    source
    fn csv_header(columns : ArrayView[String]) -> String

    csv_row

    source
    fn csv_row(values : ArrayView[Double]) -> String

    cumulative_series

    source
    fn cumulative_series(values : ArrayView[Double], spacing : Double) -> Array[Double]

    curl_1d

    source
    fn curl_1d(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

    cyclotron_period

    source
    fn cyclotron_period(charge : Double, magnetic : Vector3, mass : Double) -> Double

    debye_length

    source
    fn debye_length(electron_temperature_k : Double, electron_density_m3 : Double) -> Double

    denormalize_charge

    source
    fn denormalize_charge(scales : UnitScales, value : Double) -> Double

    denormalize_density

    source
    fn denormalize_density(scales : UnitScales, value : Double) -> Double

    denormalize_electric_field

    source
    fn denormalize_electric_field(scales : UnitScales, value : Double) -> Double

    denormalize_length

    source
    fn denormalize_length(scales : UnitScales, value : Double) -> Double

    denormalize_mass

    source
    fn denormalize_mass(scales : UnitScales, value : Double) -> Double

    denormalize_temperature

    source
    fn denormalize_temperature(scales : UnitScales, value : Double) -> Double

    denormalize_time

    source
    fn denormalize_time(scales : UnitScales, value : Double) -> Double

    denormalize_velocity

    source
    fn denormalize_velocity(scales : UnitScales, value : Double) -> Double

    deposit_charge

    source
    fn deposit_charge(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

    deposit_charge_with_shape

    source
    fn deposit_charge_with_shape(grid : Grid1D, particles : ArrayView[Particle], kind : ShapeKind) -> Array[Double]

    deposit_number_with_shape

    source
    fn deposit_number_with_shape(grid : Grid1D, particles : ArrayView[Particle], kind : ShapeKind) -> Array[Double]

    deposit_with_shape

    source
    fn deposit_with_shape(grid : Grid1D, positions : ArrayView[Double], values : ArrayView[Double], kind : ShapeKind) -> Array[Double]

    describe_grid

    source
    fn describe_grid(grid : Grid1D) -> GridDescriptor

    deterministic_seed

    source
    fn deterministic_seed(name : String, salt : Int) -> Int

    diagnostics_to_csv

    source
    fn diagnostics_to_csv(samples : ArrayView[PicDiagnostics]) -> String

    diagonal_solve

    source
    fn diagonal_solve(diagonal : ArrayView[Double], right_hand_side : ArrayView[Double]) -> Array[Double]

    dimensionless_length

    source
    fn dimensionless_length(length : Double, scale : Double) -> Double

    dimensionless_time

    source
    fn dimensionless_time(time : Double, frequency : Double) -> Double

    dipole_magnetic_field

    source
    fn dipole_magnetic_field(moment : Vector3, position : Vector3, coefficient : Double) -> Vector3

    discrete_spectrum

    source
    fn discrete_spectrum(signal : ArrayView[Double]) -> Array[SpectrumBin]

    distribution_entropy

    source
    fn distribution_entropy(state : VlasovState) -> Double

    distribution_integral

    source
    fn distribution_integral(state : VlasovState) -> Double

    distribution_is_nonnegative

    source
    fn distribution_is_nonnegative(distribution : ArrayView[Double]) -> Bool

    distribution_kinetic_energy

    source
    fn distribution_kinetic_energy(state : VlasovState, mass : Double) -> Double

    distribution_mass_error

    source
    fn distribution_mass_error(config : VlasovConfig, left : ArrayView[Double], right : ArrayView[Double]) -> Double

    distribution_maximum

    source
    fn distribution_maximum(state : VlasovState) -> Double

    distribution_mean_velocity

    source
    fn distribution_mean_velocity(config : VlasovConfig, distribution : ArrayView[Double]) -> Double

    distribution_minimum

    source
    fn distribution_minimum(state : VlasovState) -> Double

    distribution_negative_mass

    source
    fn distribution_negative_mass(state : VlasovState) -> Double

    distribution_positive_part

    source
    fn distribution_positive_part(state : VlasovState) -> Array[Double]

    distribution_sum

    source
    fn distribution_sum(config : VlasovConfig, distribution : ArrayView[Double]) -> Double

    distribution_temperature_like

    source
    fn distribution_temperature_like(config : VlasovConfig, distribution : ArrayView[Double]) -> Double

    divergence_periodic

    source
    fn divergence_periodic(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

    dominant_frequency

    source
    fn dominant_frequency(spectrum : ArrayView[SpectrumBin]) -> Int

    downsample_mean

    source
    fn downsample_mean(values : ArrayView[Double], factor : Int) -> Array[Double]

    drag_factor

    source
    fn drag_factor(rate : Double, dt : Double) -> Double

    drift_series

    source
    fn drift_series(values : ArrayView[Double]) -> Array[Double]

    electric_field_value

    source
    fn electric_field_value(model : ElectricFieldModel, x : Double) -> Double

    electric_field_values

    source
    fn electric_field_values(grid : Grid1D, model : ElectricFieldModel) -> Array[Double]

    electric_force

    source
    fn electric_force(charge : Double, electric : Vector3) -> Vector3

    electric_from_potential

    source
    fn electric_from_potential(grid : Grid1D, potential : ArrayView[Double]) -> Array[Double]

    electric_potential_value

    source
    fn electric_potential_value(model : ElectricFieldModel, x : Double) -> Double

    electron_mass

    source
    let electron_mass : Double

    electron_plasma_frequency

    source
    fn electron_plasma_frequency(electron_density_m3 : Double) -> Double

    electron_thermal_velocity

    source
    fn electron_thermal_velocity(temperature_k : Double) -> Double

    electrostatic_energy

    source
    fn electrostatic_energy(grid : Grid1D, electric : ArrayView[Double]) -> Double

    electrostatic_energy_density

    source
    fn electrostatic_energy_density(electric : ArrayView[Double]) -> Array[Double]

    elementary_charge

    source
    let elementary_charge : Double

    energy_series

    source
    fn energy_series(particles : ArrayView[Array[Particle]], fields : ArrayView[Field1D]) -> Array[Double]

    ensemble_charge_errors

    source
    fn ensemble_charge_errors(members : ArrayView[EnsembleMember]) -> Array[Double]

    ensemble_diagnostics_to_csv

    source
    fn ensemble_diagnostics_to_csv(members : ArrayView[EnsembleMember]) -> String

    ensemble_final_energies

    source
    fn ensemble_final_energies(members : ArrayView[EnsembleMember]) -> Array[Double]

    ensemble_particle_losses

    source
    fn ensemble_particle_losses(members : ArrayView[EnsembleMember]) -> Array[Int]

    ensemble_passes

    source
    fn ensemble_passes(summary : EnsembleSummary, charge_tolerance : Double, energy_spread_tolerance : Double) -> Bool

    ensemble_summary_to_csv

    source
    fn ensemble_summary_to_csv(summary : EnsembleSummary) -> String

    estimate_landau_rate

    source
    fn estimate_landau_rate(wave_number : Double, temperature : Double, density : Double) -> Double

    euler_flux

    source
    fn euler_flux(state : FluidState, _gamma : Double) -> FluidFlux

    expected_output_schema

    source
    fn expected_output_schema() -> String

    expected_sample_count

    source
    fn expected_sample_count(scenario : SimulationScenario) -> Int

    expected_work_units

    source
    fn expected_work_units(scenario : SimulationScenario) -> Int

    experiment_charge_error

    source
    fn experiment_charge_error(report : ExperimentReport) -> Double

    experiment_energy_drift

    source
    fn experiment_energy_drift(report : ExperimentReport) -> Double

    experiment_energy_series

    source
    fn experiment_energy_series(report : ExperimentReport) -> Array[Double]

    experiment_particle_counts

    source
    fn experiment_particle_counts(report : ExperimentReport) -> Array[Int]

    experiment_passes_charge_tolerance

    source
    fn experiment_passes_charge_tolerance(report : ExperimentReport, tolerance : Double) -> Bool

    experiment_passes_energy_tolerance

    source
    fn experiment_passes_energy_tolerance(report : ExperimentReport, tolerance : Double) -> Bool

    experiment_summary

    source
    fn experiment_summary(report : ExperimentReport) -> String

    experiment_times

    source
    fn experiment_times(report : ExperimentReport) -> Array[Double]

    experiment_to_csv

    source
    fn experiment_to_csv(report : ExperimentReport) -> String

    field_add

    source
    fn field_add(first : ArrayView[Double], second : ArrayView[Double]) -> Array[Double]

    field_difference

    source
    fn field_difference(first : ArrayView[Double], second : ArrayView[Double]) -> Array[Double]

    field_energy

    source
    fn field_energy(field : Field1D) -> Double

    field_invariants

    source
    fn field_invariants(field : Field1D) -> Array[InvariantCheck]

    field_l2_error

    source
    fn field_l2_error(first : ArrayView[Double], second : ArrayView[Double]) -> Double

    field_line_step

    source
    fn field_line_step(position : Vector3, field : MagneticField3D, step : Double) -> Vector3

    field_maximum

    source
    fn field_maximum(values : ArrayView[Double]) -> Double

    field_mean_abs

    source
    fn field_mean_abs(values : ArrayView[Double]) -> Double

    field_model_energy

    source
    fn field_model_energy(grid : Grid1D, model : ElectricFieldModel) -> Double

    field_model_force

    source
    fn field_model_force(model : ElectricFieldModel, charge : Double, x : Double) -> Double

    field_model_mean

    source
    fn field_model_mean(grid : Grid1D, model : ElectricFieldModel) -> Double

    field_model_name

    source
    fn field_model_name(model : ElectricFieldModel) -> String

    field_model_work

    source
    fn field_model_work(model : ElectricFieldModel, charge : Double, start : Double, stop : Double, samples : Int) -> Double

    field_quality_metrics

    source
    fn field_quality_metrics(grid : Grid1D, field : Field1D) -> Array[QualityMetric]

    field_residual

    source
    fn field_residual(grid : Grid1D, electric : ArrayView[Double], charge_density : ArrayView[Double]) -> Array[Double]

    field_residual_norm

    source
    fn field_residual_norm(grid : Grid1D, electric : ArrayView[Double], charge_density : ArrayView[Double]) -> Double

    field_scale

    source
    fn field_scale(values : ArrayView[Double], factor : Double) -> Array[Double]

    field_to_csv

    source
    fn field_to_csv(field : Field1D) -> String

    fill_like

    source
    fn fill_like(values : ArrayView[Double], value : Double) -> Array[Double]

    fingerprint_diagnostics

    source
    fn fingerprint_diagnostics(values : ArrayView[PicDiagnostics]) -> Int

    fingerprint_from_scenario

    source
    fn fingerprint_from_scenario(scenario : SimulationScenario) -> ResultFingerprint

    fingerprint_integer

    source
    fn fingerprint_integer(value : Double) -> Int

    fingerprint_suite_to_csv

    source
    fn fingerprint_suite_to_csv(suite : BenchmarkSuite) -> String

    fingerprint_to_csv

    source
    fn fingerprint_to_csv(fingerprint : ResultFingerprint) -> String

    fingerprint_values

    source
    fn fingerprint_values(values : ArrayView[Double]) -> Int

    fingerprints_equal

    source
    fn fingerprints_equal(first : ResultFingerprint, second : ResultFingerprint) -> Bool

    finite_difference_first

    source
    fn finite_difference_first(values : ArrayView[Double], spacing : Double) -> Array[Double]

    finite_difference_second

    source
    fn finite_difference_second(values : ArrayView[Double], spacing : Double) -> Array[Double]

    finite_difference_series

    source
    fn finite_difference_series(values : ArrayView[Double], spacing : Double) -> Array[Double]

    fluid_cfl_dt

    source
    fn fluid_cfl_dt(states : ArrayView[FluidState], gamma : Double, cell_width : Double, cfl : Double) -> Double

    fluid_clamp_physical

    source
    fn fluid_clamp_physical(state : FluidState) -> FluidState

    fluid_compressibility

    source
    fn fluid_compressibility(state : FluidState, gamma : Double) -> Double

    fluid_energy

    source
    fn fluid_energy(density : Double, velocity : Double, pressure : Double, gamma : Double) -> Double

    fluid_enthalpy

    source
    fn fluid_enthalpy(state : FluidState) -> Double

    fluid_mach_number

    source
    fn fluid_mach_number(state : FluidState, gamma : Double) -> Double

    fluid_mean_density

    source
    fn fluid_mean_density(states : ArrayView[FluidState]) -> Double

    fluid_mean_pressure

    source
    fn fluid_mean_pressure(states : ArrayView[FluidState]) -> Double

    fluid_mean_velocity

    source
    fn fluid_mean_velocity(states : ArrayView[FluidState]) -> Double

    fluid_pressure

    source
    fn fluid_pressure(density : Double, temperature : Double, gas_constant : Double) -> Double

    fluid_state_from_primitive

    source
    fn fluid_state_from_primitive(density : Double, velocity : Double, pressure : Double, gamma : Double) -> FluidState

    fluid_state_is_physical

    source
    fn fluid_state_is_physical(state : FluidState) -> Bool

    fluid_temperature

    source
    fn fluid_temperature(state : FluidState, gas_constant : Double) -> Double

    fluid_update

    source
    fn fluid_update(state : FluidState, flux_difference : FluidFlux, dt : Double, cell_width : Double) -> FluidState

    fluid_wave_speed

    source
    fn fluid_wave_speed(state : FluidState, gamma : Double) -> Double

    forward_difference

    source
    fn forward_difference(grid : Grid1D, values : ArrayView[Double], index : Int) -> Double

    frequency_from_angular_frequency

    source
    fn frequency_from_angular_frequency(angular : Double) -> Double

    gather_with_shape

    source
    fn gather_with_shape(grid : Grid1D, values : ArrayView[Double], positions : ArrayView[Double], kind : ShapeKind) -> Array[Double]

    gaussian_electric_field

    source
    fn gaussian_electric_field(amplitude : Double, center : Double, width : Double, offset : Double) -> ElectricFieldModel

    geometric_schedule

    source
    fn geometric_schedule(start : Double, factor : Double, count : Int) -> Array[Double]

    gradient_periodic

    source
    fn gradient_periodic(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

    grid_cell_edges

    source
    fn grid_cell_edges(grid : Grid1D) -> Array[Double]

    grid_cell_volume

    source
    fn grid_cell_volume(grid : Grid1D) -> Double

    grid_center_of_mass

    source
    fn grid_center_of_mass(grid : Grid1D, density : ArrayView[Double]) -> Double

    grid_clip

    source
    fn grid_clip(grid : Grid1D, values : ArrayView[Double], low : Double, high : Double) -> Array[Double]

    grid_coordinates

    source
    fn grid_coordinates(grid : Grid1D) -> Array[Double]

    grid_distance

    source
    fn grid_distance(grid : Grid1D, first : Double, second : Double) -> Double

    grid_index_at

    source
    fn grid_index_at(grid : Grid1D, x : Double) -> Int

    grid_integral

    source
    fn grid_integral(grid : Grid1D, values : ArrayView[Double]) -> Double

    grid_interpolate_coordinates

    source
    fn grid_interpolate_coordinates(grid : Grid1D, count : Int) -> Array[Double]

    grid_l2_difference

    source
    fn grid_l2_difference(grid : Grid1D, first : ArrayView[Double], second : ArrayView[Double]) -> Double

    grid_neighbor_indices

    source
    fn grid_neighbor_indices(grid : Grid1D, index : Int) -> (Int, Int)

    grid_periodic_copy

    source
    fn grid_periodic_copy(grid : Grid1D, values : ArrayView[Double], shift : Int) -> Array[Double]

    grid_periodic_mean

    source
    fn grid_periodic_mean(_grid : Grid1D, values : ArrayView[Double]) -> Double

    grid_regrid

    source
    fn grid_regrid(source : Grid1D, values : ArrayView[Double], target : Grid1D) -> Array[Double]

    grid_roll

    source
    fn grid_roll(grid : Grid1D, values : ArrayView[Double], shift : Int) -> Array[Double]

    grid_smooth

    source
    fn grid_smooth(grid : Grid1D, values : ArrayView[Double], passes : Int) -> Array[Double]

    grid_variance

    source
    fn grid_variance(grid : Grid1D, values : ArrayView[Double]) -> Double

    grid_weighted_integral

    source
    fn grid_weighted_integral(grid : Grid1D, values : ArrayView[Double], weight : ArrayView[Double]) -> Double

    gyro_frequency

    source
    fn gyro_frequency(charge_c : Double, magnetic_field_t : Double, mass_kg : Double) -> Double

    gyroradius

    source
    fn gyroradius(mass : Double, speed : Double, charge : Double, magnetic : Double) -> Double

    hann_window

    source
    fn hann_window(signal : ArrayView[Double]) -> Array[Double]

    health_charge

    source
    fn health_charge(grid : Grid1D, density : ArrayView[Double], expected : Double, tolerance : Double) -> HealthCheck

    health_check

    source
    fn health_check(name : String, metric : Double, threshold : Double, message : String) -> HealthCheck

    health_energy

    source
    fn health_energy(initial : Double, final_value : Double, tolerance : Double) -> HealthCheck

    health_particles

    source
    fn health_particles(expected : Int, actual : Int) -> HealthCheck

    health_report

    source
    fn health_report(checks : ArrayView[HealthCheck]) -> Bool

    health_report_to_csv

    source
    fn health_report_to_csv(checks : ArrayView[HealthCheck]) -> String

    health_residual

    source
    fn health_residual(residual : Double, tolerance : Double) -> HealthCheck

    histogram_edges

    source
    fn histogram_edges(low : Double, high : Double, bins : Int) -> Array[Double]

    histogram_particles

    source
    fn histogram_particles(grid : PhaseSpaceGrid, particles : ArrayView[Particle]) -> PhaseSpaceGrid

    integrate_position

    source
    fn integrate_position(position : Double, velocity : Double, acceleration : Double, dt : Double) -> Double

    integrate_trapezoid

    source
    fn integrate_trapezoid(grid : Grid1D, values : ArrayView[Double]) -> Double

    integrate_velocity

    source
    fn integrate_velocity(velocity : Double, acceleration : Double, dt : Double) -> Double

    interpolate_pair

    source
    fn interpolate_pair(left : Double, right : Double, fraction : Double, mode : InterpolationMode) -> Double

    interpolate_periodic

    source
    fn interpolate_periodic(grid : Grid1D, values : ArrayView[Double], x : Double) -> Double

    interpolate_series

    source
    fn interpolate_series(values : ArrayView[Double], count : Int) -> Array[Double]

    interpolation_error

    source
    fn interpolation_error(grid : Grid1D, values : ArrayView[Double], points : ArrayView[Double], expected : ArrayView[Double]) -> Double

    interquartile_range

    source
    fn interquartile_range(values : ArrayView[Double]) -> Double

    invariant

    source
    fn invariant(name : String, observed : Double, tolerance : Double) -> InvariantCheck

    invariant_all

    source
    fn invariant_all(checks : ArrayView[InvariantCheck]) -> Bool

    invariant_bounds

    source
    fn invariant_bounds(name : String, values : ArrayView[Double], low : Double, high : Double) -> InvariantCheck

    invariant_charge

    source
    fn invariant_charge(grid : Grid1D, density : ArrayView[Double], expected : Double, tolerance : Double) -> InvariantCheck

    invariant_close

    source
    fn invariant_close(name : String, actual : Double, expected : Double, tolerance : Double) -> InvariantCheck

    invariant_max_error

    source
    fn invariant_max_error(checks : ArrayView[InvariantCheck]) -> Double

    invariant_positive

    source
    fn invariant_positive(name : String, values : ArrayView[Double]) -> InvariantCheck

    invariant_report

    source
    fn invariant_report(checks : ArrayView[InvariantCheck]) -> String

    invariant_shape

    source
    fn invariant_shape(name : String, actual : Int, expected : Int) -> InvariantCheck

    invariant_to_csv

    source
    fn invariant_to_csv(checks : ArrayView[InvariantCheck]) -> String

    invariant_zero_mean

    source
    fn invariant_zero_mean(name : String, values : ArrayView[Double], tolerance : Double) -> InvariantCheck

    inverse_lerp

    source
    fn inverse_lerp(a : Double, b : Double, value : Double) -> Double

    kinetic_energy

    source
    fn kinetic_energy(particles : ArrayView[Particle]) -> Double

    kinetic_energy_vector

    source
    fn kinetic_energy_vector(mass : Double, velocity : Vector3) -> Double

    kinetic_temperature

    source
    fn kinetic_temperature(particles : ArrayView[Particle]) -> Double

    kinetic_to_thermal_ratio

    source
    fn kinetic_to_thermal_ratio(velocity : Double, temperature : Double, mass : Double) -> Double

    l2_distance

    source
    fn l2_distance(left : ArrayView[Double], right : ArrayView[Double]) -> Double

    l2_norm

    source
    fn l2_norm(values : ArrayView[Double]) -> Double

    landau_damping_rate

    source
    fn landau_damping_rate(wave_number_m : Double, electron_temperature_k : Double, electron_density_m3 : Double) -> Double

    laplacian_periodic

    source
    fn laplacian_periodic(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

    lax_friedrichs_flux

    source
    fn lax_friedrichs_flux(left : FluidState, right : FluidState, gamma : Double, wave_speed : Double) -> FluidFlux

    lerp

    source
    fn lerp(a : Double, b : Double, t : Double) -> Double

    linear_electric_field

    source
    fn linear_electric_field(offset : Double, slope : Double, center : Double) -> ElectricFieldModel

    linear_magnetic_field

    source
    fn linear_magnetic_field(origin : Vector3, uniform : Vector3, gradient : Vector3) -> MagneticField3D

    linear_schedule

    source
    fn linear_schedule(start : Double, stop : Double, count : Int) -> Array[Double]

    linspace

    source
    fn linspace(start : Double, stop : Double, count : Int) -> Array[Double]

    locate_periodic

    source
    fn locate_periodic(grid : Grid1D, x : Double) -> InterpolationResult

    lorentz_force

    source
    fn lorentz_force(charge : Double, velocity : Vector3, electric : Vector3, magnetic : Vector3) -> Vector3

    magnetic_energy_density

    source
    fn magnetic_energy_density(field : Vector3) -> Double

    magnetic_force

    source
    fn magnetic_force(charge : Double, velocity : Vector3, magnetic : Vector3) -> Vector3

    magnetic_pressure

    source
    fn magnetic_pressure(field : Vector3) -> Double

    magnetic_pressure_si

    source
    fn magnetic_pressure_si(magnetic_field : Double) -> Double

    make_landau_initial

    source
    fn make_landau_initial(config : VlasovConfig, density0~ : Double, thermal_speed~ : Double, perturbation? : Double, mode? : Int) -> VlasovState

    manifest_fingerprint

    source
    fn manifest_fingerprint(scenario : SimulationScenario, toolchain : String) -> String

    manifest_from_scenario

    source
    fn manifest_from_scenario(scenario : SimulationScenario, toolchain : String) -> ReproducibilityManifest

    manifest_seed

    source
    fn manifest_seed(manifest : ReproducibilityManifest) -> Int

    manifest_to_csv

    source
    fn manifest_to_csv(manifest : ReproducibilityManifest) -> String

    manifest_work_units

    source
    fn manifest_work_units(manifest : ReproducibilityManifest) -> Int

    map_field

    source
    fn map_field(field : Field1D, transform : (Double) -> Double) -> Field1D

    map_particles

    source
    fn map_particles(particles : ArrayView[Particle], transform : (Particle) -> Particle) -> Array[Particle]

    mass_series

    source
    fn mass_series(particles : ArrayView[Array[Particle]]) -> Array[Double]

    matrix_frobenius_norm

    source
    fn matrix_frobenius_norm(matrix : Matrix2) -> Double

    matrix_trace

    source
    fn matrix_trace(matrix : Matrix2) -> Double

    max_abs_value

    source
    fn max_abs_value(values : ArrayView[Double]) -> Double

    max_value

    source
    fn max_value(values : ArrayView[Double], fallback : Double) -> Double

    maximum_metric

    source
    fn maximum_metric(metrics : ArrayView[QualityMetric]) -> Double

    maxwellian

    source
    fn maxwellian(v : Double, thermal_speed : Double) -> Double

    mean

    source
    fn mean(values : ArrayView[Double]) -> Double

    mean_absolute_error

    source
    fn mean_absolute_error(actual : ArrayView[Double], predicted : ArrayView[Double]) -> Double

    mean_subtract

    source
    fn mean_subtract(signal : ArrayView[Double]) -> Array[Double]

    median

    source
    fn median(values : ArrayView[Double]) -> Double

    merge_observables

    source
    fn merge_observables(first : Observable, second : Observable) -> Observable

    merge_populations

    source
    fn merge_populations(first : SpeciesPopulation, second : SpeciesPopulation) -> SpeciesPopulation

    metric

    source
    fn metric(name : String, value : Double, tolerance : Double) -> QualityMetric

    metric_count

    source
    fn metric_count(name : String, actual : Int, expected : Int) -> QualityMetric

    metric_l2

    source
    fn metric_l2(name : String, actual : ArrayView[Double], expected : ArrayView[Double], tolerance : Double) -> QualityMetric

    metric_max_abs

    source
    fn metric_max_abs(name : String, values : ArrayView[Double], tolerance : Double) -> QualityMetric

    metric_names

    source
    fn metric_names(metrics : ArrayView[QualityMetric]) -> Array[String]

    metric_relative

    source
    fn metric_relative(name : String, actual : Double, expected : Double, tolerance : Double) -> QualityMetric

    metrics_to_csv

    source
    fn metrics_to_csv(metrics : ArrayView[QualityMetric]) -> String

    min_value

    source
    fn min_value(values : ArrayView[Double], fallback : Double) -> Double

    mix_fields

    source
    fn mix_fields(first : Field1D, second : Field1D, fraction : Double) -> Field1D

    modulo_index

    source
    fn modulo_index(index : Int, count : Int) -> Int

    momentum_series

    source
    fn momentum_series(particles : ArrayView[Array[Particle]]) -> Array[Double]

    momentum_vector

    source
    fn momentum_vector(mass : Double, velocity : Vector3) -> Vector3

    monotonic_time

    source
    fn monotonic_time(values : ArrayView[Double]) -> Bool

    moving_average

    source
    fn moving_average(values : ArrayView[Double], width : Int) -> Array[Double]

    multiply_profile

    source
    fn multiply_profile(a : ArrayView[Double], b : ArrayView[Double]) -> Array[Double]

    nearest_index

    source
    fn nearest_index(grid : Grid1D, x : Double) -> Int

    normalize_charge

    source
    fn normalize_charge(scales : UnitScales, value : Double) -> Double

    normalize_density

    source
    fn normalize_density(scales : UnitScales, value : Double) -> Double

    normalize_electric_field

    source
    fn normalize_electric_field(scales : UnitScales, value : Double) -> Double

    normalize_field

    source
    fn normalize_field(field : Field1D) -> Field1D

    normalize_length

    source
    fn normalize_length(scales : UnitScales, value : Double) -> Double

    normalize_mass

    source
    fn normalize_mass(scales : UnitScales, value : Double) -> Double

    normalize_profile

    source
    fn normalize_profile(grid : Grid1D, values : ArrayView[Double], target_integral : Double) -> Array[Double]

    normalize_series

    source
    fn normalize_series(values : ArrayView[Double]) -> Array[Double]

    normalize_shape_weights

    source
    fn normalize_shape_weights(weights : ArrayView[ShapeContribution]) -> Array[ShapeContribution]

    normalize_sum

    source
    fn normalize_sum(values : ArrayView[Double]) -> Array[Double]

    normalize_temperature

    source
    fn normalize_temperature(scales : UnitScales, value : Double) -> Double

    normalize_time

    source
    fn normalize_time(scales : UnitScales, value : Double) -> Double

    normalize_velocity

    source
    fn normalize_velocity(scales : UnitScales, value : Double) -> Double

    normalize_wave_number

    source
    fn normalize_wave_number(wave_number : Double, debye : Double) -> Double

    numerical_epsilon

    source
    fn numerical_epsilon(scale : Double) -> Double

    observable_correlation

    source
    fn observable_correlation(first : Observable, second : Observable) -> Double

    observable_difference

    source
    fn observable_difference(first : Observable, second : Observable) -> Observable

    observable_summary_csv

    source
    fn observable_summary_csv(values : ArrayView[Observable]) -> String

    observables_from_diagnostics

    source
    fn observables_from_diagnostics(values : ArrayView[PicDiagnostics]) -> Array[Observable]

    outer_product

    source
    fn outer_product(first : MatrixVector2, second : MatrixVector2) -> Matrix2

    package_description

    source
    fn package_description() -> String

    package_keywords

    source
    fn package_keywords() -> Array[String]

    package_license

    source
    fn package_license() -> String

    package_metadata_csv

    source
    fn package_metadata_csv() -> String

    package_name

    source
    fn package_name() -> String

    package_ready

    source
    fn package_ready() -> Bool

    package_repository

    source
    fn package_repository() -> String

    package_version

    source
    fn package_version() -> String

    particle_charge_series

    source
    fn particle_charge_series(states : ArrayView[Array[Particle]]) -> Array[Double]

    particle_current_density

    source
    fn particle_current_density(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

    particle_energy_series

    source
    fn particle_energy_series(states : ArrayView[Array[Particle]]) -> Array[Double]

    particle_for_species

    source
    fn particle_for_species(species : Species, x~ : Double, v~ : Double, weight? : Double) -> Particle

    particle_mean_shift

    source
    fn particle_mean_shift(particles : ArrayView[Particle]) -> Array[Particle]

    particle_merge

    source
    fn particle_merge(first : ArrayView[Particle], second : ArrayView[Particle]) -> Array[Particle]

    particle_momentum_series

    source
    fn particle_momentum_series(states : ArrayView[Array[Particle]]) -> Array[Double]

    particle_number_density

    source
    fn particle_number_density(grid : Grid1D, particles : ArrayView[Particle]) -> Array[Double]

    particle_position_bounds

    source
    fn particle_position_bounds(particles : ArrayView[Particle]) -> (Double, Double)

    particle_quality_metrics

    source
    fn particle_quality_metrics(grid : Grid1D, particles : ArrayView[Particle]) -> Array[QualityMetric]

    particle_speed

    source
    fn particle_speed(particle : Particle) -> Double

    particle_speed_range

    source
    fn particle_speed_range(particles : ArrayView[Particle]) -> (Double, Double)

    particle_speeds

    source
    fn particle_speeds(particles : ArrayView[Particle]) -> Array[Double]

    particle_thermalize

    source
    fn particle_thermalize(particles : ArrayView[Particle], temperature : Double) -> Array[Particle]

    particle_total_momentum

    source
    fn particle_total_momentum(particles : ArrayView[Particle]) -> Double

    particle_velocity_bounds

    source
    fn particle_velocity_bounds(particles : ArrayView[Particle]) -> (Double, Double)

    particle_velocity_center

    source
    fn particle_velocity_center(particles : ArrayView[Particle]) -> Array[Particle]

    particles_in_cell

    source
    fn particles_in_cell(grid : Grid1D, particles : ArrayView[Particle], cell : Int) -> Array[Particle]

    particles_to_csv

    source
    fn particles_to_csv(particles : ArrayView[Particle]) -> String

    particles_with_position_range

    source
    fn particles_with_position_range(particles : ArrayView[Particle], low : Double, high : Double) -> Array[Particle]

    particles_with_speed_limit

    source
    fn particles_with_speed_limit(particles : ArrayView[Particle], limit : Double) -> Array[Particle]

    percentile

    source
    fn percentile(values : ArrayView[Double], fraction : Double) -> Double

    periodic_average

    source
    fn periodic_average(grid : Grid1D, values : ArrayView[Double], radius : Int) -> Array[Double]

    periodic_cumulative

    source
    fn periodic_cumulative(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

    periodic_gradient

    source
    fn periodic_gradient(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

    periodic_index

    source
    fn periodic_index(index : Int, length : Int) -> Int

    periodic_laplacian

    source
    fn periodic_laplacian(grid : Grid1D, values : ArrayView[Double]) -> Array[Double]

    phase_space_density

    source
    fn phase_space_density(grid : PhaseSpaceGrid, particles : ArrayView[Particle]) -> Array[Double]

    phase_space_energy

    source
    fn phase_space_energy(grid : PhaseSpaceGrid, histogram : ArrayView[Double], mass : Double) -> Double

    phase_space_entropy

    source
    fn phase_space_entropy(histogram : ArrayView[Double]) -> Double

    phase_space_marginal_v

    source
    fn phase_space_marginal_v(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> Array[Double]

    phase_space_marginal_x

    source
    fn phase_space_marginal_x(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> Array[Double]

    phase_space_mean_velocity

    source
    fn phase_space_mean_velocity(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> Double

    phase_space_peak

    source
    fn phase_space_peak(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> (Int, Int)

    phase_space_to_csv

    source
    fn phase_space_to_csv(grid : PhaseSpaceGrid, histogram : ArrayView[Double]) -> String

    let pi : Double

    pic_charge_drift

    source
    fn pic_charge_drift(values : ArrayView[PicDiagnostics]) -> Double

    pic_config_summary

    source
    fn pic_config_summary(config : PicConfig) -> String

    pic_diagnostics_charges

    source
    fn pic_diagnostics_charges(values : ArrayView[PicDiagnostics]) -> Array[Double]

    pic_diagnostics_energies

    source
    fn pic_diagnostics_energies(values : ArrayView[PicDiagnostics]) -> Array[Double]

    pic_diagnostics_pass

    source
    fn pic_diagnostics_pass(values : ArrayView[PicDiagnostics], charge_tolerance : Double, energy_tolerance : Double) -> Bool

    pic_diagnostics_times

    source
    fn pic_diagnostics_times(values : ArrayView[PicDiagnostics]) -> Array[Double]

    pic_diagnostics_to_table

    source
    fn pic_diagnostics_to_table(values : ArrayView[PicDiagnostics]) -> NumericTable

    pic_energy_drift

    source
    fn pic_energy_drift(values : ArrayView[PicDiagnostics]) -> Double

    pic_invariants

    source
    fn pic_invariants(state : PicState, expected_charge : Double) -> Array[InvariantCheck]

    pic_series_summary_to_csv

    source
    fn pic_series_summary_to_csv(summary : PicSeriesSummary) -> String

    pic_state_charge_error

    source
    fn pic_state_charge_error(state : PicState) -> Double

    pic_state_energy

    source
    fn pic_state_energy(state : PicState) -> Double

    pic_state_is_finite

    source
    fn pic_state_is_finite(state : PicState) -> Bool

    pic_state_to_snapshot

    source
    fn pic_state_to_snapshot(state : PicState) -> String

    pipeline_frame

    source
    fn pipeline_frame(_config : PipelineConfig, step : Int, state : PicState) -> PipelineFrame

    pipeline_initial_state

    source
    fn pipeline_initial_state(config : PipelineConfig) -> PicState

    pipeline_step

    source
    fn pipeline_step(config : PipelineConfig, state : PicState) -> PicState

    pipeline_summary

    source
    fn pipeline_summary(result : PipelineResult) -> String

    pipeline_to_csv

    source
    fn pipeline_to_csv(result : PipelineResult) -> String

    plasma_beta

    source
    fn plasma_beta(temperature : Double, density : Double, magnetic_field : Double) -> Double

    plasma_frequency

    source
    fn plasma_frequency(density_m3 : Double, charge_c? : Double, mass_kg? : Double) -> Double

    plasma_parameter

    source
    fn plasma_parameter(electron_density_m3 : Double, debye_length_m : Double) -> Double

    plasma_parameter_from_state

    source
    fn plasma_parameter_from_state(temperature : Double, density : Double) -> Double

    plasma_time_unit

    source
    fn plasma_time_unit(scales : UnitScales, density : Double, mass : Double, charge : Double) -> Double

    poisson_converges

    source
    fn poisson_converges(grid : Grid1D, source : ArrayView[Double], tolerance : Double, max_iterations : Int) -> Bool

    poisson_electric_field

    source
    fn poisson_electric_field(grid : Grid1D, potential : ArrayView[Double]) -> Array[Double]

    poisson_energy

    source
    fn poisson_energy(grid : Grid1D, potential : ArrayView[Double]) -> Double

    poisson_iteration_history

    source
    fn poisson_iteration_history(grid : Grid1D, source : ArrayView[Double], steps : Int) -> Array[Double]

    poisson_mean_free

    source
    fn poisson_mean_free(potential : ArrayView[Double]) -> Array[Double]

    poisson_residual

    source
    fn poisson_residual(grid : Grid1D, potential : ArrayView[Double], source : ArrayView[Double]) -> Double

    poisson_residual_series

    source
    fn poisson_residual_series(grid : Grid1D, potentials : ArrayView[Array[Double]], source : ArrayView[Double]) -> Array[Double]

    poisson_solution_range

    source
    fn poisson_solution_range(result : PoissonResult) -> Double

    poisson_source

    source
    fn poisson_source(charge_density : ArrayView[Double]) -> Array[Double]

    polynomial_basis

    source
    fn polynomial_basis(x : Double, order : Int) -> Array[Double]

    polynomial_derivative

    source
    fn polynomial_derivative(coefficients : ArrayView[Double]) -> Array[Double]

    polynomial_evaluate

    source
    fn polynomial_evaluate(coefficients : ArrayView[Double], x : Double) -> Double

    polynomial_fit_constant

    source
    fn polynomial_fit_constant(values : ArrayView[Double]) -> Array[Double]

    population_charge_density

    source
    fn population_charge_density(grid : Grid1D, populations : ArrayView[SpeciesPopulation], kind : ShapeKind) -> Array[Double]

    population_charge_summary

    source
    fn population_charge_summary(state : MultiSpeciesState) -> Array[Double]

    population_mass_summary

    source
    fn population_mass_summary(state : MultiSpeciesState) -> Array[Double]

    population_names

    source
    fn population_names(state : MultiSpeciesState) -> Array[String]

    position_marginal

    source
    fn position_marginal(state : VlasovState) -> Array[Double]

    potential_from_electric

    source
    fn potential_from_electric(grid : Grid1D, electric : ArrayView[Double]) -> Array[Double]

    power_spectrum

    source
    fn power_spectrum(signal : ArrayView[Double]) -> Array[Double]

    profile_ceiling

    source
    fn profile_ceiling(values : ArrayView[Double], ceiling : Double) -> Array[Double]

    profile_constant

    source
    fn profile_constant(value : Double) -> Profile1D

    profile_double_hump

    source
    fn profile_double_hump(base : Double, amplitude : Double, center : Double, width : Double) -> Profile1D

    profile_floor

    source
    fn profile_floor(values : ArrayView[Double], floor : Double) -> Array[Double]

    profile_gaussian

    source
    fn profile_gaussian(base : Double, amplitude : Double, center : Double, width : Double) -> Profile1D

    profile_integral

    source
    fn profile_integral(grid : Grid1D, profile : Profile1D) -> Double

    profile_maximum

    source
    fn profile_maximum(values : ArrayView[Double]) -> Double

    profile_mean

    source
    fn profile_mean(grid : Grid1D, profile : Profile1D) -> Double

    profile_minimum

    source
    fn profile_minimum(values : ArrayView[Double]) -> Double

    profile_ramp

    source
    fn profile_ramp(start : Double, end : Double, center : Double, width : Double) -> Profile1D

    profile_range

    source
    fn profile_range(values : ArrayView[Double]) -> Double

    profile_sinusoid

    source
    fn profile_sinusoid(base : Double, amplitude : Double, wave_number : Double, phase : Double) -> Profile1D

    profile_top_hat

    source
    fn profile_top_hat(low : Double, high : Double, center : Double, width : Double) -> Profile1D

    profile_value

    source
    fn profile_value(profile : Profile1D, x : Double) -> Double

    profile_values

    source
    fn profile_values(grid : Grid1D, profile : Profile1D) -> Array[Double]

    project_field

    source
    fn project_field(field : Field1D) -> Field1D

    project_zero_mean

    source
    fn project_zero_mean(values : ArrayView[Double]) -> Array[Double]

    prolongate_linear

    source
    fn prolongate_linear(source : Grid1D, values : ArrayView[Double], target : Grid1D) -> Array[Double]

    proton_mass

    source
    let proton_mass : Double

    public_api_summary

    source
    fn public_api_summary() -> String

    pulse_electric_field

    source
    fn pulse_electric_field(amplitude : Double, center : Double, width : Double, offset : Double) -> ElectricFieldModel

    push_particle

    source
    fn push_particle(grid : Grid1D, particle : Particle, electric~ : Double, dt~ : Double) -> Particle

    push_particle_unbounded

    source
    fn push_particle_unbounded(particle : Particle, electric : Double, dt : Double) -> Particle

    push_particles

    source
    fn push_particles(particles : ArrayView[Particle], electric : ArrayView[Double], dt : Double) -> Array[Particle]

    quality_report

    source
    fn quality_report(metrics : ArrayView[QualityMetric]) -> String

    reduce_average

    source
    fn reduce_average(source : Grid1D, values : ArrayView[Double], target_cells : Int) -> GridReduction

    reduction_converges

    source
    fn reduction_converges(errors : ArrayView[Double], tolerance : Double) -> Bool

    reduction_error

    source
    fn reduction_error(source : Grid1D, values : ArrayView[Double], reduction : GridReduction) -> Double

    reduction_errors

    source
    fn reduction_errors(source : Grid1D, values : ArrayView[Double], reductions : ArrayView[GridReduction]) -> Array[Double]

    reduction_integral

    source
    fn reduction_integral(_grid : Grid1D, reduction : GridReduction) -> Double

    reduction_maximum

    source
    fn reduction_maximum(reduction : GridReduction) -> Double

    reduction_minimum

    source
    fn reduction_minimum(reduction : GridReduction) -> Double

    reduction_series

    source
    fn reduction_series(source : Grid1D, values : ArrayView[Double], resolutions : ArrayView[Int]) -> Array[GridReduction]

    reduction_summary

    source
    fn reduction_summary(reduction : GridReduction) -> String

    reduction_to_csv

    source
    fn reduction_to_csv(reduction : GridReduction) -> String

    reflect_position

    source
    fn reflect_position(grid : Grid1D, x : Double) -> Double

    relative_change

    source
    fn relative_change(initial : Double, final_value : Double) -> Double

    relative_energy_drift

    source
    fn relative_energy_drift(initial : Double, ending : Double) -> Double

    relative_error

    source
    fn relative_error(actual : Double, predicted : Double) -> Double

    relative_l2_error

    source
    fn relative_l2_error(reference : ArrayView[Double], actual : ArrayView[Double]) -> Double

    relative_residual

    source
    fn relative_residual(values : ArrayView[Double], target : ArrayView[Double]) -> Double

    relax_to_target

    source
    fn relax_to_target(initial : Array[Double], target : Array[Double], factor : Double, max_iterations : Int) -> RelaxationResult

    relaxation_time

    source
    fn relaxation_time(rate : Double) -> Double

    reproducibility_report

    source
    fn reproducibility_report(scenario : SimulationScenario, toolchain : String) -> String

    reproducible_run

    source
    fn reproducible_run(scenario : SimulationScenario) -> Bool

    resample_periodic

    source
    fn resample_periodic(source_grid : Grid1D, source : ArrayView[Double], target_grid : Grid1D, mode : InterpolationMode) -> Array[Double]

    rescale_particle_weights

    source
    fn rescale_particle_weights(particles : ArrayView[Particle], factor : Double) -> Array[Particle]

    residual_norm

    source
    fn residual_norm(residual : ArrayView[Double]) -> Double

    residual_sum_of_squares

    source
    fn residual_sum_of_squares(actual : ArrayView[Double], predicted : ArrayView[Double]) -> Double

    result_is_well_formed

    source
    fn result_is_well_formed(scenario : SimulationScenario, fingerprint : ResultFingerprint) -> Bool

    rms

    source
    fn rms(values : ArrayView[Double]) -> Double

    run_ensemble

    source
    fn run_ensemble(scenario : SimulationScenario, members : Int) -> Array[EnsembleMember]

    run_experiment

    source
    fn run_experiment(config : ExperimentConfig) -> ExperimentReport

    run_pic_benchmark

    source
    fn run_pic_benchmark(cells? : Int, particles? : Int, steps? : Int) -> BenchmarkSample

    run_pipeline

    source
    fn run_pipeline(config : PipelineConfig) -> PipelineResult

    run_plasma_benchmark_catalog

    source
    fn run_plasma_benchmark_catalog() -> PlasmaBenchmarkReport

    running_maximum

    source
    fn running_maximum(values : ArrayView[Double]) -> Array[Double]

    running_minimum

    source
    fn running_minimum(values : ArrayView[Double]) -> Array[Double]

    safe_grid

    source
    fn safe_grid(cells : Int, length : Double) -> Grid1D?

    safe_ratio

    source
    fn safe_ratio(numerator : Double, denominator : Double, fallback : Double) -> Double

    sample_beam

    source
    fn sample_beam(count : Int, seed : Int, drift : Double, spread : Double) -> Array[Double]

    sample_clone

    source
    fn sample_clone(particles : ArrayView[Particle]) -> Array[Particle]

    sample_histogram

    source
    fn sample_histogram(values : ArrayView[Double], low : Double, high : Double, bins : Int) -> Array[Int]

    sample_lattice

    source
    fn sample_lattice(grid : Grid1D, velocity : Double, count : Int) -> Array[Particle]

    sample_linear

    source
    fn sample_linear(grid : Grid1D, values : ArrayView[Double], x : Double) -> Double

    sample_mean

    source
    fn sample_mean(values : ArrayView[Double]) -> Double

    sample_normal

    source
    fn sample_normal(count : Int, seed : Int, mean_value : Double, standard_deviation : Double) -> Array[Double]

    sample_particles

    source
    fn sample_particles(grid : Grid1D, count : Int, seed : Int, drift : Double, spread : Double) -> Array[Particle]

    sample_periodic

    source
    fn sample_periodic(grid : Grid1D, values : ArrayView[Double], x : Double, mode : InterpolationMode) -> Double

    sample_periodic_linear

    source
    fn sample_periodic_linear(grid : Grid1D, values : ArrayView[Double], x : Double) -> Double

    sample_positions

    source
    fn sample_positions(count : Int, length : Double, phase : Double) -> Array[Double]

    sample_profile

    source
    fn sample_profile(grid : Grid1D, profile : Profile1D, count : Int, seed : Int) -> Array[Double]

    sample_quantiles

    source
    fn sample_quantiles(values : ArrayView[Double], count : Int) -> Array[Double]

    sample_rejection

    source
    fn sample_rejection(grid : Grid1D, profile : Profile1D, count : Int, seed : Int, upper : Double) -> Array[Double]

    sample_span

    source
    fn sample_span(values : ArrayView[Double]) -> Double

    sample_two_beam

    source
    fn sample_two_beam(count : Int, seed : Int, drift : Double, spread : Double) -> Array[Double]

    sample_uniform

    source
    fn sample_uniform(count : Int, seed : Int, low : Double, high : Double) -> Array[Double]

    sample_uniform_grid

    source
    fn sample_uniform_grid(grid : Grid1D, count : Int, seed : Int) -> Array[Double]

    sample_variance

    source
    fn sample_variance(values : ArrayView[Double]) -> Double

    sample_weighted_particles

    source
    fn sample_weighted_particles(grid : Grid1D, count : Int, seed : Int, profile : Profile1D) -> Array[Particle]

    sampled_beam

    source
    fn sampled_beam(config : VlasovConfig, density~ : Double, center_velocity~ : Double, thermal_speed~ : Double) -> Array[Double]

    sampled_maxwellian

    source
    fn sampled_maxwellian(config : VlasovConfig, density~ : Double, thermal_speed~ : Double) -> Array[Double]

    sampling_config_summary

    source
    fn sampling_config_summary(config : SamplingConfig) -> String

    scale_field

    source
    fn scale_field(field : Field1D, factor : Double) -> Field1D

    scales_summary

    source
    fn scales_summary(scales : UnitScales) -> String

    scenario_charge_error

    source
    fn scenario_charge_error(scenario : SimulationScenario) -> Double

    scenario_description

    source
    fn scenario_description(scenario : SimulationScenario) -> String

    scenario_diagnostics_csv

    source
    fn scenario_diagnostics_csv(scenario : SimulationScenario) -> String

    scenario_health

    source
    fn scenario_health(scenario : SimulationScenario) -> Array[HealthCheck]

    scenario_initial_state

    source
    fn scenario_initial_state(scenario : SimulationScenario) -> PicState

    scenario_manifest_summary

    source
    fn scenario_manifest_summary(scenario : SimulationScenario) -> String

    scenario_particle_count

    source
    fn scenario_particle_count(scenario : SimulationScenario) -> Int

    scenario_quality_metrics

    source
    fn scenario_quality_metrics(scenario : SimulationScenario) -> Array[QualityMetric]

    scenario_run

    source
    fn scenario_run(scenario : SimulationScenario) -> PicState

    scenario_step

    source
    fn scenario_step(state : PicState, scenario : SimulationScenario) -> PicState

    scenario_trace

    source
    fn scenario_trace(scenario : SimulationScenario) -> Array[PicDiagnostics]

    scenario_with_boundary

    source
    fn scenario_with_boundary(scenario : SimulationScenario, boundary : Boundary1D) -> SimulationScenario

    scenario_with_dt

    source
    fn scenario_with_dt(scenario : SimulationScenario, dt : Double) -> SimulationScenario

    scenario_with_shape

    source
    fn scenario_with_shape(scenario : SimulationScenario, shape : ShapeKind) -> SimulationScenario

    scenario_work_units

    source
    fn scenario_work_units(scenario : SimulationScenario) -> Int

    serialize_benchmark

    source
    fn serialize_benchmark(suite : BenchmarkSuite) -> String

    serialize_config

    source
    fn serialize_config(config : ExperimentConfig) -> String

    serialize_field_snapshot

    source
    fn serialize_field_snapshot(field : Field1D) -> String

    serialize_grid_values

    source
    fn serialize_grid_values(grid : Grid1D, name : String, values : ArrayView[Double]) -> String

    serialize_named_values

    source
    fn serialize_named_values(names : ArrayView[String], values : ArrayView[Double]) -> String

    serialize_particles_snapshot

    source
    fn serialize_particles_snapshot(particles : ArrayView[Particle]) -> String

    serialize_pipeline

    source
    fn serialize_pipeline(result : PipelineResult) -> String

    serialize_scalar_series

    source
    fn serialize_scalar_series(name : String, values : ArrayView[Double]) -> String

    serialize_shape_weights

    source
    fn serialize_shape_weights(weights : ShapeWeights) -> String

    serialize_summary

    source
    fn serialize_summary(name : String, values : ArrayView[Double]) -> String

    serialize_validation

    source
    fn serialize_validation(report : ValidationReport) -> String

    serialize_vector_series

    source
    fn serialize_vector_series(name : String, values : ArrayView[Vector3]) -> String

    serialize_vlasov

    source
    fn serialize_vlasov(state : VlasovState) -> String

    series_from_pairs

    source
    fn series_from_pairs(name : String, pairs : Array[(Double, Double)]) -> TimeSeries

    series_mean

    source
    fn series_mean(values : ArrayView[Double]) -> Double

    series_range

    source
    fn series_range(values : ArrayView[Double]) -> Double

    series_rms

    source
    fn series_rms(values : ArrayView[Double]) -> Double

    shape_blend

    source
    fn shape_blend(grid : Grid1D, x : Double, first : ShapeKind, second : ShapeKind, fraction : Double) -> Array[Double]

    shape_charge_error

    source
    fn shape_charge_error(grid : Grid1D, particles : ArrayView[Particle], kind : ShapeKind) -> Double

    shape_kind_from_index

    source
    fn shape_kind_from_index(index : Int) -> ShapeKind

    shape_moment

    source
    fn shape_moment(grid : Grid1D, positions : ArrayView[Double], values : ArrayView[Double], kind : ShapeKind, order : Int) -> Double

    shape_name

    source
    fn shape_name(kind : ShapeKind) -> String

    shape_partition_error

    source
    fn shape_partition_error(grid : Grid1D, x : Double, kind : ShapeKind) -> Double

    shape_reconstruct

    source
    fn shape_reconstruct(grid : Grid1D, deposited : ArrayView[Double], positions : ArrayView[Double], kind : ShapeKind) -> Array[Double]

    shape_support

    source
    fn shape_support(kind : ShapeKind) -> Int

    shape_weight

    source
    fn shape_weight(grid : Grid1D, x : Double, index : Int, kind : ShapeKind) -> Double

    shape_weights

    source
    fn shape_weights(grid : Grid1D, x : Double, kind : ShapeKind) -> ShapeWeights

    shift_field

    source
    fn shift_field(grid : Grid1D, field : Field1D, shift : Double) -> Field1D

    shift_profile

    source
    fn shift_profile(grid : Grid1D, values : ArrayView[Double], shift : Double) -> Array[Double]

    simpson_integral

    source
    fn simpson_integral(values : ArrayView[Double], spacing : Double) -> Double

    sinusoidal_electric_field

    source
    fn sinusoidal_electric_field(amplitude : Double, offset : Double, wave_number : Double, phase : Double) -> ElectricFieldModel

    sliding_windows

    source
    fn sliding_windows(values : ArrayView[Double], width : Int, stride : Int) -> Array[Array[Double]]

    solve_2x2

    source
    fn solve_2x2(matrix : Matrix2, rhs : MatrixVector2) -> MatrixVector2

    solve_periodic_field

    source
    fn solve_periodic_field(grid : Grid1D, charge_density : ArrayView[Double]) -> Field1D

    solve_periodic_poisson

    source
    fn solve_periodic_poisson(grid : Grid1D, source : ArrayView[Double], max_iterations? : Int, tolerance? : Double) -> PoissonResult

    Compatibility wrapper with a source-density API.

    solve_periodic_potential_field

    source
    fn solve_periodic_potential_field(grid : Grid1D, source : ArrayView[Double], max_iterations? : Int, tolerance? : Double) -> Field1D

    solve_poisson_dirichlet

    source
    fn solve_poisson_dirichlet(grid : Grid1D, source : ArrayView[Double], left_value : Double, right_value : Double) -> Array[Double]

    solve_poisson_jacobi

    source
    fn solve_poisson_jacobi(grid : Grid1D, charge_density : ArrayView[Double], max_iterations : Int, tolerance : Double) -> PoissonResult

    solve_poisson_periodic

    source
    fn solve_poisson_periodic(grid : Grid1D, charge_density : ArrayView[Double], max_iterations : Int, tolerance : Double) -> PoissonResult

    solver_convergence_rate

    source
    fn solver_convergence_rate(residuals : ArrayView[Double]) -> Double

    solver_is_decreasing

    source
    fn solver_is_decreasing(residuals : ArrayView[Double]) -> Bool

    solver_residual_csv

    source
    fn solver_residual_csv(residuals : ArrayView[Double]) -> String

    sound_speed

    source
    fn sound_speed(state : FluidState, gamma : Double) -> Double

    sound_speed_ideal

    source
    fn sound_speed_ideal(temperature : Double, mass : Double, gamma : Double) -> Double

    species_gyro_frequency

    source
    fn species_gyro_frequency(species : Species, field : Double) -> Double

    species_gyroradius

    source
    fn species_gyroradius(species : Species, temperature : Double, field : Double) -> Double

    species_particles

    source
    fn species_particles(species : Species, count : Int, spacing : Double, drift : Double) -> Array[Particle]

    species_plasma_frequency

    source
    fn species_plasma_frequency(species : Species, density : Double) -> Double

    specific_internal_energy

    source
    fn specific_internal_energy(state : FluidState) -> Double

    spectral_centroid

    source
    fn spectral_centroid(spectrum : ArrayView[SpectrumBin]) -> Double

    spectrum_band_power

    source
    fn spectrum_band_power(spectrum : ArrayView[SpectrumBin], low : Double, high : Double) -> Double

    spectrum_to_csv

    source
    fn spectrum_to_csv(spectrum : ArrayView[SpectrumBin]) -> String

    stable_pic_dt

    source
    fn stable_pic_dt(grid : Grid1D, maximum_speed : Double, safety_factor : Double) -> Double

    stable_time_step

    source
    fn stable_time_step(cell_width : Double, speed : Double, cfl : Double) -> Double

    standard_scenario

    source
    fn standard_scenario(name : String, cells : Int, particles : Int, steps : Int) -> SimulationScenario

    sum_values

    source
    fn sum_values(values : ArrayView[Double]) -> Double

    summarize_ensemble

    source
    fn summarize_ensemble(members : ArrayView[EnsembleMember]) -> EnsembleSummary

    summarize_pic_series

    source
    fn summarize_pic_series(values : ArrayView[PicDiagnostics]) -> PicSeriesSummary

    summarize_series

    source
    fn summarize_series(name : String, values : ArrayView[Double]) -> SeriesSummary

    summarize_vlasov

    source
    fn summarize_vlasov(state : VlasovState, mass : Double) -> VlasovSummary

    summary_array

    source
    fn summary_array(values : ArrayView[Array[Double]]) -> Array[SeriesSummary]

    summary_to_csv

    source
    fn summary_to_csv(summary : SeriesSummary) -> String

    table_append_column

    source
    fn table_append_column(table : NumericTable, name : String, values : ArrayView[Double]) -> NumericTable

    table_column_sums

    source
    fn table_column_sums(table : NumericTable) -> Array[Double]

    table_column_values

    source
    fn table_column_values(table : NumericTable, index : Int) -> Array[Double]

    table_filter_rows

    source
    fn table_filter_rows(table : NumericTable, column : Int, low : Double, high : Double) -> NumericTable

    table_from_series

    source
    fn table_from_series(names : Array[String], series : Array[Array[Double]]) -> NumericTable

    table_maximum

    source
    fn table_maximum(table : NumericTable, index : Int) -> Double

    table_mean

    source
    fn table_mean(table : NumericTable, index : Int) -> Double

    table_minimum

    source
    fn table_minimum(table : NumericTable, index : Int) -> Double

    table_row_sums

    source
    fn table_row_sums(table : NumericTable) -> Array[Double]

    table_summary

    source
    fn table_summary(table : NumericTable) -> String

    thermal_debye_length

    source
    fn thermal_debye_length(temperature : Double, density : Double, charge : Double) -> Double

    thermal_energy

    source
    fn thermal_energy(temperature : Double) -> Double

    thermal_speed

    source
    fn thermal_speed(temperature : Double, mass : Double) -> Double

    thermal_speed_from_temperature

    source
    fn thermal_speed_from_temperature(temperature : Double, mass : Double) -> Double

    thermal_unit

    source
    fn thermal_unit(scales : UnitScales) -> Double

    thermal_velocity

    source
    fn thermal_velocity(temperature_k : Double, mass_kg~ : Double) -> Double

    total_charge

    source
    fn total_charge(grid : Grid1D, charge_density : ArrayView[Double]) -> Double

    total_particle_charge

    source
    fn total_particle_charge(particles : ArrayView[Particle]) -> Double

    trace_field_line

    source
    fn trace_field_line(position : Vector3, field : MagneticField3D, step : Double, count : Int) -> Array[Vector3]

    trace_pic

    source
    fn trace_pic(state : PicState, dt : Double, steps : Int, every? : Int) -> Array[PicDiagnostics]

    trace_pic_diagnostics

    source
    fn trace_pic_diagnostics(state : PicState, dt : Double, steps : Int) -> Array[PicDiagnostics]

    translate_particles

    source
    fn translate_particles(particles : ArrayView[Particle], shift : Double) -> Array[Particle]

    trapezoid_integral

    source
    fn trapezoid_integral(grid : Grid1D, values : ArrayView[Double]) -> Double

    trapezoid_integral_uniform

    source
    fn trapezoid_integral_uniform(values : ArrayView[Double], spacing : Double) -> Double

    tridiagonal_jacobi

    source
    fn tridiagonal_jacobi(diagonal : ArrayView[Double], lower : ArrayView[Double], upper : ArrayView[Double], rhs : ArrayView[Double], iterations : Int) -> RelaxationResult

    tridiagonal_residual

    source
    fn tridiagonal_residual(diagonal : ArrayView[Double], lower : ArrayView[Double], upper : ArrayView[Double], solution : ArrayView[Double], rhs : ArrayView[Double]) -> Array[Double]

    two_stream_particles

    source
    fn two_stream_particles(count : Int, length : Double, speed : Double) -> Array[Particle]

    uniform_magnetic_field

    source
    fn uniform_magnetic_field(field : Vector3) -> MagneticField3D

    vacuum_permittivity

    source
    let vacuum_permittivity : Double

    validate_count

    source
    fn validate_count(value : Int, name : String) -> ValidationReport

    validate_grid

    source
    fn validate_grid(cells : Int, length : Double) -> ValidationReport

    validate_non_negative

    source
    fn validate_non_negative(value : Double, name : String) -> ValidationReport

    validate_positive

    source
    fn validate_positive(value : Double, name : String) -> ValidationReport

    validate_range

    source
    fn validate_range(value : Double, low : Double, high : Double, name : String) -> ValidationReport

    validate_simulation_inputs

    source
    fn validate_simulation_inputs(grid : Grid1D, dt : Double, particles : Int, steps : Int) -> ValidationReport

    validation_health

    source
    fn validation_health(report : ValidationReport) -> HealthCheck

    validation_message

    source
    fn validation_message(report : ValidationReport) -> String

    vector_distance

    source
    fn vector_distance(a : ArrayView[Double], b : ArrayView[Double]) -> Double

    velocity_marginal

    source
    fn velocity_marginal(state : VlasovState) -> Array[Double]

    velocity_mean

    source
    fn velocity_mean(particles : ArrayView[Particle]) -> Double

    velocity_variance

    source
    fn velocity_variance(particles : ArrayView[Particle]) -> Double

    verification_bundle_check_count

    source
    fn verification_bundle_check_count(bundle : VerificationBundle) -> Int

    verification_bundle_checksum

    source
    fn verification_bundle_checksum(bundle : VerificationBundle) -> Int

    verification_bundle_expected_work

    source
    fn verification_bundle_expected_work(bundle : VerificationBundle) -> Int

    verification_bundle_is_deterministic

    source
    fn verification_bundle_is_deterministic(scenario : SimulationScenario, toolchain : String) -> Bool

    verification_bundle_matches_work

    source
    fn verification_bundle_matches_work(bundle : VerificationBundle) -> Bool

    verification_bundle_passes_thresholds

    source
    fn verification_bundle_passes_thresholds(bundle : VerificationBundle, charge : Double, energy : Double) -> Bool

    verification_bundle_records

    source
    fn verification_bundle_records(bundle : VerificationBundle) -> Array[QualityMetric]

    verification_bundle_schema

    source
    fn verification_bundle_schema() -> String

    verification_bundle_status

    source
    fn verification_bundle_status(bundle : VerificationBundle) -> String

    verification_bundle_to_text

    source
    fn verification_bundle_to_text(bundle : VerificationBundle) -> String

    vlasov_advect_x

    source
    fn vlasov_advect_x(state : VlasovState, velocity : Double) -> VlasovState

    vlasov_cfl

    source
    fn vlasov_cfl(config : VlasovConfig) -> Double

    vlasov_charge_from_density

    source
    fn vlasov_charge_from_density(_state : VlasovState, density : ArrayView[Double]) -> Array[Double]

    vlasov_clip_negative

    source
    fn vlasov_clip_negative(state : VlasovState) -> VlasovState

    vlasov_conservative_mass_correction

    source
    fn vlasov_conservative_mass_correction(state : VlasovState, reference_mass : Double) -> VlasovState

    vlasov_density

    source
    fn vlasov_density(config : VlasovConfig, distribution : ArrayView[Double]) -> Array[Double]

    vlasov_density_error

    source
    fn vlasov_density_error(state : VlasovState, expected : Double) -> Double

    vlasov_distribution_difference

    source
    fn vlasov_distribution_difference(first : VlasovState, second : VlasovState) -> Array[Double]

    vlasov_invariants

    source
    fn vlasov_invariants(state : VlasovState, expected_mass : Double) -> Array[InvariantCheck]

    vlasov_is_normalized

    source
    fn vlasov_is_normalized(state : VlasovState, expected : Double, tolerance : Double) -> Bool

    vlasov_is_positive

    source
    fn vlasov_is_positive(state : VlasovState) -> Bool

    vlasov_l2_difference

    source
    fn vlasov_l2_difference(first : VlasovState, second : VlasovState) -> Double

    vlasov_mass_error

    source
    fn vlasov_mass_error(first : VlasovState, second : VlasovState) -> Double

    vlasov_moments

    source
    fn vlasov_moments(state : VlasovState) -> Moments1D

    vlasov_report_to_csv

    source
    fn vlasov_report_to_csv(reports : ArrayView[VlasovStepReport]) -> String

    vlasov_rescale_mass

    source
    fn vlasov_rescale_mass(state : VlasovState, target : Double) -> VlasovState

    vlasov_run_reports

    source
    fn vlasov_run_reports(state : VlasovState, steps : Int) -> Array[VlasovStepReport]

    vlasov_shift_distribution

    source
    fn vlasov_shift_distribution(state : VlasovState, shift : Double) -> VlasovState

    vlasov_snapshot_to_csv

    source
    fn vlasov_snapshot_to_csv(state : VlasovState) -> String

    vlasov_step_report

    source
    fn vlasov_step_report(state : VlasovState) -> VlasovStepReport

    vlasov_summary_to_csv

    source
    fn vlasov_summary_to_csv(values : ArrayView[VlasovSummary]) -> String

    vlasov_time_series

    source
    fn vlasov_time_series(state : VlasovState, steps : Int) -> Array[VlasovSummary]

    wave_group_speed

    source
    fn wave_group_speed(omega_first : Double, omega_second : Double, wave_first : Double, wave_second : Double) -> Double

    wave_phase_speed

    source
    fn wave_phase_speed(omega : Double, wave_number : Double) -> Double

    wavelength_from_wavenumber

    source
    fn wavelength_from_wavenumber(wave_number : Double) -> Double

    wavenumber_from_wavelength

    source
    fn wavenumber_from_wavelength(wavelength : Double) -> Double

    weighted_histogram_particles

    source
    fn weighted_histogram_particles(grid : PhaseSpaceGrid, particles : ArrayView[Particle]) -> Array[Double]

    weighted_mean

    source
    fn weighted_mean(values : ArrayView[Double], weights : ArrayView[Double]) -> Double

    weighted_sum

    source
    fn weighted_sum(values : ArrayView[Double], weights : ArrayView[Double]) -> Double

    window_means

    source
    fn window_means(values : ArrayView[Double], width : Int, stride : Int) -> Array[Double]

    z_scores

    source
    fn z_scores(values : ArrayView[Double]) -> Array[Double]

    zeros

    source
    fn zeros(n : Int) -> Array[Double]

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io