SYMBOL INDEX (1731 symbols across 174 files)

FILE: cli/source/operator_factory.cpp
  type Operon (line 19) | namespace Operon { class PrimitiveSet; }
    class PrimitiveSet (line 19) | class PrimitiveSet
    class Problem (line 20) | class Problem
    type CrossoverBase (line 21) | struct CrossoverBase
    type MutatorBase (line 22) | struct MutatorBase
    type Variable (line 23) | struct Variable
    type detail (line 27) | namespace detail {
      function GetErrorString (line 28) | auto GetErrorString(std::string const& name, std::string const& arg) {
    function ParseReinserter (line 33) | auto ParseReinserter(std::string const& str, ComparisonCallback&& comp...
    function ParseSelector (line 46) | auto ParseSelector(std::string const& str, ComparisonCallback&& comp) ...
    function ParseCreator (line 82) | auto ParseCreator(std::string const& str, PrimitiveSet const& pset, st...
    function ParseEvaluator (line 108) | auto ParseEvaluator(std::string const& str, Problem& problem, ScalarDi...
    function ParseGenerator (line 141) | auto ParseGenerator(std::string const& str, EvaluatorBase& eval, Cross...
    function ParseOptimizer (line 176) | auto ParseOptimizer(std::string const& /*str*/, Problem const& /*probl...
  type Operon (line 20) | namespace Operon { class Problem; }
    class PrimitiveSet (line 19) | class PrimitiveSet
    class Problem (line 20) | class Problem
    type CrossoverBase (line 21) | struct CrossoverBase
    type MutatorBase (line 22) | struct MutatorBase
    type Variable (line 23) | struct Variable
    type detail (line 27) | namespace detail {
      function GetErrorString (line 28) | auto GetErrorString(std::string const& name, std::string const& arg) {
    function ParseReinserter (line 33) | auto ParseReinserter(std::string const& str, ComparisonCallback&& comp...
    function ParseSelector (line 46) | auto ParseSelector(std::string const& str, ComparisonCallback&& comp) ...
    function ParseCreator (line 82) | auto ParseCreator(std::string const& str, PrimitiveSet const& pset, st...
    function ParseEvaluator (line 108) | auto ParseEvaluator(std::string const& str, Problem& problem, ScalarDi...
    function ParseGenerator (line 141) | auto ParseGenerator(std::string const& str, EvaluatorBase& eval, Cross...
    function ParseOptimizer (line 176) | auto ParseOptimizer(std::string const& /*str*/, Problem const& /*probl...
  type Operon (line 21) | namespace Operon { struct CrossoverBase; }
    class PrimitiveSet (line 19) | class PrimitiveSet
    class Problem (line 20) | class Problem
    type CrossoverBase (line 21) | struct CrossoverBase
    type MutatorBase (line 22) | struct MutatorBase
    type Variable (line 23) | struct Variable
    type detail (line 27) | namespace detail {
      function GetErrorString (line 28) | auto GetErrorString(std::string const& name, std::string const& arg) {
    function ParseReinserter (line 33) | auto ParseReinserter(std::string const& str, ComparisonCallback&& comp...
    function ParseSelector (line 46) | auto ParseSelector(std::string const& str, ComparisonCallback&& comp) ...
    function ParseCreator (line 82) | auto ParseCreator(std::string const& str, PrimitiveSet const& pset, st...
    function ParseEvaluator (line 108) | auto ParseEvaluator(std::string const& str, Problem& problem, ScalarDi...
    function ParseGenerator (line 141) | auto ParseGenerator(std::string const& str, EvaluatorBase& eval, Cross...
    function ParseOptimizer (line 176) | auto ParseOptimizer(std::string const& /*str*/, Problem const& /*probl...
  type Operon (line 22) | namespace Operon { struct MutatorBase; }
    class PrimitiveSet (line 19) | class PrimitiveSet
    class Problem (line 20) | class Problem
    type CrossoverBase (line 21) | struct CrossoverBase
    type MutatorBase (line 22) | struct MutatorBase
    type Variable (line 23) | struct Variable
    type detail (line 27) | namespace detail {
      function GetErrorString (line 28) | auto GetErrorString(std::string const& name, std::string const& arg) {
    function ParseReinserter (line 33) | auto ParseReinserter(std::string const& str, ComparisonCallback&& comp...
    function ParseSelector (line 46) | auto ParseSelector(std::string const& str, ComparisonCallback&& comp) ...
    function ParseCreator (line 82) | auto ParseCreator(std::string const& str, PrimitiveSet const& pset, st...
    function ParseEvaluator (line 108) | auto ParseEvaluator(std::string const& str, Problem& problem, ScalarDi...
    function ParseGenerator (line 141) | auto ParseGenerator(std::string const& str, EvaluatorBase& eval, Cross...
    function ParseOptimizer (line 176) | auto ParseOptimizer(std::string const& /*str*/, Problem const& /*probl...
  type Operon (line 23) | namespace Operon { struct Variable; }
    class PrimitiveSet (line 19) | class PrimitiveSet
    class Problem (line 20) | class Problem
    type CrossoverBase (line 21) | struct CrossoverBase
    type MutatorBase (line 22) | struct MutatorBase
    type Variable (line 23) | struct Variable
    type detail (line 27) | namespace detail {
      function GetErrorString (line 28) | auto GetErrorString(std::string const& name, std::string const& arg) {
    function ParseReinserter (line 33) | auto ParseReinserter(std::string const& str, ComparisonCallback&& comp...
    function ParseSelector (line 46) | auto ParseSelector(std::string const& str, ComparisonCallback&& comp) ...
    function ParseCreator (line 82) | auto ParseCreator(std::string const& str, PrimitiveSet const& pset, st...
    function ParseEvaluator (line 108) | auto ParseEvaluator(std::string const& str, Problem& problem, ScalarDi...
    function ParseGenerator (line 141) | auto ParseGenerator(std::string const& str, EvaluatorBase& eval, Cross...
    function ParseOptimizer (line 176) | auto ParseOptimizer(std::string const& /*str*/, Problem const& /*probl...
  type Operon (line 25) | namespace Operon {
    class PrimitiveSet (line 19) | class PrimitiveSet
    class Problem (line 20) | class Problem
    type CrossoverBase (line 21) | struct CrossoverBase
    type MutatorBase (line 22) | struct MutatorBase
    type Variable (line 23) | struct Variable
    type detail (line 27) | namespace detail {
      function GetErrorString (line 28) | auto GetErrorString(std::string const& name, std::string const& arg) {
    function ParseReinserter (line 33) | auto ParseReinserter(std::string const& str, ComparisonCallback&& comp...
    function ParseSelector (line 46) | auto ParseSelector(std::string const& str, ComparisonCallback&& comp) ...
    function ParseCreator (line 82) | auto ParseCreator(std::string const& str, PrimitiveSet const& pset, st...
    function ParseEvaluator (line 108) | auto ParseEvaluator(std::string const& str, Problem& problem, ScalarDi...
    function ParseGenerator (line 141) | auto ParseGenerator(std::string const& str, EvaluatorBase& eval, Cross...
    function ParseOptimizer (line 176) | auto ParseOptimizer(std::string const& /*str*/, Problem const& /*probl...

FILE: cli/source/operator_factory.hpp
  type Operon (line 18) | namespace Operon { struct EvaluatorBase; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 19) | namespace Operon { class KeepBestReinserter; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 20) | namespace Operon { class OffspringGeneratorBase; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 21) | namespace Operon { class PrimitiveSet; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 22) | namespace Operon { class Problem; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 23) | namespace Operon { class ReinserterBase; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 24) | namespace Operon { class ReplaceWorstReinserter; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 25) | namespace Operon { class SelectorBase; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 26) | namespace Operon { struct CreatorBase; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 27) | namespace Operon { struct CrossoverBase; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 28) | namespace Operon { struct ErrorMetric; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 29) | namespace Operon { class CoefficientOptimizer; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 30) | namespace Operon { struct MutatorBase; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 31) | namespace Operon { struct Variable; }
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable
  type Operon (line 33) | namespace Operon {
    type EvaluatorBase (line 18) | struct EvaluatorBase
    class KeepBestReinserter (line 19) | class KeepBestReinserter
    class OffspringGeneratorBase (line 20) | class OffspringGeneratorBase
    class PrimitiveSet (line 21) | class PrimitiveSet
    class Problem (line 22) | class Problem
    class ReinserterBase (line 23) | class ReinserterBase
    class ReplaceWorstReinserter (line 24) | class ReplaceWorstReinserter
    class SelectorBase (line 25) | class SelectorBase
    type CreatorBase (line 26) | struct CreatorBase
    type CrossoverBase (line 27) | struct CrossoverBase
    type ErrorMetric (line 28) | struct ErrorMetric
    class CoefficientOptimizer (line 29) | class CoefficientOptimizer
    type MutatorBase (line 30) | struct MutatorBase
    type Variable (line 31) | struct Variable

FILE: cli/source/operon_gp.cpp
  function main (line 33) | auto main(int argc, char** argv) -> int

FILE: cli/source/operon_nsgp.cpp
  function main (line 39) | auto main(int argc, char** argv) -> int

FILE: cli/source/operon_parse_model.cpp
  type ParseError (line 28) | enum class ParseError : std::uint8_t  {
  function ParseOptions (line 36) | auto ParseOptions(int argc, char** argv) noexcept -> tl::expected<cxxopt...
  function ParseOptimizer (line 78) | auto ParseOptimizer(Operon::ScalarDispatch const* dtable, Operon::Proble...
  function main (line 100) | auto main(int argc, char** argv) -> int

FILE: cli/source/pareto_front.cpp
  type Operon (line 21) | namespace Operon {
    function WriteParetoFront (line 23) | auto WriteParetoFront(std::string const& path,

FILE: cli/source/pareto_front.hpp
  type Operon (line 13) | namespace Operon {

FILE: cli/source/reporter.hpp
  type Operon (line 10) | namespace Operon {
    class Reporter (line 15) | class Reporter {
      method Reporter (line 20) | explicit Reporter(gsl::not_null<Evaluator const*> evaluator)
      method PrintStats (line 23) | static auto PrintStats(std::vector<std::tuple<std::string, double, s...
      method GetBest (line 46) | auto GetBest() const -> Operon::Individual const& { return best_; }

FILE: cli/source/util.cpp
  type Operon (line 27) | namespace Operon {
    function Split (line 64) | auto Split(const std::string& s, char delimiter) -> std::vector<std::s...
    function FormatDuration (line 77) | auto FormatDuration(std::chrono::duration<double> d) -> std::string
    function FormatBytes (line 86) | auto FormatBytes(size_t bytes) -> std::string
    function ParseRange (line 94) | auto ParseRange(std::string const& str) -> std::pair<size_t, size_t>
    function ParsePrimitiveSetConfig (line 104) | auto ParsePrimitiveSetConfig(const std::string& options) -> PrimitiveS...
    function PrintPrimitives (line 117) | auto PrintPrimitives(PrimitiveSetConfig config) -> void
    function InitOptions (line 133) | auto InitOptions(std::string const& name, std::string const& desc, int...
    function ParseOptions (line 187) | auto ParseOptions(cxxopts::Options&& opts, int argc, char** argv) -> c...

FILE: cli/source/util.hpp
  type Operon (line 16) | namespace Operon {

FILE: example/custom_primitives.cpp
  function main (line 46) | auto main(int argc, char** argv) -> int

FILE: example/empty_example.cpp
  function main (line 1) | auto main() -> int

FILE: include/operon/algorithms/config.hpp
  type Operon (line 9) | namespace Operon {
    class Zobrist (line 11) | class Zobrist
    type GeneticAlgorithmConfig (line 13) | struct GeneticAlgorithmConfig {

FILE: include/operon/algorithms/ga_base.hpp
  type Operon (line 12) | namespace Operon {
    class Problem (line 14) | class Problem
    class ReinserterBase (line 15) | class ReinserterBase
    type CoefficientInitializerBase (line 16) | struct CoefficientInitializerBase
    type TreeInitializerBase (line 17) | struct TreeInitializerBase
    class GeneticAlgorithmBase (line 19) | class GeneticAlgorithmBase {
      method GeneticAlgorithmBase (line 22) | GeneticAlgorithmBase(const GeneticAlgorithmBase&) = default;
      method GeneticAlgorithmBase (line 23) | GeneticAlgorithmBase(GeneticAlgorithmBase&&) = delete;
      method GeneticAlgorithmBase (line 27) | GeneticAlgorithmBase(GeneticAlgorithmConfig config, gsl::not_null<Pr...
      method Parents (line 41) | [[nodiscard]] auto Parents() const -> Operon::Span<Individual const>...
      method Parents (line 42) | auto Parents() -> Operon::Span<Individual> { return parents_; }
      method Offspring (line 44) | [[nodiscard]] auto Offspring() const -> Operon::Span<Individual cons...
      method Offspring (line 45) | auto Offspring() -> Operon::Span<Individual> { return offspring_; }
      method Individuals (line 47) | [[nodiscard]] auto Individuals() -> Operon::Vector<Operon::Individua...
      method Individuals (line 48) | [[nodiscard]] auto Individuals() const -> Operon::Vector<Operon::Ind...
      method GetProblem (line 50) | [[nodiscard]] auto GetProblem() const -> const Problem* { return pro...
      method GetConfig (line 51) | [[nodiscard]] auto GetConfig() const -> GeneticAlgorithmConfig { ret...
      method GetTreeInitializer (line 53) | [[nodiscard]] auto GetTreeInitializer() const -> TreeInitializerBase...
      method GetCoefficientInitializer (line 54) | [[nodiscard]] auto GetCoefficientInitializer() const -> CoefficientI...
      method GetGenerator (line 55) | [[nodiscard]] auto GetGenerator() const -> OffspringGeneratorBase co...
      method GetReinserter (line 56) | [[nodiscard]] auto GetReinserter() const -> ReinserterBase const* { ...
      method Generation (line 58) | [[nodiscard]] auto Generation() const -> size_t { return generation_; }
      method Generation (line 59) | auto Generation() -> size_t& { return generation_; }
      method Elapsed (line 61) | [[nodiscard]] auto Elapsed() const -> double { return elapsed_; }
      method Elapsed (line 62) | auto Elapsed() -> double& { return elapsed_; }
      method IsFitted (line 64) | [[nodiscard]] auto IsFitted() const -> bool { return isFitted_; }
      method IsFitted (line 65) | auto IsFitted() -> bool& { return isFitted_; }
      method Reset (line 67) | auto Reset() -> void
      method RestoreIndividuals (line 74) | auto RestoreIndividuals(std::vector<Individual> inds) -> void

FILE: include/operon/algorithms/gp.hpp
  type tf (line 17) | namespace tf {
    class Executor (line 18) | class Executor
  type Operon (line 21) | namespace Operon {
    class Problem (line 23) | class Problem
    class ReinserterBase (line 24) | class ReinserterBase
    type CoefficientInitializerBase (line 25) | struct CoefficientInitializerBase
    type TreeInitializerBase (line 26) | struct TreeInitializerBase
    function GeneticProgrammingAlgorithm (line 28) | class OPERON_EXPORT GeneticProgrammingAlgorithm : public GeneticAlgori...

FILE: include/operon/algorithms/nsga2.hpp
  type tf (line 21) | namespace tf { class Executor; }
    class Executor (line 21) | class Executor
  type Operon (line 23) | namespace Operon {
    class NondominatedSorterBase (line 25) | class NondominatedSorterBase
    class Problem (line 26) | class Problem
    class ReinserterBase (line 27) | class ReinserterBase
    type CoefficientInitializerBase (line 28) | struct CoefficientInitializerBase
    type TreeInitializerBase (line 29) | struct TreeInitializerBase
    function GeneticAlgorithmBase (line 31) | class OPERON_EXPORT NSGA2 : public GeneticAlgorithmBase {
    function Best (line 49) | [[nodiscard]] auto Best() const -> Operon::Span<Individual const> { re...

FILE: include/operon/algorithms/solution_archive.hpp
  type Operon (line 10) | namespace Operon {
    class SolutionArchive (line 11) | class SolutionArchive {
      method Solutions (line 16) | [[nodiscard]] auto Solutions() const { return Operon::Span<Operon::I...
      method Clear (line 17) | auto Clear() { archive_.clear(); }

FILE: include/operon/analyzers/analyzer_base.hpp
  type Operon (line 9) | namespace Operon {
    class PopulationAnalyzerBase (line 11) | class PopulationAnalyzerBase : public OperatorBase<double> {

FILE: include/operon/analyzers/diversity.hpp
  type Operon (line 16) | namespace Operon {
    function MakeHashes (line 18) | inline auto MakeHashes(Tree& tree, Operon::HashMode m) -> Operon::Vect...
    class PopulationDiversityAnalyzer (line 28) | class PopulationDiversityAnalyzer final : PopulationAnalyzerBase<T> {
      method Prepare (line 35) | void Prepare(Operon::Span<T> pop)

FILE: include/operon/ceres/integer_sequence_algorithm.h
  function namespace (line 43) | namespace ceres {

FILE: include/operon/ceres/jet.h
  function namespace (line 208) | namespace ceres {
  function isless (line 472) | inline bool isless(double lhs,
  function islessequal (line 476) | inline bool islessequal(double lhs,
  function isgreaterequal (line 481) | inline bool isgreaterequal(double lhs, double rhs) noexcept(
  function islessgreater (line 485) | inline bool islessgreater(double lhs, double rhs) noexcept(
  function isunordered (line 489) | inline bool isunordered(double lhs,
  function IsFinite (line 511) | inline bool IsFinite(double x)   { return std::isfinite(x); }
  function IsInfinite (line 513) | inline bool IsInfinite(double x) { return std::isinf(x);    }
  function IsNaN (line 515) | inline bool IsNaN(double x)      { return std::isnan(x);    }
  function IsNormal (line 517) | inline bool IsNormal(double x)   { return std::isnormal(x); }
  function fdim (line 838) | decltype(auto) fdim(const Lhs& f, const Rhs& g) {
  function BesselJ0 (line 876) | inline double BesselJ0(double x) {
  function BesselJ1 (line 883) | inline double BesselJ1(double x) {
  function BesselJn (line 890) | inline double BesselJn(int n, double x) {
  function isfinite (line 947) | bool isfinite(const Jet<T, N>& f) {
  function isinf (line 953) | bool isinf(const Jet<T, N>& f) {
  function isnan (line 959) | bool isnan(const Jet<T, N>& f) {
  function isnormal (line 966) | bool isnormal(const Jet<T, N>& f) {
  function isless (line 977) | bool isless(const Lhs& f, const Rhs& g) {
  function isgreater (line 989) | bool isgreater(const Lhs& f, const Rhs& g) {
  function islessequal (line 1001) | bool islessequal(const Lhs& f, const Rhs& g) {
  function islessgreater (line 1013) | bool islessgreater(const Lhs& f, const Rhs& g) {
  function isgreaterequal (line 1025) | bool isgreaterequal(const Lhs& f, const Rhs& g) {
  function isunordered (line 1035) | bool isunordered(const Lhs& f, const Rhs& g) {
  function fpclassify (line 1043) | int fpclassify(const Jet<T, N>& f) {
  function signbit (line 1049) | bool signbit(const Jet<T, N>& f) {
  function IsFinite (line 1058) | inline bool IsFinite(const Jet<T, N>& f) {
  function IsNaN (line 1066) | inline bool IsNaN(const Jet<T, N>& f) {
  function IsNormal (line 1074) | inline bool IsNormal(const Jet<T, N>& f) {
  function IsInfinite (line 1083) | inline bool IsInfinite(const Jet<T, N>& f) {
  function namespace (line 1298) | namespace std {
  function namespace (line 1364) | namespace Eigen {

FILE: include/operon/ceres/jet_fwd.h
  function namespace (line 35) | namespace ceres {

FILE: include/operon/ceres/jet_traits.h
  function namespace (line 42) | namespace ceres {

FILE: include/operon/ceres/tiny_solver.h
  function namespace (line 59) | namespace ceres {

FILE: include/operon/collections/bitset.hpp
  type Operon (line 9) | namespace Operon {
    class Bitset (line 12) | class Bitset {
      method WordOf (line 18) | [[nodiscard]] constexpr auto WordOf(std::size_t i) const -> std::siz...
      method BitOf (line 19) | [[nodiscard]] constexpr auto BitOf(std::size_t i)  const -> std::siz...
      method Bitset (line 22) | constexpr Bitset() = default;
      method Set (line 25) | constexpr void Set(std::size_t i)   { words_[WordOf(i)] |=  (uint64_...
      method Clear (line 26) | constexpr void Clear(std::size_t i) { words_[WordOf(i)] &= ~(uint64_...
      method Test (line 27) | [[nodiscard]] constexpr auto Test(std::size_t i) const -> bool {
      method Any (line 68) | [[nodiscard]] constexpr auto Any() const -> bool {
      method None (line 74) | [[nodiscard]] constexpr auto None() const -> bool { return !Any(); }
      method Count (line 76) | [[nodiscard]] constexpr auto Count() const -> std::size_t {
      method ForEach (line 86) | constexpr void ForEach(F&& f) const {

FILE: include/operon/collections/projection.hpp
  type Operon (line 11) | namespace Operon {
    type ProjectionIterator (line 15) | struct ProjectionIterator {
      method ProjectionIterator (line 26) | explicit ProjectionIterator(InputIt it, Func const& f) : it_(it), pr...
      method ProjectionIterator (line 27) | explicit ProjectionIterator(InputIt it, Func&& f) : it_(it), pr_(std...
    type Projection (line 129) | struct Projection {
      method Projection (line 132) | explicit Projection(Container const& c, Func const& f)
      method begin (line 137) | auto begin() const -> InputIt { return beg_; }
      method end (line 138) | auto end() const -> InputIt { return end_; }
      method empty (line 139) | bool empty() const noexcept { return beg_ == end_; }

FILE: include/operon/core/aligned_allocator.hpp
  class AlignedAllocator (line 12) | class AlignedAllocator {
    type rebind (line 22) | struct rebind {
    method AlignedAllocator (line 26) | constexpr AlignedAllocator() noexcept = default;
    method AlignedAllocator (line 27) | constexpr AlignedAllocator(AlignedAllocator const& other) noexcept = d...
    method AlignedAllocator (line 30) | explicit constexpr AlignedAllocator(AlignedAllocator<U, Alignment> con...
    method allocate (line 43) | [[nodiscard]] auto allocate(std::size_t n) -> T* {
    method allocate_at_least (line 51) | [[nodiscard]] auto allocate_at_least(std::size_t num_elements) -> std:...
    method deallocate (line 57) | auto deallocate(T* p, [[maybe_unused]] std::size_t n) -> void {

FILE: include/operon/core/comparison.hpp
  type Operon (line 14) | namespace Operon {
    type Dominance (line 16) | enum class Dominance : int { Equal = 0,
    type Equal (line 21) | struct Equal {
    type Less (line 41) | struct Less {
    type LessEqual (line 69) | struct LessEqual {
    type ParetoDominance (line 78) | struct ParetoDominance {

FILE: include/operon/core/concepts.hpp
  type Operon::Concepts (line 7) | namespace Operon::Concepts {

FILE: include/operon/core/constants.hpp
  type Operon (line 10) | namespace Operon {
    type HashMode (line 14) | enum HashMode {
    type HashFunction (line 19) | enum HashFunction {
    type Math (line 26) | struct Math {

FILE: include/operon/core/dataset.hpp
  type Operon (line 18) | namespace Operon {
    function Dataset (line 22) | class OPERON_EXPORT Dataset {

FILE: include/operon/core/dispatch.hpp
  type Operon (line 18) | namespace Operon {
    type Backend (line 20) | namespace Backend {
      function Ptr (line 41) | auto Ptr(View<T, S> view, std::integral auto col) -> Backend::View<T...
      function Fill (line 47) | auto Fill(Backend::View<T, S> view, int idx, T value) {
    type Func (line 55) | struct Func {
    type Diff (line 63) | struct Diff {
    type Dispatch (line 70) | struct Dispatch {
      method NaryOp (line 89) | static void NaryOp(Operon::Vector<Node> const& nodes, Backend::View<...
      method BinaryOp (line 138) | static void BinaryOp(Operon::Vector<Node> const& nodes, Backend::Vie...
      method UnaryOp (line 147) | static void UnaryOp(Operon::Vector<Node> const& nodes, Backend::View...
      type Noop (line 152) | struct Noop {
      method DiffOp (line 158) | static void DiffOp(Operon::Vector<Node> const& nodes, Backend::View<...
      method MakeFunctionCall (line 163) | static constexpr auto MakeFunctionCall() -> Dispatch::Callable<T, S>
      method MakeDiffCall (line 175) | static constexpr auto MakeDiffCall() -> Dispatch::CallableDiff<T, S>
    type detail (line 186) | namespace detail {
      function TypeIndexImpl (line 189) | static auto constexpr TypeIndexImpl() {
      type DefaultIndex (line 204) | struct DefaultIndex {
      type IntegerIndex (line 209) | struct IntegerIndex {
    type DispatchTable (line 215) | struct DispatchTable {
      method MakeFunction (line 263) | static constexpr auto MakeFunction() {
      method MakeDerivative (line 269) | static constexpr auto MakeDerivative() {
      method MakeTuple (line 274) | static constexpr auto MakeTuple()
      method DispatchTable (line 298) | DispatchTable()
      method DispatchTable (line 323) | explicit DispatchTable(Map const& map) : map_(map) { }
      method DispatchTable (line 324) | explicit DispatchTable(Map&& map) : map_(std::move(map)) { }
      method DispatchTable (line 325) | explicit DispatchTable(std::unordered_map<Operon::Hash, Tuple> const...
      method DispatchTable (line 327) | DispatchTable(DispatchTable const& other) : map_(other.map_) { }
      method DispatchTable (line 328) | DispatchTable(DispatchTable &&other) noexcept : map_(std::move(other...
      method GetMap (line 330) | auto GetMap() -> Map& { return map_; }
      method GetMap (line 331) | auto GetMap() const -> Map const& { return map_; }
      method GetFunction (line 334) | auto GetFunction(Operon::Hash const h) -> Callable<T>&
      method GetDerivative (line 340) | auto GetDerivative(Operon::Hash const h) -> CallableDiff<T>&
      method GetFunction (line 346) | [[nodiscard]] auto GetFunction(Operon::Hash const h) const -> Callab...
      method GetDerivative (line 355) | [[nodiscard]] auto GetDerivative(Operon::Hash const h) const -> Call...
      method Get (line 364) | [[nodiscard]] auto Get(Operon::Hash const h) const -> std::tuple<Cal...
      method RegisterFunction (line 377) | void RegisterFunction(Operon::Hash hash, Callable<T> f, CallableDiff...
      method TryGetFunction (line 384) | [[nodiscard]] auto TryGetFunction(Operon::Hash const h) const noexce...
      method TryGetDerivative (line 393) | [[nodiscard]] auto TryGetDerivative(Operon::Hash const h) const noex...
      method Contains (line 401) | [[nodiscard]] auto Contains(Operon::Hash hash) const noexcept -> boo...

FILE: include/operon/core/distance.hpp
  type Operon::Distance (line 10) | namespace Operon::Distance {

FILE: include/operon/core/individual.hpp
  type Operon (line 13) | namespace Operon {
    type LexicographicalComparison (line 15) | struct LexicographicalComparison
    type Individual (line 17) | struct Individual {
      method Size (line 26) | [[nodiscard]] inline auto Size() const noexcept -> size_t { return F...
      method Individual (line 28) | Individual()
      method Individual (line 32) | explicit Individual(size_t nObj)
    type SingleObjectiveComparison (line 38) | struct SingleObjectiveComparison {
      method SingleObjectiveComparison (line 39) | explicit SingleObjectiveComparison(size_t idx)
      method SingleObjectiveComparison (line 43) | SingleObjectiveComparison()
      method GetObjectiveIndex (line 53) | [[nodiscard]] auto GetObjectiveIndex() const -> size_t { return obj_; }
      method SetObjectiveIndex (line 54) | void SetObjectiveIndex(size_t obj) { obj_ = obj; }
    type LexicographicalComparison (line 60) | struct LexicographicalComparison {
    type ParetoComparison (line 72) | struct ParetoComparison {
    type CrowdedComparison (line 83) | struct CrowdedComparison {

FILE: include/operon/core/node.hpp
  type Operon (line 14) | namespace Operon {
    type NodeType (line 15) | enum class NodeType : uint8_t {
    type NodeTypes (line 59) | struct NodeTypes {
      method GetIndex (line 64) | static constexpr auto GetIndex(NodeType type) -> size_t
    type Node (line 97) | struct Node {
      method Node (line 110) | Node() = default;
      method Node (line 112) | explicit Node(NodeType type) noexcept
      method Node (line 117) | explicit Node(NodeType type, Operon::Hash hashValue) noexcept
      method Constant (line 140) | static auto Constant(double value)
      method IsLeaf (line 185) | [[nodiscard]] inline auto IsLeaf() const noexcept -> bool { return A...
      method IsCommutative (line 186) | [[nodiscard]] inline auto IsCommutative() const noexcept -> bool { r...
      method Is (line 189) | [[nodiscard]] inline auto Is() const -> bool { return ((Type == T) |...
      method IsConstant (line 191) | [[nodiscard]] inline auto IsConstant() const -> bool { return Is<Nod...
      method IsVariable (line 192) | [[nodiscard]] inline auto IsVariable() const -> bool { return Is<Nod...
      method IsAddition (line 193) | [[nodiscard]] inline auto IsAddition() const -> bool { return Is<Nod...
      method IsSubtraction (line 194) | [[nodiscard]] inline auto IsSubtraction() const -> bool { return Is<...
      method IsMultiplication (line 195) | [[nodiscard]] inline auto IsMultiplication() const -> bool { return ...
      method IsDivision (line 196) | [[nodiscard]] inline auto IsDivision() const -> bool { return Is<Nod...
      method IsAq (line 197) | [[nodiscard]] inline auto IsAq() const -> bool { return Is<NodeType:...
      method IsPow (line 198) | [[nodiscard]] inline auto IsPow() const -> bool { return Is<NodeType...
      method IsPowabs (line 199) | [[nodiscard]] inline auto IsPowabs() const -> bool { return Is<NodeT...
      method IsExp (line 200) | [[nodiscard]] inline auto IsExp() const -> bool { return Is<NodeType...
      method IsLog (line 201) | [[nodiscard]] inline auto IsLog() const -> bool { return Is<NodeType...
      method IsSin (line 202) | [[nodiscard]] inline auto IsSin() const -> bool { return Is<NodeType...
      method IsCos (line 203) | [[nodiscard]] inline auto IsCos() const -> bool { return Is<NodeType...
      method IsTan (line 204) | [[nodiscard]] inline auto IsTan() const -> bool { return Is<NodeType...
      method IsTanh (line 205) | [[nodiscard]] inline auto IsTanh() const -> bool { return Is<NodeTyp...
      method IsSquareRoot (line 206) | [[nodiscard]] inline auto IsSquareRoot() const -> bool { return Is<N...
      method IsCubeRoot (line 207) | [[nodiscard]] inline auto IsCubeRoot() const -> bool { return Is<Nod...
      method IsSquare (line 208) | [[nodiscard]] inline auto IsSquare() const -> bool { return Is<NodeT...
      method IsDynamic (line 209) | [[nodiscard]] inline auto IsDynamic() const -> bool { return Is<Node...

FILE: include/operon/core/operator.hpp
  type Operon (line 9) | namespace Operon {
    type OperatorBase (line 11) | struct OperatorBase {
      method OperatorBase (line 18) | OperatorBase() = default;
      method OperatorBase (line 19) | OperatorBase(OperatorBase const& other) = default;
      method OperatorBase (line 20) | OperatorBase(OperatorBase&& other) noexcept = default;

FILE: include/operon/core/problem.hpp
  type Operon (line 16) | namespace Operon {
    class Problem (line 18) | class Problem {
      method GetVariable (line 19) | [[nodiscard]] auto GetVariable(auto t) const -> Operon::Variable {
      method ValidateInputs (line 24) | auto ValidateInputs(auto const& inputs) const {
      method Problem (line 43) | Problem(const Problem&) = delete;
      method Problem (line 44) | Problem(Problem&&) = delete;
      method Problem (line 48) | explicit Problem(std::unique_ptr<Dataset> dataset)
      method Problem (line 54) | explicit Problem(gsl::not_null<Dataset*> dataset)
      method SetTarget (line 67) | auto SetTarget(T t) {
      method SetTrainingRange (line 71) | auto SetTrainingRange(Operon::Range range) { training_ = range; }
      method SetTrainingRange (line 72) | auto SetTrainingRange(int begin, int end) { training_ = Operon::Rang...
      method SetTestRange (line 74) | auto SetTestRange(Operon::Range range) { test_ = range; }
      method SetTestRange (line 75) | auto SetTestRange(int begin, int end) { test_ = Operon::Range(begin,...
      method SetValidationRange (line 77) | auto SetValidationRange(Operon::Range range) { validation_ = range; }
      method SetValidationRange (line 78) | auto SetValidationRange(int begin, int end) { validation_ = Operon::...
      method SetInputs (line 80) | auto SetInputs(auto const& inputs) {
      method GetInputs (line 88) | [[nodiscard]] auto GetInputs() const -> std::vector<Operon::Hash> co...
      method SetDefaultInputs (line 93) | auto SetDefaultInputs() -> void {
      method TrainingRange (line 100) | [[nodiscard]] auto TrainingRange() const -> Range { return training_; }
      method TestRange (line 101) | [[nodiscard]] auto TestRange() const -> Range { return test_; }
      method ValidationRange (line 102) | [[nodiscard]] auto ValidationRange() const -> Range { return validat...
      method TargetVariable (line 104) | [[nodiscard]] auto TargetVariable() const -> Variable const& { retur...
      method InputVariables (line 105) | [[nodiscard]] auto InputVariables() const -> std::vector<Variable>
      method GetPrimitiveSet (line 113) | [[nodiscard]] auto GetPrimitiveSet() const -> PrimitiveSet const& { ...
      method GetPrimitiveSet (line 114) | auto GetPrimitiveSet() -> PrimitiveSet& { return pset_; }
      method ConfigurePrimitiveSet (line 115) | auto ConfigurePrimitiveSet(Operon::PrimitiveSetConfig config) { pset...
      method GetDataset (line 117) | [[nodiscard]] auto GetDataset() const -> Dataset const* { return dat...
      method GetDataset (line 118) | auto GetDataset() -> Dataset* { return dataset_.get(); }
      method TargetValues (line 120) | [[nodiscard]] auto TargetValues() const -> Operon::Span<Operon::Scal...
      method TargetValues (line 121) | [[nodiscard]] auto TargetValues(Operon::Range range) const -> Operon...
      method StandardizeData (line 125) | void StandardizeData(Range range)
      method NormalizeData (line 132) | void NormalizeData(Range range)

FILE: include/operon/core/pset.hpp
  type Operon (line 10) | namespace Operon {
    class PrimitiveSet (line 12) | class PrimitiveSet {
      method GetPrimitive (line 25) | auto GetPrimitive(Operon::Hash hash) -> Primitive& {
      method PrimitiveSet (line 35) | PrimitiveSet() = default;
      method PrimitiveSet (line 37) | explicit PrimitiveSet(PrimitiveSetConfig config)
      method Primitives (line 42) | [[nodiscard]] auto Primitives() const -> decltype(pset_) const& { re...
      method AddPrimitive (line 44) | auto AddPrimitive(Operon::Node node, size_t frequency, size_t minAri...
      method AddFunction (line 52) | auto AddFunction(Operon::Hash hash, uint16_t arity, size_t frequency...
      method RemovePrimitive (line 61) | void RemovePrimitive(Operon::Node node) { pset_.erase(node.HashValue...
      method RemovePrimitive (line 63) | void RemovePrimitive(Operon::Hash hash) { pset_.erase(hash); }
      method SetConfig (line 65) | void SetConfig(PrimitiveSetConfig config)
      method EnabledPrimitives (line 78) | [[nodiscard]] auto EnabledPrimitives() const -> std::vector<Node> {
      method Config (line 89) | [[nodiscard]] auto Config() const -> PrimitiveSetConfig
      method Frequency (line 101) | [[nodiscard]] auto Frequency(Operon::Hash hash) const -> size_t
      method SetFrequency (line 107) | void SetFrequency(Operon::Hash hash, size_t frequency)
      method Contains (line 113) | [[nodiscard]] auto Contains(Operon::Hash hash) const -> bool { retur...
      method IsEnabled (line 115) | [[nodiscard]] auto IsEnabled(Operon::Hash hash) const -> bool
      method SetEnabled (line 121) | void SetEnabled(Operon::Hash hash, bool enabled)
      method Enable (line 127) | void Enable(Operon::Hash hash)
      method Disable (line 132) | void Disable(Operon::Hash hash)
      method FunctionArityLimits (line 148) | [[nodiscard]] auto FunctionArityLimits() const -> std::pair<size_t, ...
      method SetMinimumArity (line 162) | void SetMinimumArity(Operon::Hash hash, size_t minArity)
      method MinimumArity (line 169) | [[nodiscard]] auto MinimumArity(Operon::Hash hash) const -> size_t
      method SetMaximumArity (line 175) | void SetMaximumArity(Operon::Hash hash, size_t maxArity)
      method MaximumArity (line 182) | [[nodiscard]] auto MaximumArity(Operon::Hash hash) const -> size_t
      method MinMaxArity (line 188) | [[nodiscard]] auto MinMaxArity(Operon::Hash hash) const -> std::tupl...
      method SetMinMaxArity (line 194) | void SetMinMaxArity(Operon::Hash hash, size_t minArity, size_t maxAr...
      method SetFrequency (line 203) | void SetFrequency(Operon::Node node, size_t frequency) { SetFrequenc...
      method Frequency (line 204) | [[nodiscard]] auto Frequency(Operon::Node node) const -> size_t { re...
      method Contains (line 206) | [[nodiscard]] auto Contains(Operon::Node node) const -> bool { retur...
      method IsEnabled (line 207) | [[nodiscard]] auto IsEnabled(Operon::Node node) const -> bool { retu...
      method SetEnabled (line 209) | void SetEnabled(Operon::Node node, bool enabled) { SetEnabled(node.H...
      method Enable (line 210) | void Enable(Operon::Node node) { SetEnabled(node, /*enabled=*/true); }
      method Disable (line 211) | void Disable(Operon::Node node) { SetEnabled(node, /*enabled=*/false...
      method SetMinimumArity (line 213) | void SetMinimumArity(Operon::Node node, size_t minArity)
      method MinimumArity (line 217) | [[nodiscard]] auto MinimumArity(Operon::Node node) const -> size_t {...
      method SetMaximumArity (line 219) | void SetMaximumArity(Operon::Node node, size_t maxArity)
      method MaximumArity (line 223) | [[nodiscard]] auto MaximumArity(Operon::Node node) const -> size_t {...
      method MinMaxArity (line 225) | [[nodiscard]] auto MinMaxArity(Operon::Node node) const -> std::tupl...
      method SetMinMaxArity (line 229) | void SetMinMaxArity(Operon::Node node, size_t minArity, size_t maxAr...

FILE: include/operon/core/range.hpp
  type Operon (line 10) | namespace Operon {
    class Range (line 11) | class Range {
      method Start (line 13) | [[nodiscard]] inline auto Start() const noexcept -> std::size_t { re...
      method End (line 14) | [[nodiscard]] inline auto End() const noexcept -> std::size_t { retu...
      method Size (line 15) | [[nodiscard]] inline auto Size() const noexcept -> std::size_t { ret...
      method Bounds (line 16) | [[nodiscard]] auto Bounds() const noexcept -> std::pair<std::size_t,...
      method Range (line 18) | Range() = default;
      method Range (line 19) | Range(std::size_t start, std::size_t end)
      method Range (line 24) | explicit Range(std::pair<std::size_t, std::size_t> range)
      method CheckRange (line 37) | static auto CheckRange(std::size_t start, std::size_t end) -> std::p...

FILE: include/operon/core/subtree.hpp
  type Operon (line 9) | namespace Operon {
    type Subtree (line 14) | struct Subtree {
      method Subtree (line 15) | Subtree(Operon::Span<T> nodes, std::size_t parent)
      type Sentinel (line 19) | struct Sentinel {}
      type Enumerator (line 22) | struct Enumerator {
        method Enumerator (line 28) | Enumerator(Operon::Span<T> nodes, std::size_t parent)
        method begin (line 44) | auto begin() const { return *this; }
        method end (line 45) | auto end() const { return Sentinel{}; }
      type SubtreeIterator (line 69) | struct SubtreeIterator {
        method SubtreeIterator (line 75) | SubtreeIterator(Operon::Span<T> nodes, std::size_t parent)
        method begin (line 81) | inline auto begin() const { return *this; }
        method end (line 82) | inline auto end() const { return Sentinel{}; }
        method Done (line 119) | [[nodiscard]] inline auto Done() const -> bool { return Index >= N...
      method Indices (line 130) | [[nodiscard]] inline auto Indices() const { return IndexIterator{nod...
      method EnumerateIndices (line 131) | [[nodiscard]] inline auto EnumerateIndices() const { return Enumerat...
      method Nodes (line 133) | [[nodiscard]] inline auto Nodes() const { return NodeIterator{nodes_...
      method EnumerateNodes (line 134) | [[nodiscard]] inline auto EnumerateNodes() const { return Enumerator...

FILE: include/operon/core/symbol_library.hpp
  type Operon (line 27) | namespace Operon {
    function MakeUnaryCallable (line 33) | auto MakeUnaryCallable(F primal) -> typename DTable::template Callable<T>
    function MakeBinaryCallable (line 53) | auto MakeBinaryCallable(F primal) -> typename DTable::template Callabl...
    function MakeUnaryDiff (line 76) | auto MakeUnaryDiff(DF deriv) -> typename DTable::template CallableDiff<T>
    function MakeBinaryDiff (line 99) | auto MakeBinaryDiff(DFa derivA, DFb derivB) -> typename DTable::templa...
    function MakeUnaryAutoDiff (line 126) | auto MakeUnaryAutoDiff(F primal) -> typename DTable::template Callable...
    function MakeBinaryAutoDiff (line 148) | auto MakeBinaryAutoDiff(F primal) -> typename DTable::template Callabl...
    function RegisterUnary (line 181) | void RegisterUnary(DTable& dt, Operon::Hash hash, F primal, DF deriv =...
    function RegisterBinary (line 203) | void RegisterBinary(DTable& dt, Operon::Hash hash, F primal,
    type FunctionInfo (line 223) | struct FunctionInfo {
    function RegisterUnaryFunction (line 235) | void RegisterUnaryFunction(DTable& dt, PrimitiveSet& pset,
    function RegisterBinaryFunction (line 248) | void RegisterBinaryFunction(DTable& dt, PrimitiveSet& pset,

FILE: include/operon/core/tree.hpp
  type Operon (line 16) | namespace Operon {
    function Tree (line 17) | class OPERON_EXPORT Tree { // NOLINT

FILE: include/operon/core/types.hpp
  type Operon (line 17) | namespace Operon {

FILE: include/operon/core/variable.hpp
  type Operon (line 9) | namespace Operon {
    type Variable (line 10) | struct Variable {

FILE: include/operon/core/version.hpp
  type Operon (line 12) | namespace Operon {

FILE: include/operon/error_metrics/correlation_coefficient.hpp
  type Operon (line 12) | namespace Operon {
    function CorrelationCoefficient (line 15) | inline auto CorrelationCoefficient(InputIt1 begin1, InputIt1 end1, Inp...
    function CorrelationCoefficient (line 26) | inline auto CorrelationCoefficient(InputIt1 begin1, InputIt1 end1, Inp...
    function CorrelationCoefficient (line 37) | inline auto CorrelationCoefficient(Operon::Span<T const> x, Operon::Sp...
    function CorrelationCoefficient (line 46) | inline auto CorrelationCoefficient(Operon::Span<T const> x, Operon::Sp...
    function SquaredCorrelation (line 55) | inline auto SquaredCorrelation(InputIt1 begin1, InputIt1 end1, InputIt...
    function SquaredCorrelation (line 61) | inline auto SquaredCorrelation(InputIt1 begin1, InputIt1 end1, InputIt...
    function SquaredCorrelation (line 67) | inline auto SquaredCorrelation(Operon::Span<T const> x, Operon::Span<T...
    function SquaredCorrelation (line 73) | inline auto SquaredCorrelation(Operon::Span<T const> x, Operon::Span<T...

FILE: include/operon/error_metrics/mean_absolute_error.hpp
  type Operon (line 12) | namespace Operon {
    function MeanAbsoluteError (line 15) | inline auto MeanAbsoluteError(InputIt1 begin1, InputIt1 end1, InputIt2...
    function MeanAbsoluteError (line 26) | inline auto MeanAbsoluteError(InputIt1 begin1, InputIt1 end1, InputIt2...
    function MeanAbsoluteError (line 37) | inline auto MeanAbsoluteError(Operon::Span<T const> x, Operon::Span<T ...
    function MeanAbsoluteError (line 46) | inline auto MeanAbsoluteError(Operon::Span<T const> x, Operon::Span<T ...

FILE: include/operon/error_metrics/mean_squared_error.hpp
  type Operon (line 13) | namespace Operon {
    function MeanSquaredError (line 16) | inline auto MeanSquaredError(InputIt1 begin1, InputIt1 end1, InputIt2 ...
    function MeanSquaredError (line 28) | inline auto MeanSquaredError(InputIt1 begin1, InputIt1 end1, InputIt2 ...
    function MeanSquaredError (line 40) | inline auto MeanSquaredError(Operon::Span<T const> x, Operon::Span<T c...
    function MeanSquaredError (line 49) | inline auto MeanSquaredError(Operon::Span<T const> x, Operon::Span<T c...

FILE: include/operon/error_metrics/normalized_mean_squared_error.hpp
  type Operon (line 13) | namespace Operon {
    function NormalizedMeanSquaredError (line 16) | inline auto NormalizedMeanSquaredError(InputIt1 begin1, InputIt1 end1,...
    function NormalizedMeanSquaredError (line 31) | inline auto NormalizedMeanSquaredError(InputIt1 begin1, InputIt1 end1,...
    function NormalizedMeanSquaredError (line 46) | inline auto NormalizedMeanSquaredError(Operon::Span<T const> x, Operon...
    function NormalizedMeanSquaredError (line 52) | inline auto NormalizedMeanSquaredError(Operon::Span<T const> x, Operon...

FILE: include/operon/error_metrics/r2_score.hpp
  type Operon (line 12) | namespace Operon {
    function R2Score (line 14) | inline auto R2Score(InputIt1 begin1, InputIt1 end1, InputIt2 begin2) n...
    function R2Score (line 30) | inline auto R2Score(InputIt1 begin1, InputIt1 end1, InputIt2 begin2, I...
    function R2Score (line 48) | inline auto R2Score(Operon::Span<T const> x, Operon::Span<T const> y) ...
    function R2Score (line 55) | inline auto R2Score(Operon::Span<T const> x, Operon::Span<T const> y, ...

FILE: include/operon/error_metrics/root_mean_squared_error.hpp
  type Operon (line 13) | namespace Operon {
    function RootMeanSquaredError (line 16) | inline auto RootMeanSquaredError(InputIt1 begin1, InputIt1 end1, Input...
    function RootMeanSquaredError (line 22) | inline auto RootMeanSquaredError(InputIt1 begin1, InputIt1 end1, Input...
    function RootMeanSquaredError (line 28) | inline auto RootMeanSquaredError(Operon::Span<T const> x, Operon::Span...
    function RootMeanSquaredError (line 34) | inline auto RootMeanSquaredError(Operon::Span<T const> x, Operon::Span...

FILE: include/operon/error_metrics/sum_of_squared_errors.hpp
  type Operon (line 12) | namespace Operon {
    function SumOfSquaredErrors (line 15) | inline auto SumOfSquaredErrors(InputIt1 begin1, InputIt1 end1, InputIt...
    function SumOfSquaredErrors (line 27) | inline auto SumOfSquaredErrors(InputIt1 begin1, InputIt1 end1, InputIt...
    function SumOfSquaredErrors (line 39) | inline auto SumOfSquaredErrors(Operon::Span<T const> x, Operon::Span<T...
    function SumOfSquaredErrors (line 48) | inline auto SumOfSquaredErrors(Operon::Span<T const> x, Operon::Span<T...

FILE: include/operon/formatter/formatter.hpp
  type Operon (line 11) | namespace Operon {
    class Dataset (line 13) | class Dataset
    function TreeFormatter (line 15) | class OPERON_EXPORT TreeFormatter {
    function InfixFormatter (line 23) | class OPERON_EXPORT InfixFormatter {
    function PostfixFormatter (line 31) | class OPERON_EXPORT PostfixFormatter {
    function DotFormatter (line 39) | struct OPERON_EXPORT DotFormatter {

FILE: include/operon/hash/hash.hpp
  type Operon (line 14) | namespace Operon {
    function Hasher (line 15) | struct OPERON_EXPORT Hasher {

FILE: include/operon/hash/metrohash64.hpp
  type Operon::HashUtil (line 9) | namespace Operon::HashUtil {
    class MetroHash64 (line 11) | class MetroHash64

FILE: include/operon/hash/zobrist.hpp
  type Operon (line 15) | namespace Operon {
    function Zobrist (line 26) | class OPERON_EXPORT Zobrist {

FILE: include/operon/interpreter/backend/arma/derivatives.hpp
  type Operon::Backend (line 10) | namespace Operon::Backend {
    type detail (line 11) | namespace detail {
      function IsNaN (line 13) | inline auto IsNaN(T value) { return std::isnan(value); }
      type FComp (line 16) | struct FComp {
    function Add (line 30) | auto Add(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Mul (line 35) | auto Mul(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sub (line 40) | auto Sub(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Div (line 46) | auto Div(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Aq (line 56) | auto Aq(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T co...
    function Pow (line 65) | auto Pow(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Powabs (line 76) | auto Powabs(std::vector<Operon::Node> const& nodes, Backend::View<T co...
    function Min (line 87) | auto Min(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Max (line 95) | auto Max(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Square (line 103) | auto Square(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Abs (line 108) | auto Abs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Ceil (line 113) | auto Ceil(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Floor (line 118) | auto Floor(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Exp (line 123) | auto Exp(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log (line 128) | auto Log(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log1p (line 133) | auto Log1p(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Logabs (line 138) | auto Logabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sin (line 143) | auto Sin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Cos (line 148) | auto Cos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Tan (line 153) | auto Tan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sinh (line 158) | auto Sinh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Cosh (line 163) | auto Cosh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Tanh (line 168) | auto Tanh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Asin (line 173) | auto Asin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Acos (line 178) | auto Acos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Atan (line 183) | auto Atan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrt (line 188) | auto Sqrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrtabs (line 193) | auto Sqrtabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cbrt (line 198) | auto Cbrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...

FILE: include/operon/interpreter/backend/arma/functions.hpp
  type Operon::Backend (line 11) | namespace Operon::Backend {
    function Map (line 13) | auto Map(T* ptr) {
    function Map (line 18) | auto Map(T const* ptr) {
    function Col (line 24) | auto Col(Backend::View<T, S> view, std::integral auto col) {
    function Col (line 29) | auto Col(Backend::View<T const, S> view, std::integral auto col) {
    function Fill (line 35) | auto Fill(T* res, T weight, T value) {
    function Add (line 41) | auto Add(T* res, T weight, auto const*... args) {
    function Mul (line 46) | auto Mul(T* res, T weight, auto const*... args) {
    function Sub (line 51) | auto Sub(T* res, T weight, auto* first, auto const*... rest) {
    function Div (line 57) | auto Div(T* res, T weight, auto const* first, auto const*... rest) {
    function Min (line 63) | auto Min(T* res, T weight, auto const* first, auto const*... args) {
    function Max (line 71) | auto Max(T* res, T weight, auto* first, auto const*... args) {
    function Aq (line 79) | auto Aq(T* res, T weight, T const* a, T const* b) {
    function Pow (line 84) | auto Pow(T* res, T weight, T const* a, T const* b) {
    function Powabs (line 89) | auto Powabs(T* res, T weight, T const* a, T const* b) {
    function Cpy (line 95) | auto Cpy(T* res, T weight, T const* arg) {
    function Neg (line 100) | auto Neg(T* res, T weight, T const* arg) {
    function Inv (line 105) | auto Inv(T* res, T weight, T const* arg) {
    function Abs (line 110) | auto Abs(T* res, T weight, T const* arg) {
    function Ceil (line 115) | auto Ceil(T* res, T weight, T const* arg) {
    function Floor (line 120) | auto Floor(T* res, T weight, T const* arg) {
    function Square (line 125) | auto Square(T* res, T weight, T const* arg) {
    function Exp (line 130) | auto Exp(T* res, T weight, T const* arg) {
    function Log (line 135) | auto Log(T* res, T weight, T const* arg) {
    function Log1p (line 140) | auto Log1p(T* res, T weight, T const* arg) {
    function Logabs (line 145) | auto Logabs(T* res, T weight, T const* arg) {
    function Sin (line 150) | auto Sin(T* res, T weight, T const* arg) {
    function Cos (line 155) | auto Cos(T* res, T weight, T const* arg) {
    function Tan (line 160) | auto Tan(T* res, T weight, T const* arg) {
    function Asin (line 165) | auto Asin(T* res, T weight, T const* arg) {
    function Acos (line 170) | auto Acos(T* res, T weight, T const* arg) {
    function Atan (line 175) | auto Atan(T* res, T weight, T const* arg) {
    function Sinh (line 180) | auto Sinh(T* res, T weight, T const* arg) {
    function Cosh (line 185) | auto Cosh(T* res, T weight, T const* arg) {
    function Tanh (line 190) | auto Tanh(T* res, T weight, T const* arg) {
    function Sqrt (line 195) | auto Sqrt(T* res, T weight, T const* arg) {
    function Sqrtabs (line 200) | auto Sqrtabs(T* res, T weight, T const* arg) {
    function Cbrt (line 205) | auto Cbrt(T* res, T weight, T const* arg) {

FILE: include/operon/interpreter/backend/blaze/derivatives.hpp
  type Operon::Backend (line 10) | namespace Operon::Backend {
    type detail (line 11) | namespace detail {
      function IsNaN (line 13) | inline auto IsNaN(T value) { return std::isnan(value); }
      type FComp (line 16) | struct FComp {
    function Add (line 30) | auto Add(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Mul (line 35) | auto Mul(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sub (line 40) | auto Sub(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Div (line 46) | auto Div(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Aq (line 56) | auto Aq(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T co...
    function Pow (line 65) | auto Pow(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Powabs (line 76) | auto Powabs(std::vector<Operon::Node> const& nodes, Backend::View<T co...
    function Min (line 87) | auto Min(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Max (line 94) | auto Max(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Square (line 101) | auto Square(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Abs (line 106) | auto Abs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Ceil (line 111) | auto Ceil(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Floor (line 116) | auto Floor(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Exp (line 121) | auto Exp(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log (line 129) | auto Log(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log1p (line 134) | auto Log1p(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Logabs (line 139) | auto Logabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sin (line 144) | auto Sin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Cos (line 149) | auto Cos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Tan (line 154) | auto Tan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sinh (line 160) | auto Sinh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Cosh (line 165) | auto Cosh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Tanh (line 170) | auto Tanh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Asin (line 175) | auto Asin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Acos (line 180) | auto Acos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Atan (line 185) | auto Atan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrt (line 190) | auto Sqrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrtabs (line 195) | auto Sqrtabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cbrt (line 200) | auto Cbrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...

FILE: include/operon/interpreter/backend/blaze/functions.hpp
  type Operon::Backend (line 10) | namespace Operon::Backend {
    type detail (line 11) | namespace detail {
    function Map (line 17) | inline auto Map(T* res) -> detail::CVector<T> {
    function Map (line 22) | inline auto Map(T const* res) -> detail::CVector<std::remove_const_t<T...
    function Col (line 28) | auto Col(Backend::View<T, S> view, std::integral auto col) {
    function Col (line 33) | auto Col(Backend::View<T const, S> view, std::integral auto col) {
    function Fill (line 39) | auto Fill(T* res, T value) {
    function Fill (line 44) | auto Fill(T* res, int n, T value) {
    function Add (line 50) | auto Add(T* res, T weight, auto const*... args) {
    function Mul (line 55) | auto Mul(T* res, T weight, auto const*... args) {
    function Sub (line 60) | auto Sub(T* res, T weight, auto* first, auto const*... rest) {
    function Div (line 66) | auto Div(T* res, T weight, auto const* first, auto const*... rest) {
    function Min (line 72) | auto Min(T* res, T weight, auto const* first, auto const*... args) {
    function Max (line 80) | auto Max(T* res, T weight, auto* first, auto const*... args) {
    function Aq (line 89) | auto Aq(T* res, T weight, T const* a, T const* b) {
    function Pow (line 95) | auto Pow(T* res, T weight, T const* a, T const* b) {
    function Powabs (line 100) | auto Powabs(T* res, T weight, T const* a, T const* b) {
    function Cpy (line 106) | auto Cpy(T* res, T weight, T const* arg) {
    function Neg (line 111) | auto Neg(T* res, T weight, T const* arg) {
    function Inv (line 116) | auto Inv(T* res, T weight, T const* arg) {
    function Abs (line 121) | auto Abs(T* res, T weight, T const* arg) {
    function Ceil (line 126) | auto Ceil(T* res, T weight, T const* arg) {
    function Floor (line 131) | auto Floor(T* res, T weight, T const* arg) {
    function Square (line 136) | auto Square(T* res, T weight, T const* arg) {
    function Exp (line 141) | auto Exp(T* res, T weight, T const* arg) {
    function Log (line 146) | auto Log(T* res, T weight, T const* arg) {
    function Log1p (line 151) | auto Log1p(T* res, T weight, T const* arg) {
    function Logabs (line 156) | auto Logabs(T* res, T weight, T const* arg) {
    function Sin (line 161) | auto Sin(T* res, T weight, T const* arg) {
    function Cos (line 166) | auto Cos(T* res, T weight, T const* arg) {
    function Tan (line 171) | auto Tan(T* res, T weight, T const* arg) {
    function Asin (line 176) | auto Asin(T* res, T weight, T const* arg) {
    function Acos (line 181) | auto Acos(T* res, T weight, T const* arg) {
    function Atan (line 186) | auto Atan(T* res, T weight, T const* arg) {
    function Sinh (line 191) | auto Sinh(T* res, T weight, T const* arg) {
    function Cosh (line 196) | auto Cosh(T* res, T weight, T const* arg) {
    function Tanh (line 201) | auto Tanh(T* res, T weight, T const* arg) {
    function Sqrt (line 206) | auto Sqrt(T* res, T weight, T const* arg) {
    function Sqrtabs (line 211) | auto Sqrtabs(T* res, T weight, T const* arg) {
    function Cbrt (line 216) | auto Cbrt(T* res, T weight, T const* arg) {

FILE: include/operon/interpreter/backend/eigen/derivatives.hpp
  type Operon::Backend (line 10) | namespace Operon::Backend {
    type detail (line 11) | namespace detail {
      function IsNaN (line 13) | inline auto IsNaN(T value) { return std::isnan(value); }
      type FComp (line 16) | struct FComp {
    function Add (line 32) | auto Add(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Mul (line 37) | auto Mul(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sub (line 42) | auto Sub(Operon::Vector<Operon::Node> const& nodes, Backend::View<T co...
    function Div (line 48) | auto Div(Operon::Vector<Operon::Node> const& nodes, Backend::View<T co...
    function Aq (line 58) | auto Aq(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Pow (line 67) | auto Pow(Operon::Vector<Operon::Node> const& nodes, Backend::View<T co...
    function Powabs (line 78) | auto Powabs(Operon::Vector<Operon::Node> const& nodes, Backend::View<T...
    function Min (line 89) | auto Min(Operon::Vector<Operon::Node> const& nodes, Backend::View<T co...
    function Max (line 95) | auto Max(Operon::Vector<Operon::Node> const& nodes, Backend::View<T co...
    function Square (line 101) | auto Square(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::Vi...
    function Abs (line 106) | auto Abs(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Ceil (line 111) | auto Ceil(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Floor (line 116) | auto Floor(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::Vie...
    function Exp (line 121) | auto Exp(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Log (line 126) | auto Log(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Log1p (line 131) | auto Log1p(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::Vie...
    function Logabs (line 136) | auto Logabs(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::Vi...
    function Sin (line 141) | auto Sin(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Cos (line 146) | auto Cos(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Tan (line 151) | auto Tan(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sinh (line 156) | auto Sinh(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cosh (line 161) | auto Cosh(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Tanh (line 166) | auto Tanh(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Asin (line 171) | auto Asin(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Acos (line 176) | auto Acos(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Atan (line 181) | auto Atan(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Sqrt (line 186) | auto Sqrt(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Sqrtabs (line 191) | auto Sqrtabs(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::V...
    function Cbrt (line 196) | auto Cbrt(Operon::Vector<Operon::Node> const& /*nodes*/, Backend::View...

FILE: include/operon/interpreter/backend/eigen/functions.hpp
  type Operon::Backend (line 11) | namespace Operon::Backend {
    function Col (line 16) | auto Col(Backend::View<T, S> view, std::integral auto col) {
    function Col (line 21) | auto Col(Backend::View<T const, S> view, std::integral auto col) {
    function Fill (line 27) | auto Fill(T* res, T value) {
    function Fill (line 32) | auto Fill(T* res, int n, T value) {
    function Add (line 38) | auto Add(T* res, T weight, auto const*... args) {
    function Mul (line 43) | auto Mul(T* res, T weight, auto const*... args) {
    function Sub (line 48) | auto Sub(T* res, T weight, auto* first, auto const*... rest) {
    function Div (line 54) | auto Div(T* res, T weight, auto const* first, auto const*... rest) {
    function Min (line 60) | auto Min(T* res, T weight, auto const* first, auto const*... args) {
    function Max (line 66) | auto Max(T* res, T weight, auto* first, auto const*... args) {
    function Aq (line 73) | auto Aq(T* res, T weight, T const* a, T const* b) {
    function Pow (line 78) | auto Pow(T* res, T weight, T const* a, T const* b) {
    function Powabs (line 83) | auto Powabs(T* res, T weight, T const* a, T const* b) {
    function Cpy (line 89) | auto Cpy(T* res, T weight, T const* arg) {
    function Neg (line 94) | auto Neg(T* res, T weight, T const* arg) {
    function Inv (line 99) | auto Inv(T* res, T weight, T const* arg) {
    function Abs (line 104) | auto Abs(T* res, T weight, T const* arg) {
    function Ceil (line 109) | auto Ceil(T* res, T weight, T const* arg) {
    function Floor (line 114) | auto Floor(T* res, T weight, T const* arg) {
    function Square (line 119) | auto Square(T* res, T weight, T const* arg) {
    function Exp (line 124) | auto Exp(T* res, T weight, T const* arg) {
    function Log (line 129) | auto Log(T* res, T weight, T const* arg) {
    function Log1p (line 134) | auto Log1p(T* res, T weight, T const* arg) {
    function Logabs (line 139) | auto Logabs(T* res, T weight, T const* arg) {
    function Sin (line 144) | auto Sin(T* res, T weight, T const* arg) {
    function Cos (line 149) | auto Cos(T* res, T weight, T const* arg) {
    function Tan (line 154) | auto Tan(T* res, T weight, T const* arg) {
    function Asin (line 159) | auto Asin(T* res, T weight, T const* arg) {
    function Acos (line 164) | auto Acos(T* res, T weight, T const* arg) {
    function Atan (line 169) | auto Atan(T* res, T weight, T const* arg) {
    function Sinh (line 174) | auto Sinh(T* res, T weight, T const* arg) {
    function Cosh (line 179) | auto Cosh(T* res, T weight, T const* arg) {
    function Tanh (line 184) | auto Tanh(T* res, T weight, T const* arg) {
    function Sqrt (line 189) | auto Sqrt(T* res, T weight, T const* arg) {
    function Sqrtabs (line 194) | auto Sqrtabs(T* res, T weight, T const* arg) {
    function Cbrt (line 199) | auto Cbrt(T* res, T weight, T const* arg) {

FILE: include/operon/interpreter/backend/eve/derivatives.hpp
  type Operon::Backend (line 9) | namespace Operon::Backend {
    type detail (line 10) | namespace detail {
      function IsNaN (line 12) | inline auto IsNaN(T value) { return eve::all(eve::is_nan(value)); }
      type FComp (line 15) | struct FComp {
    function Add (line 29) | auto Add(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Mul (line 34) | auto Mul(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sub (line 48) | auto Sub(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Div (line 54) | auto Div(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Aq (line 74) | auto Aq(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T co...
    function Pow (line 100) | auto Pow(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Powabs (line 123) | auto Powabs(std::vector<Operon::Node> const& nodes, Backend::View<T co...
    function Min (line 146) | auto Min(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Max (line 155) | auto Max(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Square (line 164) | auto Square(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Abs (line 176) | auto Abs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Ceil (line 188) | auto Ceil(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Floor (line 200) | auto Floor(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Exp (line 212) | auto Exp(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log (line 217) | auto Log(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log1p (line 229) | auto Log1p(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Logabs (line 241) | auto Logabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sin (line 253) | auto Sin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Cos (line 265) | auto Cos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Tan (line 277) | auto Tan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sinh (line 289) | auto Sinh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Cosh (line 301) | auto Cosh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Tanh (line 313) | auto Tanh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Asin (line 325) | auto Asin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Acos (line 337) | auto Acos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Atan (line 349) | auto Atan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrt (line 361) | auto Sqrt(std::vector<Operon::Node> const&  /*nodes*/, Backend::View<T...
    function Sqrtabs (line 373) | auto Sqrtabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cbrt (line 386) | auto Cbrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...

FILE: include/operon/interpreter/backend/eve/functions.hpp
  type Operon::Backend (line 13) | namespace Operon::Backend {
    function Fill (line 16) | auto Fill(T* res, T value) {
    function Fill (line 21) | auto Fill(T* res, int n, T value) {
    function Add (line 28) | auto Add(T* res, T weight, auto const*... args) {
    function Mul (line 38) | auto Mul(T* res, T weight, auto const*... args) {
    function Sub (line 48) | auto Sub(T* res, T weight, auto const*... args) {
    function Div (line 58) | auto Div(T* res, T weight, auto const*... args) {
    function Min (line 68) | auto Min(T* res, T weight, auto const*... args) {
    function Max (line 74) | auto Max(T* res, T weight, auto const*... args) {
    function Aq (line 81) | auto Aq(T* res, T weight, T const* a, T const* b) {
    function Pow (line 89) | auto Pow(T* res, T weight, T const* a, T const* b) {
    function Powabs (line 97) | auto Powabs(T* res, T weight, T const* a, T const* b) {
    function Cpy (line 106) | auto Cpy(T* res, T w, T const* arg) {
    function Neg (line 113) | auto Neg(T* res, T weight, T const* arg) {
    function Inv (line 123) | auto Inv(T* res, T weight, T const* arg) {
    function Abs (line 133) | auto Abs(T* res, T weight, T const* arg) {
    function Ceil (line 143) | auto Ceil(T* res, T weight, T const* arg) {
    function Floor (line 153) | auto Floor(T* res, T weight, T const* arg) {
    function Square (line 163) | auto Square(T* res, T weight, T const* arg) {
    function Exp (line 173) | auto Exp(T* res, T weight, T const* arg) {
    function Log (line 183) | auto Log(T* res, T weight, T const* arg) {
    function Log1p (line 193) | auto Log1p(T* res, T weight, T const* arg) {
    function Logabs (line 203) | auto Logabs(T* res, T weight, T const* arg) {
    function Sin (line 213) | auto Sin(T* res, T weight, T const* arg) {
    function Cos (line 223) | auto Cos(T* res, T weight, T const* arg) {
    function Tan (line 233) | auto Tan(T* res, T weight, T const* arg) {
    function Asin (line 243) | auto Asin(T* res, T weight, T const* arg) {
    function Acos (line 253) | auto Acos(T* res, T weight, T const* arg) {
    function Atan (line 263) | auto Atan(T* res, T weight, T const* arg) {
    function Sinh (line 273) | auto Sinh(T* res, T weight, T const* arg) {
    function Cosh (line 283) | auto Cosh(T* res, T weight, T const* arg) {
    function Tanh (line 293) | auto Tanh(T* res, T weight, T const* arg) {
    function Sqrt (line 303) | auto Sqrt(T* res, T weight, T const* arg) {
    function Sqrtabs (line 313) | auto Sqrtabs(T* res, T weight, T const* arg) {
    function Cbrt (line 323) | auto Cbrt(T* res, T weight, T const* arg) {

FILE: include/operon/interpreter/backend/fast_approx/derivatives.hpp
  type Operon::Backend (line 9) | namespace Operon::Backend {
    type detail (line 10) | namespace detail {
      function IsNaN (line 12) | inline auto IsNaN(T value) { return std::isnan(value); }
      type FComp (line 15) | struct FComp {
      function Sgn (line 28) | inline auto Sgn(T x) {
    function Add (line 34) | auto Add(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Mul (line 39) | auto Mul(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sub (line 47) | auto Sub(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Div (line 53) | auto Div(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Aq (line 68) | auto Aq(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T co...
    function Pow (line 87) | auto Pow(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Powabs (line 106) | auto Powabs(std::vector<Operon::Node> const& nodes, Backend::View<T co...
    function Min (line 125) | auto Min(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Max (line 134) | auto Max(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Square (line 143) | auto Square(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Abs (line 150) | auto Abs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Ceil (line 157) | auto Ceil(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Floor (line 164) | auto Floor(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Exp (line 171) | auto Exp(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log (line 176) | auto Log(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log1p (line 183) | auto Log1p(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Logabs (line 190) | auto Logabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sin (line 197) | auto Sin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Cos (line 204) | auto Cos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Tan (line 211) | auto Tan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sinh (line 218) | auto Sinh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Cosh (line 225) | auto Cosh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Tanh (line 232) | auto Tanh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Asin (line 239) | auto Asin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Acos (line 246) | auto Acos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Atan (line 253) | auto Atan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrt (line 260) | auto Sqrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrtabs (line 267) | auto Sqrtabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cbrt (line 275) | auto Cbrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...

FILE: include/operon/interpreter/backend/fast_approx/functions.hpp
  type Operon::Backend (line 19) | namespace Operon::Backend {
    type detail::fast_approx (line 20) | namespace detail::fast_approx {
      function Inv (line 24) | inline auto constexpr Inv(Operon::Scalar x) -> Operon::Scalar {
      function Log (line 28) | inline auto constexpr Log(Operon::Scalar x) -> Operon::Scalar {
      function Log1p (line 32) | inline auto constexpr Log1p(Operon::Scalar x) -> Operon::Scalar {
      function Logabs (line 36) | inline auto constexpr Logabs(Operon::Scalar x) -> Operon::Scalar {
      function Exp (line 40) | inline auto constexpr Exp(Operon::Scalar x) -> Operon::Scalar {
      function Sin (line 44) | inline auto constexpr Sin(Operon::Scalar x) -> Operon::Scalar {
      function Cos (line 48) | inline auto constexpr Cos(Operon::Scalar x) -> Operon::Scalar {
      function Tan (line 52) | inline auto constexpr Tan(Operon::Scalar x) -> Operon::Scalar {
      function Sinh (line 56) | inline auto constexpr Sinh(Operon::Scalar x) -> Operon::Scalar {
      function Cosh (line 61) | inline auto constexpr Cosh(Operon::Scalar x) -> Operon::Scalar {
      function ISqrt (line 66) | inline auto constexpr ISqrt(Operon::Scalar x) -> Operon::Scalar {
      function Sqrt (line 70) | inline auto constexpr Sqrt(Operon::Scalar x) -> Operon::Scalar {
      function Sqrtabs (line 74) | inline auto constexpr Sqrtabs(Operon::Scalar x) -> Operon::Scalar {
      function Div (line 78) | inline auto constexpr Div(Operon::Scalar x, Operon::Scalar y) -> Ope...
      function Pow (line 82) | inline auto constexpr Pow(Operon::Scalar x, Operon::Scalar y) -> Ope...
      function Powabs (line 86) | inline auto constexpr Powabs(Operon::Scalar x, Operon::Scalar y) -> ...
      function Tanh (line 90) | inline auto constexpr Tanh(Operon::Scalar x) -> Operon::Scalar {
      function Aq (line 94) | inline auto constexpr Aq(Operon::Scalar x, Operon::Scalar y) -> Oper...
    function Fill (line 101) | auto Fill(T* res, T value) {
    function Fill (line 106) | auto Fill(T* res, int n, T value) {
    function Add (line 112) | auto Add(T* res, auto const*... args) {
    function Mul (line 119) | auto Mul(T* res, auto const*... args) {
    function Sub (line 126) | auto Sub(T* res, auto const* first, auto const*... rest) {
    function Div (line 137) | auto Div(T* res, auto const* first, auto const*... rest) {
    function Min (line 148) | auto Min(T* res, auto const*... args) {
    function Max (line 155) | auto Max(T* res, auto const*... args) {
    function Aq (line 163) | auto Aq(T* res, T const* a, T const* b) {
    function Pow (line 168) | auto Pow(T* res, T const* a, T const* b) {
    function Powabs (line 173) | auto Powabs(T* res, T const* a, T const* b) {
    function Cpy (line 179) | auto Cpy(T* res, T const* arg) {
    function Neg (line 184) | auto Neg(T* res, T const* arg) {
    function Inv (line 189) | auto Inv(T* res, T const* arg) {
    function Abs (line 194) | auto Abs(T* res, T const* arg) {
    function Ceil (line 199) | auto Ceil(T* res, T const* arg) {
    function Floor (line 204) | auto Floor(T* res, T const* arg) {
    function Exp (line 209) | auto Exp(T* res, T const* arg) {
    function Log (line 214) | auto Log(T* res, T const* arg) {
    function Log1p (line 219) | auto Log1p(T* res, T const* arg) {
    function Logabs (line 224) | auto Logabs(T* res, T const* arg) {
    function Sin (line 229) | auto Sin(T* res, T const* arg) {
    function Cos (line 234) | auto Cos(T* res, T const* arg) {
    function Tan (line 239) | auto Tan(T* res, T const* arg) {
    function Asin (line 244) | auto Asin(T* res, T const* arg) {
    function Acos (line 249) | auto Acos(T* res, T const* arg) {
    function Atan (line 254) | auto Atan(T* res, T const* arg) {
    function Sinh (line 259) | auto Sinh(T* res, T const* arg) {
    function Cosh (line 264) | auto Cosh(T* res, T const* arg) {
    function Tanh (line 269) | auto Tanh(T* res, T const* arg) {
    function Sqrt (line 274) | auto Sqrt(T* res, T const* arg) {
    function Sqrtabs (line 279) | auto Sqrtabs(T* res, T const* arg) {
    function Square (line 284) | auto Square(T* res, T const* arg) {
    function Cbrt (line 289) | auto Cbrt(T* res, T const* arg) {

FILE: include/operon/interpreter/backend/fast_approx/impl/aq.hpp
  type Operon::Backend::detail::fast_approx (line 8) | namespace Operon::Backend::detail::fast_approx {
    function AqImpl (line 10) | inline auto constexpr AqImpl(Operon::Scalar x1, Operon::Scalar x2) {

FILE: include/operon/interpreter/backend/fast_approx/impl/exp.hpp
  type Operon::Backend::detail::fast_approx (line 6) | namespace Operon::Backend::detail::fast_approx {
    function ExpV1 (line 7) | inline auto constexpr ExpV1(Operon::Scalar x) -> Operon::Scalar {
    function ExpV2 (line 19) | inline auto constexpr ExpV2(Operon::Scalar x) -> Operon::Scalar {
    function ExpV3 (line 34) | inline auto constexpr ExpV3(Operon::Scalar x) -> Operon::Scalar {
    function ExpImpl (line 53) | inline auto constexpr ExpImpl(Operon::Scalar x) -> Operon::Scalar {

FILE: include/operon/interpreter/backend/fast_approx/impl/inv.hpp
  type Operon::Backend::detail::fast_approx (line 6) | namespace Operon::Backend::detail::fast_approx {
    function InvImpl (line 8) | inline auto constexpr InvImpl(Operon::Scalar x) -> Operon::Scalar {
    function DivImpl (line 39) | inline auto constexpr DivImpl(Operon::Scalar x, Operon::Scalar y) -> O...

FILE: include/operon/interpreter/backend/fast_approx/impl/log.hpp
  type Operon::Backend::detail::fast_approx (line 6) | namespace Operon::Backend::detail::fast_approx {
    function LogImpl (line 8) | inline auto constexpr LogImpl(Operon::Scalar x) -> Operon::Scalar {
    function Log1pImpl (line 33) | inline auto constexpr Log1pImpl(Operon::Scalar x) -> Operon::Scalar  {
    function LogabsImpl (line 38) | inline auto constexpr LogabsImpl(Operon::Scalar x) -> Operon::Scalar  {

FILE: include/operon/interpreter/backend/fast_approx/impl/pow.hpp
  type Operon::Backend::detail::fast_approx (line 8) | namespace Operon::Backend::detail::fast_approx {
    function PowV1 (line 9) | inline auto constexpr PowV1(Operon::Scalar x, Operon::Scalar y) -> Ope...
    function PowV2 (line 26) | inline auto PowV2(Operon::Scalar x, Operon::Scalar y) {
    function PowImpl (line 45) | inline auto PowImpl(Operon::Scalar x, Operon::Scalar y) -> Operon::Sca...
    function PowabsImpl (line 52) | inline auto constexpr PowabsImpl(Operon::Scalar x, Operon::Scalar y) -...

FILE: include/operon/interpreter/backend/fast_approx/impl/sqrt.hpp
  type Operon::Backend::detail::fast_approx (line 6) | namespace Operon::Backend::detail::fast_approx {
    function ISqrtImpl (line 8) | inline auto constexpr ISqrtImpl(Operon::Scalar x) -> Operon::Scalar {
    function SqrtImpl (line 30) | inline auto constexpr SqrtImpl(Operon::Scalar x) -> Operon::Scalar {
    function SqrtabsImpl (line 48) | inline auto constexpr SqrtabsImpl(Operon::Scalar x) {

FILE: include/operon/interpreter/backend/fast_approx/impl/tanh.hpp
  type Operon::Backend::detail::fast_approx (line 7) | namespace Operon::Backend::detail::fast_approx {
    function TanhImpl (line 9) | inline auto constexpr TanhImpl(Operon::Scalar x) -> Operon::Scalar {

FILE: include/operon/interpreter/backend/fast_approx/impl/trig.hpp
  type Operon::Backend::detail::fast_approx (line 8) | namespace Operon::Backend::detail::fast_approx {
    function CosImpl (line 10) | inline auto constexpr CosImpl(Operon::Scalar x) -> Operon::Scalar {
    function SinImpl (line 36) | inline auto constexpr SinImpl(Operon::Scalar x) -> Operon::Scalar {
    function TanImpl (line 52) | inline auto constexpr TanImpl(Operon::Scalar x) -> Operon::Scalar {

FILE: include/operon/interpreter/backend/fastor/derivatives.hpp
  type Operon::Backend (line 10) | namespace Operon::Backend {
    type detail (line 11) | namespace detail {
      function IsNaN (line 13) | inline auto IsNaN(T value) { return std::isnan(value); }
      type FComp (line 19) | struct FComp {
      function Sgn (line 32) | inline auto Sgn(T x) {
    function Add (line 38) | auto Add(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Mul (line 43) | auto Mul(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sub (line 48) | auto Sub(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Div (line 54) | auto Div(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Aq (line 65) | auto Aq(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T co...
    function Pow (line 74) | auto Pow(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Powabs (line 85) | auto Powabs(std::vector<Operon::Node> const& nodes, Backend::View<T co...
    function Min (line 98) | auto Min(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Max (line 105) | auto Max(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Square (line 112) | auto Square(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Abs (line 117) | auto Abs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Ceil (line 123) | auto Ceil(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Floor (line 128) | auto Floor(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Exp (line 133) | auto Exp(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log (line 138) | auto Log(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log1p (line 143) | auto Log1p(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Logabs (line 148) | auto Logabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sin (line 154) | auto Sin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Cos (line 159) | auto Cos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Tan (line 164) | auto Tan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sinh (line 169) | auto Sinh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Cosh (line 174) | auto Cosh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Tanh (line 179) | auto Tanh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Asin (line 184) | auto Asin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Acos (line 189) | auto Acos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Atan (line 194) | auto Atan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrt (line 199) | auto Sqrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrtabs (line 204) | auto Sqrtabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cbrt (line 213) | auto Cbrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...

FILE: include/operon/interpreter/backend/fastor/functions.hpp
  type Operon::Backend (line 13) | namespace Operon::Backend {
    function Map (line 15) | auto Map(T* ptr) { return Fastor::TensorMap<T, S>(ptr); }
    function Map (line 18) | auto Map(T const* ptr) {
    function Col (line 23) | auto Col(Backend::View<T, S> view, std::integral auto col) {
    function Fill (line 29) | auto Fill(T* res, T value) {
    function Fill (line 34) | auto Fill(T* res, int n, T value) {
    function Add (line 40) | auto Add(T* res, T weight, auto const*... args) {
    function Mul (line 45) | auto Mul(T* res, T weight, auto const*... args) {
    function Sub (line 50) | auto Sub(T* res, T weight, auto const* first, auto const*... rest) {
    function Div (line 56) | auto Div(T* res, T weight, auto const* first, auto const*... rest) {
    function Min (line 62) | auto Min(T* res, T weight, auto const* first, auto const*... args) {
    function Max (line 68) | auto Max(T* res, T weight, auto const* first, auto const*... args) {
    function Aq (line 75) | auto Aq(T* res, T weight, T* a, T* b) {
    function Pow (line 81) | auto Pow(T* res, T weight, T* a, T* b) {
    function Powabs (line 86) | auto Powabs(T* res, T weight, T* a, T* b) {
    function Cpy (line 92) | auto Cpy(T* res, T weight, T* arg) {
    function Neg (line 97) | auto Neg(T* res, T weight, T* arg) {
    function Inv (line 102) | auto Inv(T* res, T weight, T* arg) {
    function Abs (line 107) | auto Abs(T* res, T weight, T* arg) {
    function Square (line 112) | auto Square(T* res, T weight, T* arg) {
    function Ceil (line 118) | auto Ceil(T* res, T weight, T* arg) {
    function Floor (line 123) | auto Floor(T* res, T weight, T* arg) {
    function Exp (line 128) | auto Exp(T* res, T weight, T* arg) {
    function Log (line 133) | auto Log(T* res, T weight, T* arg) {
    function Log1p (line 138) | auto Log1p(T* res, T weight, T* arg) {
    function Logabs (line 143) | auto Logabs(T* res, T weight, T* arg) {
    function Sin (line 148) | auto Sin(T* res, T weight, T* arg) {
    function Cos (line 153) | auto Cos(T* res, T weight, T* arg) {
    function Tan (line 158) | auto Tan(T* res, T weight, T* arg) {
    function Asin (line 163) | auto Asin(T* res, T weight, T* arg) {
    function Acos (line 168) | auto Acos(T* res, T weight, T* arg) {
    function Atan (line 173) | auto Atan(T* res, T weight, T* arg) {
    function Sinh (line 178) | auto Sinh(T* res, T weight, T* arg) {
    function Cosh (line 183) | auto Cosh(T* res, T weight, T* arg) {
    function Tanh (line 188) | auto Tanh(T* res, T weight, T* arg) {
    function Sqrt (line 193) | auto Sqrt(T* res, T weight, T* arg) {
    function Sqrtabs (line 198) | auto Sqrtabs(T* res, T weight, T* arg) {
    function Cbrt (line 203) | auto Cbrt(T* res, T weight, T* arg) {

FILE: include/operon/interpreter/backend/plain/derivatives.hpp
  type Operon::Backend (line 10) | namespace Operon::Backend {
    type detail (line 11) | namespace detail {
      function IsNaN (line 13) | inline auto IsNaN(T value) { return std::isnan(value); }
      type FComp (line 16) | struct FComp {
      function Sgn (line 29) | inline auto Sgn(T x) {
    function Add (line 35) | auto Add(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Mul (line 40) | auto Mul(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sub (line 48) | auto Sub(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Div (line 54) | auto Div(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Aq (line 69) | auto Aq(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T co...
    function Pow (line 88) | auto Pow(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Powabs (line 107) | auto Powabs(std::vector<Operon::Node> const& nodes, Backend::View<T co...
    function Min (line 126) | auto Min(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Max (line 135) | auto Max(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Square (line 144) | auto Square(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Abs (line 151) | auto Abs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Ceil (line 158) | auto Ceil(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Floor (line 165) | auto Floor(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Exp (line 172) | auto Exp(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log (line 177) | auto Log(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log1p (line 184) | auto Log1p(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Logabs (line 191) | auto Logabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sin (line 198) | auto Sin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Cos (line 205) | auto Cos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Tan (line 212) | auto Tan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sinh (line 219) | auto Sinh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Cosh (line 226) | auto Cosh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Tanh (line 233) | auto Tanh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Asin (line 240) | auto Asin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Acos (line 247) | auto Acos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Atan (line 254) | auto Atan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrt (line 261) | auto Sqrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrtabs (line 268) | auto Sqrtabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cbrt (line 276) | auto Cbrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...

FILE: include/operon/interpreter/backend/plain/functions.hpp
  type Operon::Backend (line 10) | namespace Operon::Backend {
    function Fill (line 13) | auto Fill(T* res, T value) {
    function Fill (line 18) | auto Fill(T* res, int n, T value) {
    function Add (line 24) | auto Add(T* res, T weight, auto const*... args) {
    function Mul (line 31) | auto Mul(T* res, T weight, auto const*... args) {
    function Sub (line 38) | auto Sub(T* res, T weight, auto const* first, auto const*... rest) {
    function Div (line 49) | auto Div(T* res, T weight, auto const* first, auto const*... rest) {
    function Min (line 60) | auto Min(T* res, T weight, auto const*... args) {
    function Max (line 67) | auto Max(T* res, T weight, auto const*... args) {
    function Aq (line 75) | auto Aq(T* res, T weight, T const* a, T const* b) {
    function Pow (line 80) | auto Pow(T* res, T weight, T const* a, T const* b) {
    function Powabs (line 85) | auto Powabs(T* res, T weight, T const* a, T const* b) {
    function Cpy (line 91) | auto Cpy(T* res, T w, T const* arg) {
    function Neg (line 97) | auto Neg(T* res, T weight, T const* arg) {
    function Inv (line 102) | auto Inv(T* res, T weight, T const* arg) {
    function Abs (line 107) | auto Abs(T* res, T weight, T const* arg) {
    function Square (line 112) | auto Square(T* res, T weight, T const* arg) {
    function Ceil (line 117) | auto Ceil(T* res, T weight, T const* arg) {
    function Floor (line 122) | auto Floor(T* res, T weight, T const* arg) {
    function Exp (line 127) | auto Exp(T* res, T weight, T const* arg) {
    function Log (line 132) | auto Log(T* res, T weight, T const* arg) {
    function Log1p (line 137) | auto Log1p(T* res, T weight, T const* arg) {
    function Logabs (line 142) | auto Logabs(T* res, T weight, T const* arg) {
    function Sin (line 147) | auto Sin(T* res, T weight, T const* arg) {
    function Cos (line 152) | auto Cos(T* res, T weight, T const* arg) {
    function Tan (line 157) | auto Tan(T* res, T weight, T const* arg) {
    function Asin (line 162) | auto Asin(T* res, T weight, T const* arg) {
    function Acos (line 167) | auto Acos(T* res, T weight, T const* arg) {
    function Atan (line 172) | auto Atan(T* res, T weight, T const* arg) {
    function Sinh (line 177) | auto Sinh(T* res, T weight, T const* arg) {
    function Cosh (line 182) | auto Cosh(T* res, T weight, T const* arg) {
    function Tanh (line 187) | auto Tanh(T* res, T weight, T const* arg) {
    function Sqrt (line 192) | auto Sqrt(T* res, T weight, T const* arg) {
    function Sqrtabs (line 197) | auto Sqrtabs(T* res, T weight, T const* arg) {
    function Cbrt (line 202) | auto Cbrt(T* res, T weight, T const* arg) {

FILE: include/operon/interpreter/backend/vdt/derivatives.hpp
  type Operon::Backend (line 6) | namespace Operon::Backend {
    type detail (line 7) | namespace detail {
      function IsNaN (line 9) | inline auto IsNaN(T value) { return std::isnan(value); }
      type FComp (line 12) | struct FComp {
      function Sgn (line 25) | inline auto Sgn(T x) {
    function Add (line 31) | auto Add(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Mul (line 36) | auto Mul(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sub (line 44) | auto Sub(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Div (line 50) | auto Div(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Aq (line 65) | auto Aq(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T co...
    function Pow (line 84) | auto Pow(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Powabs (line 103) | auto Powabs(std::vector<Operon::Node> const& nodes, Backend::View<T co...
    function Min (line 122) | auto Min(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Max (line 131) | auto Max(std::vector<Operon::Node> const& nodes, Backend::View<T const...
    function Square (line 140) | auto Square(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Abs (line 147) | auto Abs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Ceil (line 154) | auto Ceil(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Floor (line 161) | auto Floor(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Exp (line 168) | auto Exp(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log (line 173) | auto Log(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Log1p (line 180) | auto Log1p(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T...
    function Logabs (line 187) | auto Logabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View<...
    function Sin (line 194) | auto Sin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Cos (line 201) | auto Cos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Tan (line 208) | auto Tan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T c...
    function Sinh (line 215) | auto Sinh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Cosh (line 222) | auto Cosh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Tanh (line 229) | auto Tanh(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Asin (line 236) | auto Asin(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Acos (line 243) | auto Acos(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Atan (line 250) | auto Atan(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrt (line 257) | auto Sqrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...
    function Sqrtabs (line 264) | auto Sqrtabs(std::vector<Operon::Node> const& /*nodes*/, Backend::View...
    function Cbrt (line 272) | auto Cbrt(std::vector<Operon::Node> const& /*nodes*/, Backend::View<T ...

FILE: include/operon/interpreter/backend/vdt/functions.hpp
  type Operon::Backend (line 12) | namespace Operon::Backend {
    type detail::vdt (line 14) | namespace detail::vdt {
      function Exp (line 16) | inline auto Exp(Operon::Scalar x) -> Operon::Scalar {
      function Log (line 30) | inline auto Log(Operon::Scalar x) -> Operon::Scalar {
      function Logabs (line 45) | inline auto Logabs(Operon::Scalar x) -> Operon::Scalar {
      function Log1p (line 49) | inline auto Log1p(Operon::Scalar x) -> Operon::Scalar {
      function Inv (line 53) | inline auto Inv(Operon::Scalar x) -> Operon::Scalar {
      function ISqrt (line 59) | inline auto ISqrt(Operon::Scalar x) -> Operon::Scalar {
      function Sqrt (line 73) | inline auto Sqrt(Operon::Scalar x) -> Operon::Scalar {
      function Sqrtabs (line 83) | inline auto Sqrtabs(Operon::Scalar x) -> Operon::Scalar {
      function Cbrt (line 87) | inline auto Cbrt(Operon::Scalar x) -> Operon::Scalar {
      function Floor (line 91) | inline auto Floor(Operon::Scalar x) -> Operon::Scalar {
      function Div (line 96) | inline auto Div(Operon::Scalar x, Operon::Scalar y) -> Operon::Scalar {
      function Aq (line 101) | inline auto Aq(Operon::Scalar x, Operon::Scalar y) -> Operon::Scalar {
      function Pow (line 106) | inline auto Pow(Operon::Scalar x, Operon::Scalar y) -> Operon::Scalar {
      function Acos (line 122) | inline auto Acos(Operon::Scalar x) -> Operon::Scalar {
      function Asin (line 128) | inline auto Asin(Operon::Scalar x) -> Operon::Scalar {
      function Atan (line 134) | inline auto Atan(Operon::Scalar x) -> Operon::Scalar {
      function Cos (line 140) | inline auto Cos(Operon::Scalar x) -> Operon::Scalar {
      function Sin (line 148) | inline auto Sin(Operon::Scalar x) -> Operon::Scalar {
      function Tan (line 156) | inline auto Tan(Operon::Scalar x) -> Operon::Scalar {
      function Sinh (line 162) | inline auto Sinh(Operon::Scalar x) -> Operon::Scalar {
      function Cosh (line 167) | inline auto Cosh(Operon::Scalar x) -> Operon::Scalar {
      function Tanh (line 172) | inline auto Tanh(Operon::Scalar x) -> Operon::Scalar {
    function Fill (line 185) | auto Fill(T* res, T value) {
    function Fill (line 190) | auto Fill(T* res, int n, T value) {
    function Add (line 196) | auto Add(T* res, T weight, auto const*... args) {
    function Mul (line 203) | auto Mul(T* res, T weight, auto const*... args) {
    function Sub (line 210) | auto Sub(T* res, T weight, auto const* first, auto const*... rest) {
    function Div (line 221) | auto Div(T* res, T weight, auto const* first, auto const*... rest) {
    function Min (line 232) | auto Min(T* res, T weight, auto const*... args) {
    function Max (line 239) | auto Max(T* res, T weight, auto const*... args) {
    function Aq (line 247) | auto Aq(T* res, T weight, T const* a, T const* b) {
    function Pow (line 252) | auto Pow(T* res, T weight, T const* a, T const* b) {
    function Powabs (line 257) | auto Powabs(T* res, T weight, T const* a, T const* b) {
    function Cpy (line 263) | auto Cpy(T* res, T weight, T const* arg) {
    function Neg (line 268) | auto Neg(T* res, T weight, T const* arg) {
    function Inv (line 273) | auto Inv(T* res, T weight, T const* arg) {
    function Abs (line 278) | auto Abs(T* res, T weight, T const* arg) {
    function Square (line 283) | auto Square(T* res, T weight, T const* arg) {
    function Ceil (line 288) | auto Ceil(T* res, T weight, T const* arg) {
    function Floor (line 293) | auto Floor(T* res, T weight, T const* arg) {
    function Exp (line 298) | auto Exp(T* res, T weight, T const* arg) {
    function Log (line 303) | auto Log(T* res, T weight, T const* arg) {
    function Log1p (line 308) | auto Log1p(T* res, T weight, T const* arg) {
    function Logabs (line 313) | auto Logabs(T* res, T weight, T const* arg) {
    function Sin (line 318) | auto Sin(T* res, T weight, T const* arg) {
    function Cos (line 323) | auto Cos(T* res, T weight, T const* arg) {
    function Tan (line 328) | auto Tan(T* res, T weight, T const* arg) {
    function Asin (line 333) | auto Asin(T* res, T weight, T const* arg) {
    function Acos (line 338) | auto Acos(T* res, T weight, T const* arg) {
    function Atan (line 343) | auto Atan(T* res, T weight, T const* arg) {
    function Sinh (line 348) | auto Sinh(T* res, T weight, T const* arg) {
    function Cosh (line 353) | auto Cosh(T* res, T weight, T const* arg) {
    function Tanh (line 358) | auto Tanh(T* res, T weight, T const* arg) {
    function Sqrt (line 363) | auto Sqrt(T* res, T weight, T const* arg) {
    function Sqrtabs (line 368) | auto Sqrtabs(T* res, T weight, T const* arg) {
    function Cbrt (line 373) | auto Cbrt(T* res, T weight, T const* arg) {

FILE: include/operon/interpreter/derivatives.hpp
  type Operon (line 10) | namespace Operon {
    type Diff<T, Operon::NodeType::Add, S> (line 13) | struct Diff<T, Operon::NodeType::Add, S> {
    type Diff<T, Operon::NodeType::Sub, S> (line 20) | struct Diff<T, Operon::NodeType::Sub, S> {
    type Diff<T, Operon::NodeType::Mul, S> (line 27) | struct Diff<T, Operon::NodeType::Mul, S> {
    type Diff<T, Operon::NodeType::Div, S> (line 34) | struct Diff<T, Operon::NodeType::Div, S> {
    type Diff<T, Operon::NodeType::Fmin, S> (line 41) | struct Diff<T, Operon::NodeType::Fmin, S> {
    type Diff<T, Operon::NodeType::Fmax, S> (line 48) | struct Diff<T, Operon::NodeType::Fmax, S> {
    type Diff<T, Operon::NodeType::Aq, S> (line 56) | struct Diff<T, Operon::NodeType::Aq, S> {
    type Diff<T, Operon::NodeType::Pow, S> (line 63) | struct Diff<T, Operon::NodeType::Pow, S> {
    type Diff<T, Operon::NodeType::Powabs, S> (line 70) | struct Diff<T, Operon::NodeType::Powabs, S> {
    type Diff<T, Operon::NodeType::Abs, S> (line 78) | struct Diff<T, Operon::NodeType::Abs, S> {
    type Diff<T, Operon::NodeType::Acos, S> (line 85) | struct Diff<T, Operon::NodeType::Acos, S> {
    type Diff<T, Operon::NodeType::Asin, S> (line 92) | struct Diff<T, Operon::NodeType::Asin, S> {
    type Diff<T, Operon::NodeType::Atan, S> (line 99) | struct Diff<T, Operon::NodeType::Atan, S> {
    type Diff<T, Operon::NodeType::Cbrt, S> (line 106) | struct Diff<T, Operon::NodeType::Cbrt, S> {
    type Diff<T, Operon::NodeType::Ceil, S> (line 113) | struct Diff<T, Operon::NodeType::Ceil, S> {
    type Diff<T, Operon::NodeType::Cos, S> (line 120) | struct Diff<T, Operon::NodeType::Cos, S> {
    type Diff<T, Operon::NodeType::Cosh, S> (line 127) | struct Diff<T, Operon::NodeType::Cosh, S> {
    type Diff<T, Operon::NodeType::Exp, S> (line 134) | struct Diff<T, Operon::NodeType::Exp, S> {
    type Diff<T, Operon::NodeType::Floor, S> (line 141) | struct Diff<T, Operon::NodeType::Floor, S> {
    type Diff<T, Operon::NodeType::Log, S> (line 148) | struct Diff<T, Operon::NodeType::Log, S> {
    type Diff<T, Operon::NodeType::Logabs, S> (line 155) | struct Diff<T, Operon::NodeType::Logabs, S> {
    type Diff<T, Operon::NodeType::Log1p, S> (line 162) | struct Diff<T, Operon::NodeType::Log1p, S> {
    type Diff<T, Operon::NodeType::Sin, S> (line 169) | struct Diff<T, Operon::NodeType::Sin, S> {
    type Diff<T, Operon::NodeType::Sinh, S> (line 176) | struct Diff<T, Operon::NodeType::Sinh, S> {
    type Diff<T, Operon::NodeType::Sqrt, S> (line 183) | struct Diff<T, Operon::NodeType::Sqrt, S> {
    type Diff<T, Operon::NodeType::Sqrtabs, S> (line 190) | struct Diff<T, Operon::NodeType::Sqrtabs, S> {
    type Diff<T, Operon::NodeType::Square, S> (line 197) | struct Diff<T, Operon::NodeType::Square, S> {
    type Diff<T, Operon::NodeType::Tan, S> (line 204) | struct Diff<T, Operon::NodeType::Tan, S> {
    type Diff<T, Operon::NodeType::Tanh, S> (line 211) | struct Diff<T, Operon::NodeType::Tanh, S> {

FILE: include/operon/interpreter/dual.hpp
  type Operon (line 15) | namespace Operon {

FILE: include/operon/interpreter/functions.hpp
  type Operon (line 33) | namespace Operon {
    function Ptr (line 35) | auto Ptr(Backend::View<T, S> view, std::integral auto i) {
    type Func<T, Operon::NodeType::Add, C, S> (line 41) | struct Func<T, Operon::NodeType::Add, C, S> {
    type Func<T, Operon::NodeType::Mul, C, S> (line 53) | struct Func<T, Operon::NodeType::Mul, C, S> {
    type Func<T, Operon::NodeType::Sub, C, S> (line 65) | struct Func<T, Operon::NodeType::Sub, C, S> {
    type Func<T, Operon::NodeType::Div, C, S> (line 85) | struct Func<T, Operon::NodeType::Div, C, S> {
    type Func<T, Operon::NodeType::Fmin, C, S> (line 105) | struct Func<T, Operon::NodeType::Fmin, C, S> {
    type Func<T, Operon::NodeType::Fmax, C, S> (line 125) | struct Func<T, Operon::NodeType::Fmax, C, S> {
    type Func<T, Operon::NodeType::Aq, C, S> (line 146) | struct Func<T, Operon::NodeType::Aq, C, S> {
    type Func<T, Operon::NodeType::Pow, C, S> (line 154) | struct Func<T, Operon::NodeType::Pow, C, S> {
    type Func<T, Operon::NodeType::Powabs, C, S> (line 162) | struct Func<T, Operon::NodeType::Powabs, C, S> {
    type Func<T, Operon::NodeType::Abs, C, S> (line 171) | struct Func<T, Operon::NodeType::Abs, C, S> {
    type Func<T, Operon::NodeType::Square, C, S> (line 180) | struct Func<T, Operon::NodeType::Square, C, S> {
    type Func<T, Operon::NodeType::Exp, C, S> (line 188) | struct Func<T, Operon::NodeType::Exp, C, S> {
    type Func<T, Operon::NodeType::Log, C, S> (line 196) | struct Func<T, Operon::NodeType::Log, C, S> {
    type Func<T, Operon::NodeType::Logabs, C, S> (line 204) | struct Func<T, Operon::NodeType::Logabs, C, S> {
    type Func<T, Operon::NodeType::Log1p, C, S> (line 212) | struct Func<T, Operon::NodeType::Log1p, C, S> {
    type Func<T, Operon::NodeType::Sqrt, C, S> (line 220) | struct Func<T, Operon::NodeType::Sqrt, C, S> {
    type Func<T, Operon::NodeType::Sqrtabs, C, S> (line 228) | struct Func<T, Operon::NodeType::Sqrtabs, C, S> {
    type Func<T, Operon::NodeType::Cbrt, C, S> (line 236) | struct Func<T, Operon::NodeType::Cbrt, C, S> {
    type Func<T, Operon::NodeType::Ceil, C, S> (line 244) | struct Func<T, Operon::NodeType::Ceil, C, S> {
    type Func<T, Operon::NodeType::Floor, C, S> (line 252) | struct Func<T, Operon::NodeType::Floor, C, S> {
    type Func<T, Operon::NodeType::Sin, C, S> (line 260) | struct Func<T, Operon::NodeType::Sin, C, S> {
    type Func<T, Operon::NodeType::Cos, C, S> (line 268) | struct Func<T, Operon::NodeType::Cos, C, S> {
    type Func<T, Operon::NodeType::Tan, C, S> (line 276) | struct Func<T, Operon::NodeType::Tan, C, S> {
    type Func<T, Operon::NodeType::Asin, C, S> (line 284) | struct Func<T, Operon::NodeType::Asin, C, S> {
    type Func<T, Operon::NodeType::Acos, C, S> (line 292) | struct Func<T, Operon::NodeType::Acos, C, S> {
    type Func<T, Operon::NodeType::Atan, C, S> (line 300) | struct Func<T, Operon::NodeType::Atan, C, S> {
    type Func<T, Operon::NodeType::Sinh, C, S> (line 308) | struct Func<T, Operon::NodeType::Sinh, C, S> {
    type Func<T, Operon::NodeType::Cosh, C, S> (line 316) | struct Func<T, Operon::NodeType::Cosh, C, S> {
    type Func<T, Operon::NodeType::Tanh, C, S> (line 324) | struct Func<T, Operon::NodeType::Tanh, C, S> {

FILE: include/operon/interpreter/interpreter.hpp
  type Operon (line 21) | namespace Operon {
    type LikelihoodType (line 23) | enum class LikelihoodType : uint8_t { Gaussian, Poisson }
    type InterpreterBase (line 26) | struct InterpreterBase {
      method InterpreterBase (line 27) | InterpreterBase() = default;
      method InterpreterBase (line 28) | InterpreterBase(const InterpreterBase&) = default;
      method InterpreterBase (line 29) | InterpreterBase(InterpreterBase&&) = default;
    type Interpreter (line 53) | struct Interpreter : public InterpreterBase<T> {
      method Interpreter (line 57) | Interpreter(gsl::not_null<DTable const*> dtable, gsl::not_null<Opero...
      method Primal (line 62) | auto Primal() const { return primal_; }
      method Trace (line 63) | auto Trace() const { return trace_; }
      method Evaluate (line 65) | auto Evaluate(Operon::Span<T const> coeff, Operon::Range range, Oper...
      method Evaluate (line 83) | auto Evaluate(Operon::Span<T const> coeff, Operon::Range range) cons...
      method JacRev (line 90) | auto JacRev(Operon::Span<T const> coeff, Operon::Range range, Operon...
      method JacRev (line 108) | auto JacRev(Operon::Span<T const> coeff, Operon::Range range) const ...
      method JacFwd (line 115) | auto JacFwd(Operon::Span<T const> coeff, Operon::Range range, Operon...
      method JacFwd (line 132) | auto JacFwd(Operon::Span<T const> coeff, Operon::Range range) const ...
      method GetTree (line 139) | [[nodiscard]] auto GetTree() const -> Operon::Tree const* { return t...
      method GetDataset (line 140) | [[nodiscard]] auto GetDataset() const -> Operon::Dataset const* { re...
      method GetDispatchTable (line 142) | auto GetDispatchTable() const { return dtable_.get(); }
      method Evaluate (line 144) | static auto Evaluate(Operon::Tree const& tree, Operon::Dataset const...
      method Evaluate (line 150) | static auto Evaluate(Operon::Tree const& tree, Operon::Dataset const...
      method ForwardPass (line 172) | auto ForwardPass(Operon::Range range, int row, bool trace = false) c...
      method ForwardTrace (line 209) | auto ForwardTrace(Operon::Range range, int row, Eigen::Ref<Eigen::Ar...
      method ReverseTrace (line 244) | auto ReverseTrace(Operon::Range range, int row, Eigen::Ref<Eigen::Ar...
      method InitContext (line 272) | auto InitContext(Operon::Span<T const> coeff, Operon::Range range) c...

FILE: include/operon/mdspan/mdspan.hpp
  type restrict_accessor (line 56) | struct restrict_accessor {
    method restrict_accessor (line 62) | constexpr restrict_accessor() noexcept = default;
    class OtherElementType (line 65) | class OtherElementType
    method restrict_accessor (line 68) | explicit restrict_accessor(restrict_accessor<OtherElementType>/*noname...
    method access (line 69) | constexpr auto access(data_handle_type p, size_t i) const noexcept -> ...
    method offset (line 72) | constexpr auto
  function is_nonzero_power_of_two (line 116) | constexpr auto
  function valid_byte_alignment (line 129) | constexpr auto
  type aligned_pointer (line 140) | struct aligned_pointer {
  function bless (line 163) | auto
  type aligned_accessor (line 170) | struct aligned_accessor {
    method aligned_accessor (line 176) | constexpr aligned_accessor() noexcept = default;
    class OtherElementType (line 179) | class OtherElementType
    method aligned_accessor (line 183) | constexpr explicit aligned_accessor(aligned_accessor<OtherElementType,...
    method access (line 185) | constexpr auto access(data_handle_type p, size_t i) const noexcept -> ...
    method offset (line 191) | constexpr typename offset_policy::data_handle_type

FILE: include/operon/operators/creator.hpp
  type Operon (line 14) | namespace Operon {
    class Tree (line 16) | class Tree
    class PrimitiveSet (line 17) | class PrimitiveSet
    type OPERON_EXPORT (line 20) | struct OPERON_EXPORT
    function GetPrimitiveSet (line 27) | [[nodiscard]] auto GetPrimitiveSet() const -> PrimitiveSet const* { re...
    function GetVariables (line 30) | [[nodiscard]] auto GetVariables() const -> Operon::Span<Operon::Hash c...
    function SetVariables (line 31) | auto SetVariables(Operon::Span<Operon::Hash const> variables) { variab...
    function BalancedTreeCreator (line 51) | class OPERON_EXPORT BalancedTreeCreator final : public CreatorBase {
    function GrowTreeCreator (line 68) | class OPERON_EXPORT GrowTreeCreator final : public CreatorBase {
    function ProbabilisticTreeCreator (line 77) | class OPERON_EXPORT ProbabilisticTreeCreator final : public CreatorBase {

FILE: include/operon/operators/crossover.hpp
  type Operon (line 20) | namespace Operon {
    type CrossoverBase (line 22) | struct CrossoverBase : public OperatorBase<Tree, const Tree&, const Tr...
    function SubtreeCrossover (line 29) | class OPERON_EXPORT SubtreeCrossover : public CrossoverBase {

FILE: include/operon/operators/evaluator.hpp
  type Operon (line 22) | namespace Operon {
    type ErrorType (line 24) | enum class ErrorType : int { SSE, MSE, NMSE, RMSE, MAE, R2, C2 }
    function ErrorMetric (line 26) | struct OPERON_EXPORT ErrorMetric {
    function ErrorMetric (line 41) | struct OPERON_EXPORT SSE : public ErrorMetric {
    function ErrorMetric (line 45) | struct OPERON_EXPORT MSE : public ErrorMetric {
    function ErrorMetric (line 49) | struct OPERON_EXPORT NMSE : public ErrorMetric {
    function ErrorMetric (line 53) | struct OPERON_EXPORT RMSE : public ErrorMetric {
    function ErrorMetric (line 57) | struct OPERON_EXPORT MAE : public ErrorMetric {
    function ErrorMetric (line 61) | struct OPERON_EXPORT R2 : public ErrorMetric {
    function ErrorMetric (line 65) | struct OPERON_EXPORT C2 : public ErrorMetric {
    type EvaluatorBase (line 75) | struct EvaluatorBase : public E1, E2
      method EvaluatorBase (line 92) | explicit EvaluatorBase(gsl::not_null<Problem const*> problem)
      method Evaluate (line 98) | static auto Evaluate(Derived const* self, Operon::RandomGenerator& r...
      method Evaluate (line 104) | static auto Evaluate(Derived const* self, Operon::RandomGenerator& r...
      method Prepare (line 109) | virtual void Prepare(Operon::Span<Individual const> /*pop*/) const
      method ObjectiveCount (line 113) | virtual auto ObjectiveCount() const -> std::size_t { return 1UL; }
      method TotalEvaluations (line 115) | auto TotalEvaluations() const -> size_t { return ResidualEvaluations...
      method SetBudget (line 117) | void SetBudget(size_t value) { budget_ = value; }
      method Budget (line 118) | auto Budget() const -> size_t { return budget_; }
      method BudgetExhausted (line 121) | virtual auto BudgetExhausted() const -> bool { return TotalEvaluatio...
      method Stats (line 123) | virtual auto Stats() const -> std::tuple<std::size_t, std::size_t, s...
      method Population (line 132) | auto Population() const -> Operon::Span<Individual const> { return p...
      method SetPopulation (line 133) | auto SetPopulation(Operon::Span<Operon::Individual const> pop) const...
      method GetProblem (line 134) | auto GetProblem() const -> Problem const* { return problem_; }
      method SetProblem (line 135) | auto SetProblem(gsl::not_null<Problem const*> problem) { problem_ = ...
      method Reset (line 137) | void Reset() const
    function UserDefinedEvaluator (line 151) | class OPERON_EXPORT UserDefinedEvaluator : public EvaluatorBase {
    function EvaluatorBase (line 183) | class OPERON_EXPORT Evaluator : public EvaluatorBase {
      method EvaluatorBase (line 92) | explicit EvaluatorBase(gsl::not_null<Problem const*> problem)
      method Evaluate (line 98) | static auto Evaluate(Derived const* self, Operon::RandomGenerator& r...
      method Evaluate (line 104) | static auto Evaluate(Derived const* self, Operon::RandomGenerator& r...
      method Prepare (line 109) | virtual void Prepare(Operon::Span<Individual const> /*pop*/) const
      method ObjectiveCount (line 113) | virtual auto ObjectiveCount() const -> std::size_t { return 1UL; }
      method TotalEvaluations (line 115) | auto TotalEvaluations() const -> size_t { return ResidualEvaluations...
      method SetBudget (line 117) | void SetBudget(size_t value) { budget_ = value; }
      method Budget (line 118) | auto Budget() const -> size_t { return budget_; }
      method BudgetExhausted (line 121) | virtual auto BudgetExhausted() const -> bool { return TotalEvaluatio...
      method Stats (line 123) | virtual auto Stats() const -> std::tuple<std::size_t, std::size_t, s...
      method Population (line 132) | auto Population() const -> Operon::Span<Individual const> { return p...
      method SetPopulation (line 133) | auto SetPopulation(Operon::Span<Operon::Individual const> pop) const...
      method GetProblem (line 134) | auto GetProblem() const -> Problem const* { return problem_; }
      method SetProblem (line 135) | auto SetProblem(gsl::not_null<Problem const*> problem) { problem_ = ...
      method Reset (line 137) | void Reset() const
    function MultiEvaluator (line 210) | class OPERON_EXPORT MultiEvaluator : public EvaluatorBase {
    function Prepare (line 222) | auto Prepare(Operon::Span<Operon::Individual const> pop) const -> void...
    function ObjectiveCount (line 229) | auto ObjectiveCount() const -> std::size_t override
    function Stats (line 254) | auto Stats() const -> std::tuple<std::size_t, std::size_t, std::size_t...
    function BudgetExhausted (line 274) | auto BudgetExhausted() const -> bool final {
    function Evaluators (line 279) | auto Evaluators() const { return evaluators_; }
  function AggregateEvaluator (line 285) | class OPERON_EXPORT AggregateEvaluator final : public EvaluatorBase {
  function UserDefinedEvaluator (line 316) | class OPERON_EXPORT LengthEvaluator : public UserDefinedEvaluator {
  function UserDefinedEvaluator (line 326) | class OPERON_EXPORT ShapeEvaluator : public UserDefinedEvaluator {
  function DiversityEvaluator (line 336) | class OPERON_EXPORT DiversityEvaluator : public EvaluatorBase {
  class OPERON_EXPORT (line 360) | class OPERON_EXPORT
  function Sigma (line 369) | auto Sigma() const { return std::span<Operon::Scalar const>{sigma_}; }
  function SetSigma (line 370) | auto SetSigma(std::vector<Operon::Scalar> sigma) const -> void { sigma_ ...
  class OPERON_EXPORT (line 480) | class OPERON_EXPORT
  function Sigma (line 489) | auto Sigma() const { return std::span<Operon::Scalar const>{sigma_}; }
  function SetSigma (line 490) | auto SetSigma(std::vector<Operon::Scalar> sigma) const -> void { sigma_ ...
  class OPERON_EXPORT (line 579) | class OPERON_EXPORT
  class OPERON_EXPORT (line 593) | class OPERON_EXPORT
  class OPERON_EXPORT (line 608) | class OPERON_EXPORT
  function Sigma (line 642) | auto Sigma() const { return std::span<Operon::Scalar const>{sigma_}; }
  function SetSigma (line 643) | auto SetSigma(std::vector<Operon::Scalar> sigma) const -> void { sigma_ ...

FILE: include/operon/operators/generator.hpp
  type Operon (line 16) | namespace Operon {
    type RecombinationResult (line 18) | struct RecombinationResult {
    class OffspringGeneratorBase (line 26) | class OffspringGeneratorBase : public OperatorBase<std::optional<Indiv...
      method OffspringGeneratorBase (line 28) | OffspringGeneratorBase(EvaluatorBase const* eval, CrossoverBase cons...
      method FemaleSelector (line 38) | [[nodiscard]] auto FemaleSelector() const -> SelectorBase const* { r...
      method MaleSelector (line 39) | [[nodiscard]] auto MaleSelector() const -> SelectorBase const* { ret...
      method Crossover (line 40) | [[nodiscard]] auto Crossover() const -> CrossoverBase const* { retur...
      method Mutator (line 41) | [[nodiscard]] auto Mutator() const -> MutatorBase const* { return mu...
      method Evaluator (line 42) | [[nodiscard]] auto Evaluator() const -> EvaluatorBase const* { retur...
      method Optimizer (line 43) | [[nodiscard]] auto Optimizer() const -> CoefficientOptimizer const* ...
      method Prepare (line 45) | virtual auto Prepare(Operon::Span<Individual const> pop) const -> void
      method Terminate (line 52) | [[nodiscard]] virtual auto Terminate() const -> bool { return evalua...
      method SetCache (line 54) | auto SetCache(Zobrist* cache) const { cache_ = cache; }
      method Cache (line 55) | [[nodiscard]] auto Cache() const -> Zobrist* { return cache_; }
      method Generate (line 57) | auto Generate(Operon::RandomGenerator& random, double pCrossover, do...
      method Generate (line 108) | auto Generate(Operon::RandomGenerator& random, double pCrossover, do...
    function BasicOffspringGenerator (line 124) | class OPERON_EXPORT BasicOffspringGenerator final : public OffspringGe...
    function BroodOffspringGenerator (line 134) | class OPERON_EXPORT BroodOffspringGenerator : public OffspringGenerato...
    function PolygenicOffspringGenerator (line 153) | class OPERON_EXPORT PolygenicOffspringGenerator : public OffspringGene...
    function OffspringSelectionGenerator (line 172) | class OPERON_EXPORT OffspringSelectionGenerator : public OffspringGene...

FILE: include/operon/operators/initializer.hpp
  type Operon (line 13) | namespace Operon {
    type CoefficientInitializerBase (line 15) | struct CoefficientInitializerBase : public OperatorBase<void, Tree&> {
    type TreeInitializerBase (line 18) | struct TreeInitializerBase : public OperatorBase<Tree> {
    function CoefficientInitializerBase (line 22) | struct OPERON_EXPORT CoefficientInitializer : public CoefficientInitia...
    function TreeInitializerBase (line 56) | struct OPERON_EXPORT TreeInitializer : public TreeInitializerBase {

FILE: include/operon/operators/local_search.hpp
  type Operon (line 12) | namespace Operon {
    class Tree (line 15) | class Tree
    class OptimizerBase (line 16) | class OptimizerBase
    type OptimizerSummary (line 17) | struct OptimizerSummary
    class OPERON_EXPORT (line 19) | class OPERON_EXPORT

FILE: include/operon/operators/mutation.hpp
  type Operon (line 22) | namespace Operon {
    type CoefficientInitializerBase (line 24) | struct CoefficientInitializerBase
    type CreatorBase (line 25) | struct CreatorBase
    type MutatorBase (line 28) | struct MutatorBase : public OperatorBase<Tree, Tree> {
    function OnePointMutation (line 32) | struct OPERON_EXPORT OnePointMutation : public MutatorBase {
    function MultiPointMutation (line 55) | struct OPERON_EXPORT MultiPointMutation : public MutatorBase {
    function DiscretePointMutation (line 76) | struct OPERON_EXPORT DiscretePointMutation : public MutatorBase {
    function MultiMutation (line 89) | struct OPERON_EXPORT MultiMutation : public MutatorBase {
    function ChangeVariableMutation (line 105) | struct OPERON_EXPORT ChangeVariableMutation : public MutatorBase {
    function ChangeFunctionMutation (line 117) | struct OPERON_EXPORT ChangeFunctionMutation : public MutatorBase {
    function RemoveSubtreeMutation (line 129) | struct OPERON_EXPORT RemoveSubtreeMutation final : public MutatorBase {
    function InsertSubtreeMutation (line 138) | struct OPERON_EXPORT InsertSubtreeMutation final : public MutatorBase {
    function ReplaceSubtreeMutation (line 156) | struct OPERON_EXPORT ReplaceSubtreeMutation : public MutatorBase {
    function ShuffleSubtreesMutation (line 174) | struct OPERON_EXPORT ShuffleSubtreesMutation : public MutatorBase {

FILE: include/operon/operators/non_dominated_sorter.hpp
  type Operon (line 14) | namespace Operon {
    type EfficientSortStrategy (line 16) | enum EfficientSortStrategy : int { Binary, Sequential }
    class NondominatedSorterBase (line 18) | class NondominatedSorterBase {
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function NondominatedSorterBase (line 44) | struct OPERON_EXPORT DeductiveSorter : public NondominatedSorterBase {
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function NondominatedSorterBase (line 48) | struct OPERON_EXPORT DominanceDegreeSorter : public NondominatedSorter...
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function NondominatedSorterBase (line 52) | struct OPERON_EXPORT HierarchicalSorter : public NondominatedSorterBase {
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function NondominatedSorterBase (line 56) | struct OPERON_EXPORT EfficientBinarySorter : public NondominatedSorter...
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function EfficientSequentialSorter (line 60) | struct OPERON_EXPORT EfficientSequentialSorter : public NondominatedSo...
    function NondominatedSorterBase (line 64) | struct OPERON_EXPORT MergeSorter : public NondominatedSorterBase {
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function NondominatedSorterBase (line 68) | struct OPERON_EXPORT RankOrdinalSorter : public NondominatedSorterBase {
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function NondominatedSorterBase (line 72) | struct OPERON_EXPORT RankIntersectSorter : public NondominatedSorterBa...
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }
    function NondominatedSorterBase (line 76) | struct OPERON_EXPORT BestOrderSorter : public NondominatedSorterBase {
      method Reset (line 33) | void Reset() { Stats = { 0, 0, 0, 0, 0, 0., 0. }; }

FILE: include/operon/operators/reinserter.hpp
  type Operon (line 11) | namespace Operon {
    class ReinserterBase (line 12) | class ReinserterBase : public OperatorBase<void, Operon::Span<Individu...
      method ReinserterBase (line 14) | explicit ReinserterBase(ComparisonCallback cb)
      method Sort (line 19) | inline void Sort(Operon::Span<Individual> inds) const { std::stable_...
      method Compare (line 21) | [[nodiscard]] inline auto Compare(Individual const& lhs, Individual ...
    function KeepBestReinserter (line 30) | class OPERON_EXPORT KeepBestReinserter : public ReinserterBase {
  function ReplaceWorstReinserter (line 56) | class OPERON_EXPORT ReplaceWorstReinserter : public ReinserterBase {

FILE: include/operon/operators/selector.hpp
  type Operon (line 10) | namespace Operon {
    class SelectorBase (line 13) | class SelectorBase : public OperatorBase<size_t> {
      method SelectorBase (line 17) | SelectorBase()
      method SelectorBase (line 22) | explicit SelectorBase(ComparisonCallback&& cb)
      method SelectorBase (line 27) | explicit SelectorBase(ComparisonCallback cb)
      method Prepare (line 32) | virtual void Prepare(Operon::Span<Individual const> pop) const
      method Population (line 37) | auto Population() const -> Operon::Span<Individual const> { return p...
      method Compare (line 39) | [[nodiscard]] inline auto Compare(Individual const& lhs, Individual ...
    function TournamentSelector (line 50) | class OPERON_EXPORT TournamentSelector : public SelectorBase {
    function RankTournamentSelector (line 71) | class OPERON_EXPORT RankTournamentSelector : public SelectorBase {
    function ProportionalSelector (line 90) | class OPERON_EXPORT ProportionalSelector : public SelectorBase {
    function RandomSelector (line 110) | class OPERON_EXPORT RandomSelector : public SelectorBase {

FILE: include/operon/optimizer/dynamic_cost_function.hpp
  type Operon (line 18) | namespace Operon {
    type DynamicCostFunction (line 20) | struct DynamicCostFunction final : public ceres::DynamicCostFunction {
      method DynamicCostFunction (line 23) | explicit DynamicCostFunction(CostFunctor const& cf)
      method Evaluate (line 35) | auto Evaluate(double const* const* parameters, double* residuals, do...
      method AddParameterBlock (line 77) | void AddParameterBlock(int /*size*/) override
      method SetNumResiduals (line 82) | void SetNumResiduals(int /*num_residuals*/) override
      method Functor (line 87) | auto Functor() -> CostFunctor& { return cf_; }
      method Functor (line 88) | [[nodiscard]] auto Functor() const -> CostFunctor const& { return cf...

FILE: include/operon/optimizer/likelihood/gaussian_likelihood.hpp
  type Operon (line 16) | namespace Operon {
    type detail (line 18) | namespace detail {
      type SquaredResidual (line 19) | struct SquaredResidual {
    type GaussianLikelihood (line 38) | struct GaussianLikelihood {
      method ComputeLikelihood (line 45) | static auto ComputeLikelihood(Span<Scalar const> x, Span<Scalar cons...
      method ComputeFisherMatrix (line 72) | static auto ComputeFisherMatrix(Span<Scalar const> pred, Span<Scalar...
    type GaussianLoss (line 98) | struct GaussianLoss : public LikelihoodBase<T> {
      method GaussianLoss (line 101) | GaussianLoss(gsl::not_null<Operon::RandomGenerator*> rng, gsl::not_n...
      method ComputeLikelihood (line 141) | static auto ComputeLikelihood(Span<Scalar const> x, Span<Scalar cons...
      method ComputeFisherMatrix (line 145) | static auto ComputeFisherMatrix(Span<Scalar const> pred, Span<Scalar...
      method NumParameters (line 149) | auto NumParameters() const -> std::size_t { return np_; }
      method NumObservations (line 150) | auto NumObservations() const -> std::size_t { return nr_; }
      method FunctionEvaluations (line 151) | auto FunctionEvaluations() const -> std::size_t { return feval_; }
      method JacobianEvaluations (line 152) | auto JacobianEvaluations() const -> std::size_t { return jeval_; }
      method SelectRandomRange (line 155) | auto SelectRandomRange() const -> Operon::Range {

FILE: include/operon/optimizer/likelihood/likelihood_base.hpp
  type Operon (line 15) | namespace Operon {
    type Concepts (line 17) | namespace Concepts {
    type LikelihoodBase (line 31) | struct LikelihoodBase {
      method LikelihoodBase (line 40) | explicit LikelihoodBase(gsl::not_null<Operon::InterpreterBase<T> con...
      method GetInterpreter (line 45) | [[nodiscard]] auto GetInterpreter() const -> InterpreterBase<Operon:...
    type Concepts (line 60) | namespace Concepts {

FILE: include/operon/optimizer/likelihood/poisson_likelihood.hpp
  type Operon (line 16) | namespace Operon {
    type detail (line 18) | namespace detail {
      type Poisson (line 19) | struct Poisson {
      type PoissonLog (line 31) | struct PoissonLog {
    type PoissonLikelihood (line 48) | struct PoissonLikelihood {
      method ComputeLikelihood (line 55) | static auto ComputeLikelihood(Span<Scalar const> x, Span<Scalar cons...
      method ComputeFisherMatrix (line 78) | static auto ComputeFisherMatrix(Span<Scalar const> pred, Span<Scalar...
    type PoissonLoss (line 98) | struct PoissonLoss : public LikelihoodBase<T> {
      method PoissonLoss (line 101) | PoissonLoss(gsl::not_null<Operon::RandomGenerator*> rng, gsl::not_nu...
      method ComputeLikelihood (line 148) | static auto ComputeLikelihood(Span<Scalar const> x, Span<Scalar cons...
      method ComputeFisherMatrix (line 152) | static auto ComputeFisherMatrix(Span<Scalar const> pred, Span<Scalar...
      method NumParameters (line 156) | auto NumParameters() const -> std::size_t { return numParameters_; }
      method NumObservations (line 157) | auto NumObservations() const -> std::size_t { return numResiduals_; }
      method FunctionEvaluations (line 158) | auto FunctionEvaluations() const -> std::size_t { return feval_; }
      method JacobianEvaluations (line 159) | auto JacobianEvaluations() const -> std::size_t { return jeval_; }
      method SelectRandomRange (line 162) | auto SelectRandomRange() const -> Operon::Range {

FILE: include/operon/optimizer/lm_cost_function.hpp
  type Operon (line 11) | namespace Operon {
    type LMCostFunction (line 19) | struct LMCostFunction {
      method LMCostFunction (line 28) | explicit LMCostFunction(gsl::not_null<InterpreterBase<T> const*> int...
      method Evaluate (line 36) | inline auto Evaluate(Scalar const* parameters, Scalar* residuals, Sc...
      method NumResiduals (line 66) | [[nodiscard]] auto NumResiduals() const -> int { return numResiduals...
      method NumParameters (line 67) | [[nodiscard]] auto NumParameters() const -> int { return numParamete...
      method df (line 81) | auto df(Eigen::Matrix<Scalar, -1, 1> const& input, Eigen::Matrix<Sca...
      method values (line 88) | [[nodiscard]] auto values() const -> int { return NumResiduals(); }
      method inputs (line 89) | [[nodiscard]] auto inputs() const -> int { return NumParameters(); }
      method ResidualCalls (line 91) | [[nodiscard]] auto ResidualCalls() const -> std::size_t { return res...
      method JacobianCalls (line 92) | [[nodiscard]] auto JacobianCalls() const -> std::size_t { return jac...

FILE: include/operon/optimizer/optimizer.hpp
  type Operon (line 31) | namespace Operon {
    type OptimizerType (line 33) | enum class OptimizerType : int { Tiny, Eigen, Ceres }
    type OptimizerSummary (line 35) | struct OptimizerSummary {
    class OptimizerBase (line 46) | class OptimizerBase {
      method OptimizerBase (line 53) | explicit OptimizerBase(gsl::not_null<Problem const*> problem)
      method OptimizerBase (line 58) | OptimizerBase(const OptimizerBase&) = default;
      method OptimizerBase (line 59) | OptimizerBase(OptimizerBase&&) = delete;
      method GetProblem (line 65) | [[nodiscard]] auto GetProblem() const -> Problem const* { return pro...
      method BatchSize (line 66) | [[nodiscard]] auto BatchSize() const -> std::size_t { return batchSi...
      method Iterations (line 67) | [[nodiscard]] auto Iterations() const -> std::size_t { return iterat...
      method SetBatchSize (line 69) | auto SetBatchSize(std::size_t batchSize) const { batchSize_ = batchS...
      method SetIterations (line 70) | auto SetIterations(std::size_t iterations) const { iterations_ = ite...
    type detail (line 77) | namespace detail {
      function CheckSuccess (line 78) | inline auto CheckSuccess(double initialCost, double finalCost) {
    type LevenbergMarquardtOptimizer (line 85) | struct LevenbergMarquardtOptimizer : public OptimizerBase {
      method LevenbergMarquardtOptimizer (line 86) | explicit LevenbergMarquardtOptimizer(gsl::not_null<DTable const*> dt...
      method Optimize (line 91) | [[nodiscard]] auto Optimize(Operon::RandomGenerator& /*unused*/, Ope...
      method GetDispatchTable (line 124) | auto GetDispatchTable() const -> DTable const* { return dtable_.get(...
      method ComputeLikelihood (line 126) | [[nodiscard]] auto ComputeLikelihood(Operon::Span<Operon::Scalar con...
      method ComputeFisherMatrix (line 131) | [[nodiscard]] auto ComputeFisherMatrix(Operon::Span<Operon::Scalar c...
    type LevenbergMarquardtOptimizer<DTable, OptimizerType::Eigen> (line 140) | struct LevenbergMarquardtOptimizer<DTable, OptimizerType::Eigen> final...
      method LevenbergMarquardtOptimizer (line 141) | explicit LevenbergMarquardtOptimizer(gsl::not_null<DTable const*> dt...
      method Optimize (line 146) | [[nodiscard]] auto Optimize(Operon::RandomGenerator& /*unused*/, Ope...
      method GetDispatchTable (line 187) | auto GetDispatchTable() const -> DTable const* { return dtable_.get(...
      method ComputeLikelihood (line 189) | [[nodiscard]] auto ComputeLikelihood(Operon::Span<Operon::Scalar con...
      method ComputeFisherMatrix (line 194) | [[nodiscard]] auto ComputeFisherMatrix(Operon::Span<Operon::Scalar c...
    type LevenbergMarquardtOptimizer<DTable, OptimizerType::Ceres> (line 204) | struct LevenbergMarquardtOptimizer<DTable, OptimizerType::Ceres> final...
      method LevenbergMarquardtOptimizer (line 205) | explicit LevenbergMarquardtOptimizer(gsl::not_null<DTable const*> dt...
      method Optimize (line 210) | auto Optimize(Operon::RandomGenerator& /*unused*/, Operon::Tree cons...
      method GetDispatchTable (line 251) | auto GetDispatchTable() const -> DTable const& { return dtable_.get(...
      method ComputeLikelihood (line 253) | [[nodiscard]] auto ComputeLikelihood(Operon::Span<Operon::Scalar con...
      method ComputeFisherMatrix (line 258) | [[nodiscard]] auto ComputeFisherMatrix(Operon::Span<Operon::Scalar c...
    type LBFGSOptimizer (line 268) | struct LBFGSOptimizer final : public OptimizerBase {
      method LBFGSOptimizer (line 269) | LBFGSOptimizer(gsl::not_null<DTable const*> dtable, gsl::not_null<Pr...
      method Optimize (line 274) | [[nodiscard]] auto Optimize(Operon::RandomGenerator& rng, Operon::Tr...
      method GetDispatchTable (line 321) | auto GetDispatchTable() const -> DTable const* { return dtable_.get(...
      method ComputeLikelihood (line 323) | [[nodiscard]] auto ComputeLikelihood(Operon::Span<Operon::Scalar con...
      method ComputeFisherMatrix (line 328) | [[nodiscard]] auto ComputeFisherMatrix(Operon::Span<Operon::Scalar c...
    type SGDOptimizer (line 337) | struct SGDOptimizer final : public OptimizerBase {
      method SGDOptimizer (line 338) | SGDOptimizer(gsl::not_null<DTable const*> dtable, gsl::not_null<Prob...
      method SGDOptimizer (line 344) | SGDOptimizer(gsl::not_null<DTable const*> dtable, gsl::not_null<Prob...
      method GetDispatchTable (line 350) | auto GetDispatchTable() const -> DTable const* { return dtable_.get(...
      method Optimize (line 352) | [[nodiscard]] auto Optimize(Operon::RandomGenerator& rng, Operon::Tr...
      method ComputeLikelihood (line 396) | [[nodiscard]] auto ComputeLikelihood(Operon::Span<Operon::Scalar con...
      method ComputeFisherMatrix (line 401) | [[nodiscard]] auto ComputeFisherMatrix(Operon::Span<Operon::Scalar c...
      method SetUpdateRule (line 405) | auto SetUpdateRule(std::unique_ptr<UpdateRule::LearningRateUpdateRul...
      method UpdateRule (line 409) | auto UpdateRule() const { return update_.get(); }

FILE: include/operon/optimizer/solvers/sgd.hpp
  type Operon (line 17) | namespace Operon {
    type UpdateRule (line 19) | namespace UpdateRule {
      type LearningRateUpdateRule (line 20) | struct LearningRateUpdateRule {
        method LearningRateUpdateRule (line 38) | LearningRateUpdateRule(const LearningRateUpdateRule&) = delete;
        method LearningRateUpdateRule (line 39) | LearningRateUpdateRule(LearningRateUpdateRule&&) = delete;
        method LearningRateUpdateRule (line 43) | explicit LearningRateUpdateRule(std::string name)
        method Name (line 48) | [[nodiscard]] auto Name() const -> std::string const& { return nam...
      class Constant (line 57) | class Constant : public LearningRateUpdateRule {
        method Constant (line 68) | explicit Constant(Eigen::Index /*dim*/= 0, T r = 0.1)
        method Constant (line 74) | explicit Constant(T r = 0.1) : Constant(0, r)
        method Update (line 78) | [[nodiscard]] auto Update(Eigen::Ref<U const> const& gradient) con...
        method Update (line 85) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 91) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 98) | auto SetDimension(int /*unused*/) const -> void final { }
        method Clone (line 100) | [[nodiscard]] auto Clone(int dim) const -> std::unique_ptr<Learnin...
      class Momentum (line 106) | class Momentum : public LearningRateUpdateRule {
        method Momentum (line 117) | explicit Momentum(Eigen::Index dim, T r = 0.01, T b = 0.9)
        method Update (line 125) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 132) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 139) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 147) | auto SetDimension(int dim) const -> void final
        method Clone (line 154) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
      class RmsProp (line 162) | class RmsProp : public LearningRateUpdateRule {
        method RmsProp (line 174) | explicit RmsProp(Eigen::Index dim, T r = 0.01, T b = 0.9, T e = 1e-6)
        method Update (line 183) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 190) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 197) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 206) | auto SetDimension(int dim) const -> void final
        method Clone (line 213) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
      class AdaDelta (line 221) | class AdaDelta : public LearningRateUpdateRule {
        method AdaDelta (line 234) | explicit AdaDelta(Eigen::Index dim, T b = 0.9, T e = 1e-6)
        method Update (line 244) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 251) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 260) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 270) | auto SetDimension(int dim) const -> void final
        method Clone (line 279) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
      class AdaMax (line 287) | class AdaMax : public LearningRateUpdateRule {
        method AdaMax (line 300) | explicit AdaMax(Eigen::Index dim, T r = 0.01, T b1 = 0.9, T b2 = 0...
        method Update (line 310) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 317) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 325) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 335) | auto SetDimension(int dim) const -> void final
        method Clone (line 343) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
      class Adam (line 351) | class Adam : public LearningRateUpdateRule {
        method Adam (line 368) | explicit Adam(Eigen::Index dim, T r = 0.01, T e = 1e-8, T b1 = 0.9...
        method Update (line 380) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 387) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 405) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 417) | auto SetDimension(int dim) const -> void final
        method Clone (line 425) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
      class YamAdam (line 433) | class YamAdam : public LearningRateUpdateRule {
        method YamAdam (line 445) | explicit YamAdam(Eigen::Index dim, T e = 1e-6)
        method Update (line 457) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 464) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 476) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 488) | auto SetDimension(int dim) const -> void final
        method Clone (line 500) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
      class AmsGrad (line 508) | class AmsGrad : public LearningRateUpdateRule {
        method AmsGrad (line 519) | explicit AmsGrad(Eigen::Index dim, T r = 0.01, T e = 1e-6, T b1 = ...
        method Update (line 530) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 537) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 545) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 556) | auto SetDimension(int dim) const -> void final
        method Clone (line 564) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
      class Yogi (line 572) | class Yogi : public LearningRateUpdateRule {
        method Yogi (line 586) | explicit Yogi(Eigen::Index dim, T r = 0.01, T e = 1e-8, T b1 = 0.9...
        method Update (line 598) | auto Update(Eigen::Ref<U const> const& gradient) const -> U final
        method Update (line 605) | auto Update(Eigen::Ref<U const> const& gradient, Eigen::Ref<U> res...
        method Print (line 621) | auto Print(std::ostream& os) const -> std::ostream& final
        method SetDimension (line 632) | auto SetDimension(int dim) const -> void final
        method Clone (line 640) | auto Clone(int dim) const -> std::unique_ptr<LearningRateUpdateRul...
    type SGDSolver (line 649) | struct SGDSolver {
      method SGDSolver (line 653) | explicit SGDSolver(gsl::not_null<Functor const* >functor, gsl::not_n...
      method Optimize (line 659) | auto Optimize(Eigen::Ref<Vector const> const x0, int epochs = 1000) ...
      method Epochs (line 685) | auto Epochs() const { return epochs_; }

FILE: include/operon/optimizer/tiny_cost_function.hpp
  type Operon (line 12) | namespace Operon {
    type CostFunction (line 20) | struct CostFunction {
      method CostFunction (line 29) | explicit CostFunction(gsl::not_null<Operon::InterpreterBase<T> const...
      method Evaluate (line 37) | inline auto Evaluate(Scalar const* parameters, Scalar* residuals, Sc...
      method NumResiduals (line 65) | [[nodiscard]] auto NumResiduals() const -> int { return numResiduals...
      method NumParameters (line 66) | [[nodiscard]] auto NumParameters() const -> int { return numParamete...
      method df (line 80) | auto df(Eigen::Matrix<Scalar, -1, 1> const& input, Eigen::Matrix<Sca...
      method values (line 88) | [[nodiscard]] auto values() const -> int { return NumResiduals(); }
      method inputs (line 89) | [[nodiscard]] auto inputs() const -> int { return NumParameters(); }
      method ParameterCount (line 98) | inline auto ParameterCount(auto const& tree) const -> std::size_t {

FILE: include/operon/parser/infix.hpp
  type Operon (line 13) | namespace Operon {
    function InfixParser (line 15) | struct OPERON_EXPORT InfixParser {

FILE: include/operon/random/random.hpp
  type Operon::Random (line 13) | namespace Operon::Random {
    function Uniform (line 15) | auto Uniform(R& random, T a, T b) -> T
    function Sample (line 23) | auto Sample(R& random, InputIterator start, InputIterator end) -> Inpu...
    function Sample (line 32) | auto Sample(R& random, InputIterator start, InputIterator end,
    function Sample (line 55) | auto Sample(R& random, InputIterator start, InputIterator end, OutputI...

FILE: source/algorithms/gp.cpp
  type Operon (line 24) | namespace Operon {

FILE: source/algorithms/nsga2.cpp
  type Operon (line 28) | namespace Operon {

FILE: source/algorithms/solution_archive.cpp
  type Operon (line 15) | namespace Operon {

FILE: source/core/dataset.cpp
  type Operon (line 14) | namespace Operon {
    function VariablesFromNames (line 18) | auto VariablesFromNames(auto const& names) {
    function DefaultVariables (line 30) | auto DefaultVariables(size_t count) {
    function MatrixFromValues (line 38) | auto MatrixFromValues(auto const& values) {

FILE: source/core/distance.cpp
  type Operon::Distance (line 9) | namespace Operon::Distance {
    type detail (line 10) | namespace detail {
      function Intersect (line 12) | auto Intersect(T const* lhs, T const* rhs) {
      function CountIntersect (line 21) | inline auto CountIntersect(Operon::Span<T const> lhs, Operon::Span<T...
      function CountIntersect (line 60) | inline auto CountIntersect(Container const& lhs, Container const& rh...
    function Jaccard (line 67) | auto Jaccard(Operon::Vector<Operon::Hash> const& lhs, Operon::Vector<O...
    function SorensenDice (line 74) | auto SorensenDice(Operon::Vector<Operon::Hash> const& lhs, Operon::Vec...

FILE: source/core/node.cpp
  type Operon (line 17) | namespace Operon {

FILE: source/core/pset.cpp
  type Operon (line 20) | namespace Operon {

FILE: source/core/tree.cpp
  type Operon (line 19) | namespace Operon {

FILE: source/core/version.cpp
  type Operon (line 13) | namespace Operon {
    function Version (line 15) | auto Version() -> std::string {

FILE: source/formatter/dot.cpp
  type Operon (line 9) | namespace Operon {

FILE: source/formatter/infix.cpp
  type Operon (line 9) | namespace Operon {

FILE: source/formatter/postfix.cpp
  type Operon (line 9) | namespace Operon {

FILE: source/formatter/tree.cpp
  type Operon (line 9) | namespace Operon {

FILE: source/hash/hash.cpp
  type Operon (line 13) | namespace Operon {

FILE: source/hash/metrohash64.cpp
  function rotate_right (line 25) | inline static uint64_t rotate_right(uint64_t v, unsigned k) // NOLINT
  function read_u64 (line 31) | inline static uint64_t read_u64(const void* const ptr) // NOLINT
  function read_u32 (line 36) | inline static uint64_t read_u32(const void* const ptr) // NOLINT
  function read_u16 (line 41) | inline static uint64_t read_u16(const void* const ptr) // NOLINT
  function read_u8 (line 46) | inline static uint64_t read_u8(const void* const ptr) // NOLINT
  type Operon::HashUtil (line 52) | namespace Operon::HashUtil {

FILE: source/hash/zobrist.cpp
  type Operon (line 9) | namespace Operon {
    type Zobrist::TranspositionTable (line 11) | struct Zobrist::TranspositionTable {

FILE: source/interpreter/interpreter.cpp
  type Operon (line 8) | namespace Operon {
    function EvaluateTrees (line 9) | auto EvaluateTrees(Operon::Vector<Operon::Tree> const& trees, Operon::...
    function EvaluateTrees (line 27) | auto EvaluateTrees(Operon::Vector<Operon::Tree> const& trees, Operon::...

FILE: source/operators/creator/balanced.cpp
  type Operon (line 18) | namespace Operon {

FILE: source/operators/creator/creator.cpp
  type Operon (line 11) | namespace Operon {

FILE: source/operators/creator/koza.cpp
  type Operon (line 18) | namespace Operon {

FILE: source/operators/creator/ptc2.cpp
  type Operon (line 21) | namespace Operon {

FILE: source/operators/crossover.cpp
  type Operon (line 12) | namespace Operon {
    function NotIn (line 15) | auto NotIn(Limits t, size_t v) -> bool {

FILE: source/operators/evaluator.cpp
  type Operon (line 20) | namespace Operon {
    function FitLeastSquaresImpl (line 22) | auto FitLeastSquaresImpl(Operon::Span<T const> estimated, Operon::Span...
    function FitLeastSquares (line 34) | auto FitLeastSquares(Operon::Span<float const> estimated, Operon::Span...
    function FitLeastSquares (line 38) | auto FitLeastSquares(Operon::Span<double const> estimated, Operon::Spa...

FILE: source/operators/evaluator_error_metrics.cpp
  type Operon (line 4) | namespace Operon {

FILE: source/operators/generator/basic.cpp
  type Operon (line 6) | namespace Operon {

FILE: source/operators/generator/brood.cpp
  type Operon (line 7) | namespace Operon {

FILE: source/operators/generator/os.cpp
  type Operon (line 7) | namespace Operon {

FILE: source/operators/generator/poly.cpp
  type Operon (line 7) | namespace Operon {

FILE: source/operators/local_search.cpp
  type Operon (line 10) | namespace Operon {

FILE: source/operators/mutation.cpp
  type Operon (line 16) | namespace Operon {

FILE: source/operators/non_dominated_sorter/best_order_sort.cpp
  type Operon (line 11) | namespace Operon {

FILE: source/operators/non_dominated_sorter/deductive_sort.cpp
  type Operon (line 16) | namespace Operon {

FILE: source/operators/non_dominated_sorter/dominance_degree_sort.cpp
  type Operon (line 9) | namespace Operon {
    function ComputeComparisonMatrix (line 13) | inline auto ComputeComparisonMatrix(Operon::Span<Operon::Individual co...
    function ComparisonMatrixSum (line 31) | inline auto ComparisonMatrixSum(Operon::Span<Operon::Individual const>...
    function ComputeDegreeMatrix (line 39) | inline auto ComputeDegreeMatrix(Operon::Span<Operon::Individual const>...

FILE: source/operators/non_dominated_sorter/efficient_sort.cpp
  type Operon (line 10) | namespace Operon {
    function EfficientSortImpl (line 13) | inline auto EfficientSortImpl(Operon::Span<Operon::Individual const> p...

FILE: source/operators/non_dominated_sorter/hierarchical_sort.cpp
  type Operon (line 13) | namespace Operon {

FILE: source/operators/non_dominated_sorter/merge_sort.cpp
  type Operon (line 18) | namespace Operon {
    type detail (line 20) | namespace detail {
      class BitsetManager (line 21) | class BitsetManager {
        method GetRanking (line 39) | [[nodiscard]] auto GetRanking() const -> Operon::Vector<int> const...
        method UpdateSolutionDominance (line 41) | auto UpdateSolutionDominance(size_t solutionId) -> bool
        method ComputeSolutionRanking (line 70) | void ComputeSolutionRanking(size_t solutionId, size_t initSolId)
        method UpdateIncrementalBitset (line 115) | void UpdateIncrementalBitset(size_t solutionId)
        method InitializeSolutionBitset (line 127) | auto InitializeSolutionBitset(size_t solutionId) -> bool
        method ClearIncrementalBitset (line 159) | void ClearIncrementalBitset()
        method BitsetManager (line 166) | BitsetManager() = default;
        method BitsetManager (line 169) | explicit BitsetManager(size_t nSolutions)
      type Item (line 180) | struct Item {

FILE: source/operators/non_dominated_sorter/rank_intersect.cpp
  type Operon (line 13) | namespace Operon {
    type Item (line 23) | struct Item {
    function MakeUnique (line 31) | auto MakeUnique(std::size_t n, std::optional<typename std::remove_exte...
    function InitBitsets (line 40) | auto InitBitsets(Operon::Span<Operon::Individual const> pop)
    function UpdateRanks (line 87) | auto UpdateRanks(auto i, auto const& item, auto& rank, auto& rankset)
    function GetFronts (line 117) | auto GetFronts(Operon::Vector<int> const& rank)

FILE: source/operators/non_dominated_sorter/rank_ordinal.cpp
  type Operon (line 13) | namespace Operon {

FILE: source/operators/selector/proportional.cpp
  type Operon (line 18) | namespace Operon {

FILE: source/operators/selector/tournament.cpp
  type Operon (line 15) | namespace Operon {

FILE: source/parser/infix.cpp
  function MakeNodeTypeMap (line 23) | constexpr auto MakeNodeTypeMap()
  function ToOperonNode (line 62) | auto ToOperonNode(infix_parser::node const& a) -> Operon::Node
  type Operon (line 82) | namespace Operon {

FILE: test/source/implementation/autodiff.cpp
  type Operon::Test (line 20) | namespace Operon::Test {

FILE: test/source/implementation/crossover.cpp
  type Operon::Test (line 17) | namespace Operon::Test {

FILE: test/source/implementation/details.cpp
  type Operon::Test (line 21) | namespace Operon::Test {

FILE: test/source/implementation/dispatch_table.cpp
  type Operon::Test (line 15) | namespace Operon::Test {

FILE: test/source/implementation/error_metrics.cpp
  type Operon::Test (line 9) | namespace Operon::Test {

FILE: test/source/implementation/evaluation.cpp
  type Operon::Test (line 18) | namespace Operon::Test {

FILE: test/source/implementation/evaluator.cpp
  type Operon::Test (line 18) | namespace Operon::Test {
    type EvaluatorFixture (line 25) | struct EvaluatorFixture {
      method EvaluatorFixture (line 38) | EvaluatorFixture()
      method MakeIndividual (line 68) | static auto MakeIndividual(Operon::Tree const& t) -> Operon::Individ...

FILE: test/source/implementation/hashing.cpp
  type Operon::Test (line 20) | namespace Operon::Test {

FILE: test/source/implementation/infix_parser.cpp
  type Operon::Test (line 15) | namespace Operon::Test {

FILE: test/source/implementation/initialization.cpp
  type Operon::Test (line 16) | namespace Operon::Test {
    function GenerateTrees (line 18) | static auto GenerateTrees(Operon::RandomGenerator& random, Operon::Cre...
    type TestCreator (line 190) | struct TestCreator final : public CreatorBase {
      method TestCreator (line 191) | TestCreator(PrimitiveSet const* pset, size_t maxLen)
      method SnapDown (line 196) | auto SnapDown(size_t n) const -> size_t { return AchievableLength(n); }

FILE: test/source/implementation/mutation.cpp
  type Operon::Test (line 15) | namespace Operon::Test {

FILE: test/source/implementation/nondominatedsort.cpp
  type Operon::Test (line 17) | namespace Operon::Test {
    function InitializePop (line 20) | auto InitializePop(Operon::RandomGenerator& random, auto& dist, size_t...

FILE: test/source/implementation/optimizer.cpp
  type Operon::Test (line 20) | namespace Operon::Test {
    type OptimizerFixture (line 26) | struct OptimizerFixture {
      method OptimizerFixture (line 38) | OptimizerFixture()

FILE: test/source/implementation/random.cpp
  type Operon::Test (line 14) | namespace Operon::Test {

FILE: test/source/implementation/selection.cpp
  type Operon::Test (line 13) | namespace Operon::Test {

FILE: test/source/implementation/zobrist.cpp
  type Operon::Test (line 14) | namespace Operon::Test {
    function MakeSetup (line 20) | auto MakeSetup() {

FILE: test/source/operon_test.hpp
  type Operon::Test::Util (line 20) | namespace Operon::Test::Util {
    function RandomDataset (line 21) | inline auto RandomDataset(Operon::RandomGenerator& rng, int rows, int ...
    function EvaluateTree (line 30) | auto EvaluateTree(auto const& tree, auto const& dataset, auto const ra...
    function Autodiff (line 217) | auto Autodiff(auto const& tree, auto const& dataset, auto const range) {

FILE: test/source/performance/autodiff.cpp
  type Operon::Test (line 18) | namespace Operon::Test {

FILE: test/source/performance/creator.cpp
  type Operon::Test (line 15) | namespace Operon::Test {

FILE: test/source/performance/distance.cpp
  type Operon (line 15) | namespace Operon {
    type Test (line 16) | namespace Test {
      type ComputeDistanceMatrix (line 19) | struct ComputeDistanceMatrix {
        method ComputeDistanceMatrix (line 20) | explicit ComputeDistanceMatrix(Callable&& f)

FILE: test/source/performance/evaluation.cpp
  type Operon::Test (line 31) | namespace Operon::Test {
    function TotalNodes (line 32) | auto TotalNodes(const Operon::Vector<Tree>& trees)
    function Evaluate (line 41) | void Evaluate(tf::Executor& executor, DTable const& dt, Operon::Vector...

FILE: test/source/performance/infix_parser.cpp
  type Operon::Test (line 15) | namespace Operon::Test {

FILE: test/source/performance/nondominatedsort.cpp
  type Operon::Test (line 19) | namespace Operon::Test {
    function InitializePop (line 24) | auto InitializePop(Operon::RandomGenerator& random, Dist& dist, size_t...

FILE: test/source/thirdparty/elki_stats.hpp
  type Elki (line 18) | namespace Elki {
    type MeanVarianceResult (line 19) | struct MeanVarianceResult {
    type MeanVariance (line 25) | struct MeanVariance {
      method put (line 30) | void put(double val) {
      method put (line 44) | void put(double val, double weight) {
      method put (line 61) | auto put(auto const& x) {
      method put (line 65) | auto put(auto const& x, auto const& w) {
      method Sum (line 72) | double Sum() const { return sum; }
      method PopulationMean (line 74) | double PopulationMean() const { return sum / n; }
      method SampleMean (line 75) | double SampleMean() const { return sum / (n-1); }
      method PopulationVariance (line 77) | double PopulationVariance() const { return m2 / n; }
      method SampleVariance (line 78) | double SampleVariance() const { return m2 / (n-1); }
      method PopulationStats (line 80) | static inline auto PopulationStats(auto const& x) {
      method PopulationStats (line 86) | static inline auto PopulationStats(auto const& x, auto const& w) {
      method SampleStats (line 92) | static inline auto SampleStats(auto const& x) {
      method SampleStats (line 98) | static inline auto SampleStats(auto const& x, auto const& w) {
      method SSR (line 104) | static inline auto SSR(auto const& x, auto const& y) {
      method SSR (line 115) | static inline auto SSR(auto const& x, auto const& y, auto const& z) {
      method MSE (line 127) | static inline auto MSE(auto const& x, auto const& y) {
      method MSE (line 138) | static inline auto MSE(auto const& x, auto const& y, auto const& z) {
      method NMSE (line 150) | static inline auto NMSE(auto const& x, auto const& y) {
      method NMSE (line 162) | static inline auto NMSE(auto const& x, auto const& y, auto const& z) {
      method MAE (line 175) | static inline auto MAE(auto const& x, auto const& y) {
      method MAE (line 185) | static inline auto MAE(auto const& x, auto const& y, auto const& z) {
      method Corr (line 196) | static inline auto Corr(auto const& x, auto const& y) {
      method Corr (line 214) | static inline auto Corr(auto const& x, auto const& y, auto const& z) {
      method R2 (line 232) | static inline auto R2(auto const& x, auto const& y) {
      method R2 (line 245) | static inline auto R2(auto const& x, auto const& y, auto const& z) {

FILE: test/source/thirdparty/nanobench.h
  function namespace (line 129) | namespace ankerl {
  function namespace (line 369) | namespace ankerl {
  function namespace (line 1328) | namespace ankerl {
  function namespace (line 1352) | namespace ankerl {

FILE: tools/bench_ndsort.py
  function _parse_csv_lines (line 63) | def _parse_csv_lines(text: str) -> list[dict]:
  function run_once (line 99) | def run_once(binary: Path, tag: str, section: str | None, timeout: int) ...
  function _quantile (line 116) | def _quantile(data: list[float], q: float) -> float:
  function _iqr (line 126) | def _iqr(data: list[float]) -> float:
  function aggregate (line 129) | def aggregate(all_rows: list[dict]) -> dict:
  function _fmt_ns (line 149) | def _fmt_ns(ns: float) -> str:
  function print_tables (line 158) | def print_tables(agg: dict, runs: int) -> None:
  function plot_results (line 200) | def plot_results(agg: dict) -> None:
  function main (line 232) | def main() -> None:

FILE: tools/benchmark_cache.py
  function fmt_duration (line 76) | def fmt_duration(seconds: float) -> str:
  function parse_budget (line 86) | def parse_budget(s: str) -> float:
  function repair_csv (line 98) | def repair_csv(path: Path) -> bool:
  function load_problem (line 114) | def load_problem(name: str) -> dict:
  function discover_problems (line 131) | def discover_problems() -> list[str]:
  function run_one (line 139) | def run_one(
  function run_estimate (line 194) | def run_estimate(
  function main (line 249) | def main() -> None:

FILE: tools/compare_operon.py
  function _strip_color (line 52) | def _strip_color(s: str) -> str:
  class Dataset (line 58) | class Dataset:
    method name (line 65) | def name(self) -> str:
  class RunConfig (line 100) | class RunConfig:
    method cli_args (line 112) | def cli_args(self, datadir: Path) -> list[str]:
    method label (line 131) | def label(self) -> str:
    method group_key (line 136) | def group_key(self) -> tuple:
  class RunResult (line 142) | class RunResult:
  function _parse_stats_line (line 150) | def _parse_stats_line(line: str) -> dict:
  function run_binary (line 163) | def run_binary(binary: Path, config: RunConfig, datadir: Path, timeout: ...
  function _ok (line 189) | def _ok(msg, no_color=False):
  function _fail (line 193) | def _fail(msg, no_color=False):
  function _warn (line 197) | def _warn(msg, no_color=False):
  function test_determinism (line 203) | def test_determinism(ref_bin: Path, new_bin: Path, datadir: Path, args) ...
  function test_statistics (line 291) | def test_statistics(ref_bin: Path, new_bin: Path, datadir: Path, args) -...
  function main (line 446) | def main() -> None: