Full Code of heal-research/operon for AI

gitextract_jvogax4q/

├── .clang-format
├── .clang-tidy
├── .codespellrc
├── .envrc
├── .github/
│   └── workflows/
│       ├── build-linux.yml
│       ├── build-macos.yml
│       ├── build-windows.yml
│       ├── ci.yml
│       └── test-linux.yml
├── .gitignore
├── .readthedocs.yml
├── BUILDING.md
├── CMakeLists.txt
├── CMakePresets.json
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── HACKING.md
├── LICENSE
├── README.md
├── cli/
│   ├── CMakeLists.txt
│   └── source/
│       ├── operator_factory.cpp
│       ├── operator_factory.hpp
│       ├── operon_gp.cpp
│       ├── operon_nsgp.cpp
│       ├── operon_parse_model.cpp
│       ├── pareto_front.cpp
│       ├── pareto_front.hpp
│       ├── reporter.hpp
│       ├── util.cpp
│       └── util.hpp
├── cmake/
│   ├── coverage.cmake
│   ├── dev-mode.cmake
│   ├── docs.cmake
│   ├── get-git-revision.cmake
│   ├── get-git-revision.cmake.in
│   ├── install-config.cmake
│   ├── install-rules.cmake
│   ├── lint-targets.cmake
│   ├── lint.cmake
│   ├── open-cpp-coverage.cmake.example
│   ├── prelude.cmake
│   ├── project-is-top-level.cmake
│   ├── spell-targets.cmake
│   ├── spell.cmake
│   ├── variables.cmake
│   └── windows-set-path.cmake
├── data/
│   ├── AirfoilSelfNoise.csv
│   ├── AirfoilSelfNoise.json
│   ├── Breiman-I.csv
│   ├── Breiman-I.json
│   ├── Chemical-I.csv
│   ├── Chemical-I.json
│   ├── Chemical-II.csv
│   ├── Chemical-II.json
│   ├── Concrete.csv
│   ├── Concrete.json
│   ├── Flow_stress.csv
│   ├── Flow_stress.json
│   ├── FrictionDyn-OneHot.csv
│   ├── FrictionDyn-OneHot.json
│   ├── FrictionStat-OneHot.csv
│   ├── FrictionStat-OneHot.json
│   ├── Friedman-I.csv
│   ├── Friedman-I.json
│   ├── Friedman-II.csv
│   ├── Friedman-II.json
│   ├── GP-Challenge.csv
│   ├── GP-Challenge.json
│   ├── NasaBattery-1_10min.csv
│   ├── NasaBattery-1_10min.json
│   ├── NasaBattery-2_20min.csv
│   ├── NasaBattery-2_20min.json
│   ├── Nikuradse_1.csv
│   ├── Nikuradse_1.json
│   ├── Nikuradse_2.csv
│   ├── Nikuradse_2.json
│   ├── Pagie-1.csv
│   ├── Pagie-1.json
│   ├── Poly-10.csv
│   ├── Poly-10.json
│   ├── Sextic.csv
│   ├── Sextic.json
│   ├── Vladislavleva-1.csv
│   ├── Vladislavleva-1.json
│   ├── Vladislavleva-2.csv
│   ├── Vladislavleva-2.json
│   ├── Vladislavleva-3.csv
│   ├── Vladislavleva-3.json
│   ├── Vladislavleva-4.csv
│   ├── Vladislavleva-4.json
│   ├── Vladislavleva-5.csv
│   ├── Vladislavleva-5.json
│   ├── Vladislavleva-6.csv
│   ├── Vladislavleva-6.json
│   ├── Vladislavleva-7.csv
│   ├── Vladislavleva-7.json
│   ├── Vladislavleva-8.csv
│   └── Vladislavleva-8.json
├── docs/
│   ├── Doxyfile.in
│   ├── conf.py.in
│   └── pages/
│       └── about.dox
├── example/
│   ├── CMakeLists.txt
│   ├── custom_primitives.cpp
│   └── empty_example.cpp
├── flake.nix
├── include/
│   └── operon/
│       ├── algorithms/
│       │   ├── config.hpp
│       │   ├── ga_base.hpp
│       │   ├── gp.hpp
│       │   ├── nsga2.hpp
│       │   └── solution_archive.hpp
│       ├── analyzers/
│       │   ├── analyzer_base.hpp
│       │   └── diversity.hpp
│       ├── ceres/
│       │   ├── integer_sequence_algorithm.h
│       │   ├── jet.h
│       │   ├── jet_fwd.h
│       │   ├── jet_traits.h
│       │   ├── port.h
│       │   └── tiny_solver.h
│       ├── collections/
│       │   ├── bitset.hpp
│       │   └── projection.hpp
│       ├── core/
│       │   ├── aligned_allocator.hpp
│       │   ├── buildinfo.hpp.in
│       │   ├── comparison.hpp
│       │   ├── concepts.hpp
│       │   ├── constants.hpp
│       │   ├── contracts.hpp
│       │   ├── dataset.hpp
│       │   ├── dispatch.hpp
│       │   ├── distance.hpp
│       │   ├── individual.hpp
│       │   ├── node.hpp
│       │   ├── operator.hpp
│       │   ├── problem.hpp
│       │   ├── pset.hpp
│       │   ├── range.hpp
│       │   ├── subtree.hpp
│       │   ├── symbol_library.hpp
│       │   ├── tree.hpp
│       │   ├── types.hpp
│       │   ├── variable.hpp
│       │   └── version.hpp
│       ├── error_metrics/
│       │   ├── correlation_coefficient.hpp
│       │   ├── error_metrics.hpp
│       │   ├── mean_absolute_error.hpp
│       │   ├── mean_squared_error.hpp
│       │   ├── normalized_mean_squared_error.hpp
│       │   ├── r2_score.hpp
│       │   ├── root_mean_squared_error.hpp
│       │   └── sum_of_squared_errors.hpp
│       ├── formatter/
│       │   └── formatter.hpp
│       ├── hash/
│       │   ├── hash.hpp
│       │   ├── metrohash64.hpp
│       │   └── zobrist.hpp
│       ├── interpreter/
│       │   ├── backend/
│       │   │   ├── arma/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   └── functions.hpp
│       │   │   ├── arma.hpp
│       │   │   ├── blaze/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   └── functions.hpp
│       │   │   ├── blaze.hpp
│       │   │   ├── eigen/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   └── functions.hpp
│       │   │   ├── eigen.hpp
│       │   │   ├── eve/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   └── functions.hpp
│       │   │   ├── eve.hpp
│       │   │   ├── fast_approx/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   ├── functions.hpp
│       │   │   │   └── impl/
│       │   │   │       ├── aq.hpp
│       │   │   │       ├── exp.hpp
│       │   │   │       ├── inv.hpp
│       │   │   │       ├── log.hpp
│       │   │   │       ├── pow.hpp
│       │   │   │       ├── sqrt.hpp
│       │   │   │       ├── tanh.hpp
│       │   │   │       └── trig.hpp
│       │   │   ├── fast_v1.hpp
│       │   │   ├── fast_v2.hpp
│       │   │   ├── fast_v3.hpp
│       │   │   ├── fastor/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   └── functions.hpp
│       │   │   ├── fastor.hpp
│       │   │   ├── plain/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   └── functions.hpp
│       │   │   ├── plain.hpp
│       │   │   ├── vdt/
│       │   │   │   ├── derivatives.hpp
│       │   │   │   └── functions.hpp
│       │   │   └── vdt.hpp
│       │   ├── derivatives.hpp
│       │   ├── dual.hpp
│       │   ├── functions.hpp
│       │   └── interpreter.hpp
│       ├── mdspan/
│       │   └── mdspan.hpp
│       ├── operators/
│       │   ├── creator.hpp
│       │   ├── crossover.hpp
│       │   ├── evaluator.hpp
│       │   ├── generator.hpp
│       │   ├── initializer.hpp
│       │   ├── local_search.hpp
│       │   ├── mutation.hpp
│       │   ├── non_dominated_sorter.hpp
│       │   ├── reinserter.hpp
│       │   └── selector.hpp
│       ├── optimizer/
│       │   ├── dynamic_cost_function.hpp
│       │   ├── likelihood/
│       │   │   ├── gaussian_likelihood.hpp
│       │   │   ├── likelihood_base.hpp
│       │   │   └── poisson_likelihood.hpp
│       │   ├── lm_cost_function.hpp
│       │   ├── optimizer.hpp
│       │   ├── solvers/
│       │   │   └── sgd.hpp
│       │   └── tiny_cost_function.hpp
│       ├── parser/
│       │   └── infix.hpp
│       └── random/
│           └── random.hpp
├── operon.nix
├── ports/
│   ├── aria-csv/
│   │   ├── portfile.cmake
│   │   └── vcpkg.json
│   ├── fluky/
│   │   ├── portfile.cmake
│   │   └── vcpkg.json
│   ├── infix-parser/
│   │   ├── portfile.cmake
│   │   └── vcpkg.json
│   ├── lbfgs/
│   │   ├── portfile.cmake
│   │   └── vcpkg.json
│   └── vstat/
│       ├── portfile.cmake
│       └── vcpkg.json
├── rtd/
│   ├── build.rst
│   ├── conf.py
│   ├── example.rst
│   ├── features.rst
│   ├── index.rst
│   └── requirements.txt
├── source/
│   ├── algorithms/
│   │   ├── gp.cpp
│   │   ├── nsga2.cpp
│   │   └── solution_archive.cpp
│   ├── core/
│   │   ├── dataset.cpp
│   │   ├── distance.cpp
│   │   ├── node.cpp
│   │   ├── pset.cpp
│   │   ├── tree.cpp
│   │   └── version.cpp
│   ├── formatter/
│   │   ├── dot.cpp
│   │   ├── infix.cpp
│   │   ├── postfix.cpp
│   │   └── tree.cpp
│   ├── hash/
│   │   ├── hash.cpp
│   │   ├── metrohash64.cpp
│   │   └── zobrist.cpp
│   ├── interpreter/
│   │   └── interpreter.cpp
│   ├── operators/
│   │   ├── creator/
│   │   │   ├── balanced.cpp
│   │   │   ├── creator.cpp
│   │   │   ├── koza.cpp
│   │   │   └── ptc2.cpp
│   │   ├── crossover.cpp
│   │   ├── evaluator.cpp
│   │   ├── evaluator_error_metrics.cpp
│   │   ├── generator/
│   │   │   ├── basic.cpp
│   │   │   ├── brood.cpp
│   │   │   ├── os.cpp
│   │   │   └── poly.cpp
│   │   ├── local_search.cpp
│   │   ├── mutation.cpp
│   │   ├── non_dominated_sorter/
│   │   │   ├── best_order_sort.cpp
│   │   │   ├── deductive_sort.cpp
│   │   │   ├── dominance_degree_sort.cpp
│   │   │   ├── efficient_sort.cpp
│   │   │   ├── hierarchical_sort.cpp
│   │   │   ├── merge_sort.cpp
│   │   │   ├── rank_intersect.cpp
│   │   │   └── rank_ordinal.cpp
│   │   └── selector/
│   │       ├── proportional.cpp
│   │       └── tournament.cpp
│   └── parser/
│       └── infix.cpp
├── test/
│   ├── CMakeLists.txt
│   └── source/
│       ├── implementation/
│       │   ├── autodiff.cpp
│       │   ├── crossover.cpp
│       │   ├── details.cpp
│       │   ├── dispatch_table.cpp
│       │   ├── error_metrics.cpp
│       │   ├── evaluation.cpp
│       │   ├── evaluator.cpp
│       │   ├── hashing.cpp
│       │   ├── infix_parser.cpp
│       │   ├── initialization.cpp
│       │   ├── mutation.cpp
│       │   ├── nondominatedsort.cpp
│       │   ├── optimizer.cpp
│       │   ├── random.cpp
│       │   ├── selection.cpp
│       │   └── zobrist.cpp
│       ├── operon_test.cpp
│       ├── operon_test.hpp
│       ├── performance/
│       │   ├── autodiff.cpp
│       │   ├── creator.cpp
│       │   ├── distance.cpp
│       │   ├── evaluation.cpp
│       │   ├── infix_parser.cpp
│       │   └── nondominatedsort.cpp
│       └── thirdparty/
│           ├── elki_stats.hpp
│           └── nanobench.h
├── tools/
│   ├── bench_ndsort.py
│   ├── benchmark_cache.py
│   └── compare_operon.py
└── vcpkg.json

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:

[
  {
    "path": ".clang-format",
    "chars": 3478,
    "preview": "---\nLanguage:        Cpp\n# BasedOnStyle:  WebKit\nAccessModifierOffset: -4\nAlignAfterOpenBracket: DontAlign\nAlignConsecut"
  },
  {
    "path": ".clang-tidy",
    "chars": 6415,
    "preview": "---\n# Enable ALL the things! Except not really\n# misc-non-private-member-variables-in-classes: the options don't do anyt"
  },
  {
    "path": ".codespellrc",
    "chars": 139,
    "preview": "[codespell]\nbuiltin = clear,rare,en-GB_to_en-US,names,informal,code\ncheck-filenames =\ncheck-hidden =\nskip = */.git,*/bui"
  },
  {
    "path": ".envrc",
    "chars": 26,
    "preview": "use flake . --builders ''\n"
  },
  {
    "path": ".github/workflows/build-linux.yml",
    "chars": 1039,
    "preview": "name: build-linux\n\non:\n  push:\n    branches: [ main ]\n  pull_request:\n    branches: [ main ]\n\nenv:\n  # Customize the CMa"
  },
  {
    "path": ".github/workflows/build-macos.yml",
    "chars": 1035,
    "preview": "name: build-macos\n\non:\n  push:\n    branches: [ main ]\n  pull_request:\n    branches: [ main ]\n\nenv:\n  # Customize the CMa"
  },
  {
    "path": ".github/workflows/build-windows.yml",
    "chars": 1356,
    "preview": "name: build-windows\n\non:\n  push:\n    branches: [ main ]\n  pull_request:\n    branches: [ main ]\n\nenv:\n  # Customize the C"
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 4416,
    "preview": "name: Continuous Integration\n\non:\n  push:\n    branches:\n    - main\n\n  pull_request:\n    branches:\n    - main\n\njobs:\n  li"
  },
  {
    "path": ".github/workflows/test-linux.yml",
    "chars": 571,
    "preview": "name: tests\r\n\r\non:\r\n  push:\r\n    branches: [main]\r\n  pull_request:\r\n    branches: [main]\r\n\r\njobs:\r\n  test:\r\n    runs-on:"
  },
  {
    "path": ".gitignore",
    "chars": 178,
    "preview": ".DS_Store\n.idea/\n.vs/\n.vscode/\n.cache/\nbuild*/\ncmake/open-cpp-coverage.cmake\ncmake-build-*/\nprefix/\nCMakeLists.txt.user\n"
  },
  {
    "path": ".readthedocs.yml",
    "chars": 666,
    "preview": "# .readthedocs.yml\n# Read the Docs configuration file\n# See https://docs.readthedocs.io/en/stable/config-file/v2.html fo"
  },
  {
    "path": "BUILDING.md",
    "chars": 2208,
    "preview": "# Building with CMake\n\n## Build\n\nThis project doesn't require any special command-line flags to build to keep\nthings sim"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 9790,
    "preview": "# SPDX-License-Identifier: MIT\n# SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\ncmake_minimum_required(VERSI"
  },
  {
    "path": "CMakePresets.json",
    "chars": 2793,
    "preview": "{\n    \"version\": 6,\n    \"cmakeMinimumRequired\": {\n        \"major\": 3,\n        \"minor\": 23,\n        \"patch\": 0\n    },\n   "
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 131,
    "preview": "# Code of Conduct\n\n* You will be judged by your contributions first, and your sense of humor\n  second.\n* Nobody owes you"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 485,
    "preview": "# Contributing\n\n<!--\n    Short overview, rules, general guidelines, notes about pull requests and\n    style should go he"
  },
  {
    "path": "HACKING.md",
    "chars": 2291,
    "preview": "# Hacking\n\nHere is some wisdom to help you build and test this project as a developer and\npotential contributor.\n\nIf you"
  },
  {
    "path": "LICENSE",
    "chars": 1075,
    "preview": "MIT License\n\nCopyright (c) 2019-2022 Heal Research\n\nPermission is hereby granted, free of charge, to any person obtainin"
  },
  {
    "path": "README.md",
    "chars": 6620,
    "preview": "<picture>\n    <source media=\"(prefers-color-scheme: dark)\" srcset=\"./rtd/_static/logo_mini_dark.png\">\n    <source media="
  },
  {
    "path": "cli/CMakeLists.txt",
    "chars": 1196,
    "preview": "cmake_minimum_required(VERSION 3.20)\n\nproject(operonCli LANGUAGES CXX)\n\ninclude(../cmake/project-is-top-level.cmake)\ninc"
  },
  {
    "path": "cli/source/operator_factory.cpp",
    "chars": 8482,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#include \"operator_factory"
  },
  {
    "path": "cli/source/operator_factory.hpp",
    "chars": 2510,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CLI_OPERATO"
  },
  {
    "path": "cli/source/operon_gp.cpp",
    "chars": 12040,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#include \"reporter.hpp\"\n#i"
  },
  {
    "path": "cli/source/operon_nsgp.cpp",
    "chars": 13506,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#include <chrono>\n#include"
  },
  {
    "path": "cli/source/operon_parse_model.cpp",
    "chars": 8696,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#include <algorithm>\n#incl"
  },
  {
    "path": "cli/source/pareto_front.cpp",
    "chars": 7753,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#include \"pareto_front.hpp"
  },
  {
    "path": "cli/source/pareto_front.hpp",
    "chars": 1009,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CLI_PARETO_"
  },
  {
    "path": "cli/source/reporter.hpp",
    "chars": 8674,
    "preview": "#ifndef OPERON_CLI_REPORTER_HPP\n#define OPERON_CLI_REPORTER_HPP\n\n#include <fmt/format.h>\n#include <operon/algorithms/ga_"
  },
  {
    "path": "cli/source/util.cpp",
    "chars": 11044,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#include <array>\n#include "
  },
  {
    "path": "cli/source/util.hpp",
    "chars": 1010,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CLI_UTIL_HP"
  },
  {
    "path": "cmake/coverage.cmake",
    "chars": 837,
    "preview": "# ---- Variables ----\n\n# We use variables separate from what CTest uses, because those have\n# customization issues\nset(\n"
  },
  {
    "path": "cmake/dev-mode.cmake",
    "chars": 698,
    "preview": "include(CTest)\nif(BUILD_TESTING)\n  add_subdirectory(test)\nendif()\n\noption(BUILD_MCSS_DOCS \"Build documentation using Dox"
  },
  {
    "path": "cmake/docs.cmake",
    "chars": 1462,
    "preview": "# ---- Redefine docs_early_return ----\n\n# This function must be a macro, so the return() takes effect in the calling\n# s"
  },
  {
    "path": "cmake/get-git-revision.cmake",
    "chars": 9508,
    "preview": "# - Returns a version string from Git\n#\n# These functions force a re-configure on each git commit so that you can\n# trus"
  },
  {
    "path": "cmake/get-git-revision.cmake.in",
    "chars": 1354,
    "preview": "#\n# Internal file for GetGitRevisionDescription.cmake\n#\n# Requires CMake 2.6 or newer (uses the 'function' command)\n#\n# "
  },
  {
    "path": "cmake/install-config.cmake",
    "chars": 846,
    "preview": "include(CMakeFindDependencyMacro)\n\n# PUBLIC dependencies\nfind_dependency(Eigen3 CONFIG REQUIRED)\nfind_dependency(Threads"
  },
  {
    "path": "cmake/install-rules.cmake",
    "chars": 1574,
    "preview": "if(PROJECT_IS_TOP_LEVEL)\n  set(CMAKE_INSTALL_INCLUDEDIR include/operon CACHE PATH \"\")\nendif()\n\ninclude(CMakePackageConfi"
  },
  {
    "path": "cmake/lint-targets.cmake",
    "chars": 874,
    "preview": "set(\n    FORMAT_PATTERNS\n    source/*.cpp source/*.hpp\n    include/*.hpp\n    test/*.cpp test/*.hpp\n    example/*.cpp exa"
  },
  {
    "path": "cmake/lint.cmake",
    "chars": 1337,
    "preview": "cmake_minimum_required(VERSION 3.14)\n\nmacro(default name)\n  if(NOT DEFINED \"${name}\")\n    set(\"${name}\" \"${ARGN}\")\n  end"
  },
  {
    "path": "cmake/open-cpp-coverage.cmake.example",
    "chars": 1170,
    "preview": "# Example file to run OpenCppCoverage on Windows\n\ninclude(ProcessorCount)\nProcessorCount(N)\n\nfile(MAKE_DIRECTORY \"${PROJ"
  },
  {
    "path": "cmake/prelude.cmake",
    "chars": 520,
    "preview": "# ---- In-source guard ----\n\nif(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)\n  message(\n      FATAL_ERROR\n      \"In-sourc"
  },
  {
    "path": "cmake/project-is-top-level.cmake",
    "chars": 154,
    "preview": "# This variable is set by project() in CMake 3.21+\nstring(\n    COMPARE EQUAL\n    \"${CMAKE_SOURCE_DIR}\" \"${PROJECT_SOURCE"
  },
  {
    "path": "cmake/spell-targets.cmake",
    "chars": 581,
    "preview": "set(SPELL_COMMAND codespell CACHE STRING \"Spell checker to use\")\n\nadd_custom_target(\n    spell-check\n    COMMAND \"${CMAK"
  },
  {
    "path": "cmake/spell.cmake",
    "chars": 657,
    "preview": "cmake_minimum_required(VERSION 3.14)\n\nmacro(default name)\n  if(NOT DEFINED \"${name}\")\n    set(\"${name}\" \"${ARGN}\")\n  end"
  },
  {
    "path": "cmake/variables.cmake",
    "chars": 2993,
    "preview": "# ---- Developer mode ----\n\n# Developer mode enables targets and code paths in the CMake scripts that are\n# only relevan"
  },
  {
    "path": "cmake/windows-set-path.cmake",
    "chars": 793,
    "preview": "# This function will add shared libraries to the PATH when running the test, so\n# they can be found. Windows does not su"
  },
  {
    "path": "data/AirfoilSelfNoise.csv",
    "chars": 60002,
    "preview": "X1,X2,X3,X4,X5,Y\r\n800,0,0.3048,71.3,0.00266337,126.201\r\n1000,0,0.3048,71.3,0.00266337,125.201\r\n1250,0,0.3048,71.3,0.0026"
  },
  {
    "path": "data/AirfoilSelfNoise.json",
    "chars": 408,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Airfoil Self-Noise\",\n        \"filename\": \"AirfoilSelfNoise.csv\",\n        \"formula\":"
  },
  {
    "path": "data/Breiman-I.csv",
    "chars": 420824,
    "preview": "X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,Y\r\n-1,1,-1,0,0,1,-1,0,-1,0,-1.64046046120892\r\n1,0,1,0,0,-1,-1,1,1,-1,2.01080532985597\r\n-1"
  },
  {
    "path": "data/Breiman-I.json",
    "chars": 392,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Breiman-I\",\n        \"filename\": \"Breiman-I.csv\",\n        \"formula\": \"\",\n        \"ki"
  },
  {
    "path": "data/Chemical-I.csv",
    "chars": 2176330,
    "preview": "x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,target\n28.0784464518229,13.93"
  },
  {
    "path": "data/Chemical-I.json",
    "chars": 400,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Chemical-I\",\n        \"filename\": \"Chemical-I.csv\",\n        \"formula\": \"\",\n        \""
  },
  {
    "path": "data/Chemical-II.csv",
    "chars": 478655,
    "preview": "x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x"
  },
  {
    "path": "data/Chemical-II.json",
    "chars": 399,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Chemical-II\",\n        \"filename\": \"Chemical-II.csv\",\n        \"formula\": \"\",\n       "
  },
  {
    "path": "data/Concrete.csv",
    "chars": 41375,
    "preview": "X1,X2,X3,X4,X5,X6,X7,X8,Y\r\n540,0,0,162,2.5,1040,676,28,79.99\r\n540,0,0,162,2.5,1055,676,28,61.89\r\n332.5,142.5,0,228,0,932"
  },
  {
    "path": "data/Concrete.json",
    "chars": 410,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Concrete Compressive Strength\",\n        \"filename\": \"Concrete.csv\",\n        \"formul"
  },
  {
    "path": "data/Flow_stress.csv",
    "chars": 153614,
    "preview": "T,phi_1000,target\n200,0,0\n200,1,15.06770756\n200,2,32.92914271\n200,3,49.05083984\n200,4,59.39326183\n200,5,68.41416898\n200,"
  },
  {
    "path": "data/Flow_stress.json",
    "chars": 402,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Flow-stress\",\n        \"filename\": \"Flow_stress.csv\",\n        \"formula\": \"\",\n       "
  },
  {
    "path": "data/FrictionDyn-OneHot.csv",
    "chars": 108960,
    "preview": "p_rel,v_rel,T_0,target,exp_a,exp_b,exp_c,exp_d,exp_e,exp_f,exp_g,exp_h,exp_i,exp_j,exp_k,exp_l,exp_m,exp_n\n0.2863,0.262,"
  },
  {
    "path": "data/FrictionDyn-OneHot.json",
    "chars": 416,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"FrictionDyn-OneHot\",\n        \"filename\": \"FrictionDyn-OneHot.csv\",\n        \"formula"
  },
  {
    "path": "data/FrictionStat-OneHot.csv",
    "chars": 96858,
    "preview": "p_rel,T_0,target,exp_a,exp_b,exp_c,exp_d,exp_e,exp_f,exp_g,exp_h,exp_i,exp_j,exp_k,exp_l,exp_m,exp_n\n0.2863,18.1,0.09768"
  },
  {
    "path": "data/FrictionStat-OneHot.json",
    "chars": 418,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"FrictionStat-OneHot\",\n        \"filename\": \"FrictionStat-OneHot.csv\",\n        \"formu"
  },
  {
    "path": "data/Friedman-I.csv",
    "chars": 1978975,
    "preview": "X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,Y\r\n0.236619971747654,0.600080705620367,0.487644763544119,0.296937824528883,0.020660492130"
  },
  {
    "path": "data/Friedman-I.json",
    "chars": 394,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Friedman-I\",\n        \"filename\": \"Friedman-I.csv\",\n        \"formula\": \"\",\n        \""
  },
  {
    "path": "data/Friedman-II.csv",
    "chars": 1979027,
    "preview": "X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,Y\r\n0.726927566744137,0.81838005776945,0.021370209758489,0.430856247765677,0.1507603458945"
  },
  {
    "path": "data/Friedman-II.json",
    "chars": 396,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Friedman-II\",\n        \"filename\": \"Friedman-II.csv\",\n        \"formula\": \"\",\n       "
  },
  {
    "path": "data/GP-Challenge.csv",
    "chars": 7547749,
    "preview": "T1,T2,T3,T4,T5,T6,T7,T8,rank,RMSD,energy\r\n-7.58,-187.84,-167.04,-126.5692594,43.54275172,68.1772,170.5913573,107.81,957,"
  },
  {
    "path": "data/GP-Challenge.json",
    "chars": 405,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"GP-Challenge\",\n        \"filename\": \"GP-Challenge.csv\",\n        \"formula\": \"\",\n     "
  },
  {
    "path": "data/NasaBattery-1_10min.csv",
    "chars": 73068,
    "preview": "dischargeCycles,initialCapacity,Voltage0,DeltaVoltage3,Voltage10,Temperature10,target\n1,1.8564874208181574,4.19149180750"
  },
  {
    "path": "data/NasaBattery-1_10min.json",
    "chars": 417,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Nasa Battery 1h 10min\",\n        \"filename\": \"NasaBattery-1_10min.csv\",\n        \"for"
  },
  {
    "path": "data/NasaBattery-2_20min.csv",
    "chars": 157687,
    "preview": "dischargeCycles,initialCapacity,Voltage20,AvgCurrent20,AvgTemp20,target\n2,1.8518025516704486,3.6234948625001504,-2.02399"
  },
  {
    "path": "data/NasaBattery-2_20min.json",
    "chars": 420,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Nasa Battery 2h 20min\",\n        \"filename\": \"NasaBattery-2_20min.csv\",\n        \"for"
  },
  {
    "path": "data/Nikuradse_1.csv",
    "chars": 5600,
    "preview": "r_k,log_Re,target\n507,4.114,0.456\n507,4.23,0.438\n507,4.322,0.417\n507,4.362,0.407\n507,4.362,0.403\n507,4.462,0.381\n507,4.4"
  },
  {
    "path": "data/Nikuradse_1.json",
    "chars": 399,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Nikuradse-I\",\n        \"filename\": \"Nikuradse_1.csv\",\n        \"formula\": \"\",\n       "
  },
  {
    "path": "data/Nikuradse_2.csv",
    "chars": 4032,
    "preview": "log_v_k_nu,target\n1.511,1.94\n2.608,1.74\n1.394,1.91\n1.519,1.78\n1.49665,1.93\n3.255,1.72\n0.33686,1.33\n1.38,2.02\n1.993,1.73\n"
  },
  {
    "path": "data/Nikuradse_2.json",
    "chars": 400,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Nikuradse-II\",\n        \"filename\": \"Nikuradse_2.csv\",\n        \"formula\": \"\",\n      "
  },
  {
    "path": "data/Pagie-1.csv",
    "chars": 70806,
    "preview": "X,Y,F\r\n-5,-5,1.99680511182109\r\n-5,-4.6,1.99617412180445\r\n-5,-4.2,1.99519916903367\r\n-5,-3.8,1.9936295960645\r\n-5,-3.4,1.99"
  },
  {
    "path": "data/Pagie-1.json",
    "chars": 437,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Spatial Coevolution\",\n        \"filename\": \"Pagie-1.csv\",\n        \"formula\": \"F(x,y)"
  },
  {
    "path": "data/Poly-10.csv",
    "chars": 102300,
    "preview": "X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,Y\r\n-0.996123041491053,-0.342333388361692,-0.585257368531371,-0.0186943437481984,-0.306348"
  },
  {
    "path": "data/Poly-10.json",
    "chars": 384,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Poly-10\",\n        \"filename\": \"Poly-10.csv\",\n        \"formula\": \"\",\n        \"kind\":"
  },
  {
    "path": "data/Sextic.csv",
    "chars": 95624,
    "preview": "X,Y\n-0.97789,0.00182882\n-0.93914,0.012284\n-0.898858,0.0298011\n-0.850502,0.0553608\n-0.80849,0.0784088\n-0.784378,0.0910774"
  },
  {
    "path": "data/Sextic.json",
    "chars": 382,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Sextic\",\n        \"filename\": \"Sextic.csv\",\n        \"formula\": \"\",\n        \"kind\": \""
  },
  {
    "path": "data/Vladislavleva-1.csv",
    "chars": 61106,
    "preview": "X1,X2,Y\r\n2.85610608401618,0.360281924661315,0.00552067309875047\r\n1.19774234578892,2.30787014234994,0.777461224626437\r\n0."
  },
  {
    "path": "data/Vladislavleva-1.json",
    "chars": 451,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-1\",\n        \"filename\": \"Vladislavleva-1.csv\",\n        \"formula\": \"F1"
  },
  {
    "path": "data/Vladislavleva-2.csv",
    "chars": 7942,
    "preview": "X,Y\r\n0.05,-5.92047290537525E-06\r\n0.15,-0.000419749007439608\r\n0.25,-0.00274401196221596\r\n0.35,-0.00865712869883085\r\n0.45,"
  },
  {
    "path": "data/Vladislavleva-2.json",
    "chars": 460,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-2\",\n        \"filename\": \"Vladislavleva-2.csv\",\n        \"formula\": \"F2"
  },
  {
    "path": "data/Vladislavleva-3.csv",
    "chars": 152659,
    "preview": "X1,X2,Y\r\n0.05,0.05,2.93063408816075E-05\r\n0.05,2.05,1.7465395070857E-05\r\n0.05,4.05,5.62444926010648E-06\r\n0.05,6.05,-6.216"
  },
  {
    "path": "data/Vladislavleva-3.json",
    "chars": 480,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-3\",\n        \"filename\": \"Vladislavleva-3.csv\",\n        \"formula\": \"F3"
  },
  {
    "path": "data/Vladislavleva-4.csv",
    "chars": 629721,
    "preview": "X1,X2,X3,X4,X5,Y\r\n0.449094023834703,2.07673772769671,3.05001488276758,0.90014683400517,3.06119295670911,0.59611936162968"
  },
  {
    "path": "data/Vladislavleva-4.json",
    "chars": 453,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-4\",\n        \"filename\": \"Vladislavleva-4.csv\",\n        \"formula\": \"F4"
  },
  {
    "path": "data/Vladislavleva-5.csv",
    "chars": 105065,
    "preview": "X1,X2,X3,Y\r\n0.533650793387473,1.90948500482121,0.488797764524072,-0.207209763781291\r\n1.40375737780793,1.39874084047013,1"
  },
  {
    "path": "data/Vladislavleva-5.json",
    "chars": 463,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-5\",\n        \"filename\": \"Vladislavleva-5.csv\",\n        \"formula\": \"F5"
  },
  {
    "path": "data/Vladislavleva-6.csv",
    "chars": 2691847,
    "preview": "X1,X2,Y\r\n1.01584214026012,1.61989856211466,-0.250298572687778\r\n3.87612407993901,4.76313587247001,-0.203987843788056\r\n3.3"
  },
  {
    "path": "data/Vladislavleva-6.json",
    "chars": 434,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-6\",\n        \"filename\": \"Vladislavleva-6.csv\",\n        \"formula\": \"F6"
  },
  {
    "path": "data/Vladislavleva-7.csv",
    "chars": 68753,
    "preview": "X1,X2,Y\r\n1.97649262024241,5.33710876388641,-3.23657921858249\r\n5.22873620409023,2.65913343369242,-2.75381015612599\r\n5.809"
  },
  {
    "path": "data/Vladislavleva-7.json",
    "chars": 458,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-7\",\n        \"filename\": \"Vladislavleva-7.csv\",\n        \"formula\": \"F7"
  },
  {
    "path": "data/Vladislavleva-8.csv",
    "chars": 36443,
    "preview": "X1,X2,Y\r\n4.42333200694372,6.01606719632774,0.10559134469785\r\n1.27750320640102,2.68184236191023,0.88967188760059\r\n0.73136"
  },
  {
    "path": "data/Vladislavleva-8.json",
    "chars": 466,
    "preview": "{\n    \"metadata\": {\n        \"name\": \"Vladislavleva-8\",\n        \"filename\": \"Vladislavleva-8.csv\",\n        \"formula\": \"F8"
  },
  {
    "path": "docs/Doxyfile.in",
    "chars": 1069,
    "preview": "# Configuration for Doxygen for use with CMake\n# Only options that deviate from the default are included\n# To create a n"
  },
  {
    "path": "docs/conf.py.in",
    "chars": 113,
    "preview": "DOXYFILE = 'Doxyfile'\n\nLINKS_NAVBAR1 = [\n    (None, 'pages', [(None, 'about')]),\n    (None, 'namespaces', []),\n]\n"
  },
  {
    "path": "docs/pages/about.dox",
    "chars": 269,
    "preview": "/**\n * @page about About\n * @section about-doxygen Doxygen documentation\n * This page is auto generated using\n * <a href"
  },
  {
    "path": "example/CMakeLists.txt",
    "chars": 666,
    "preview": "cmake_minimum_required(VERSION 3.14)\n\nproject(operonExamples CXX)\n\ninclude(../cmake/project-is-top-level.cmake)\ninclude("
  },
  {
    "path": "example/custom_primitives.cpp",
    "chars": 7798,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n//\n// Demonstration: symbol"
  },
  {
    "path": "example/empty_example.cpp",
    "chars": 35,
    "preview": "auto main() -> int\n{\n  return 0;\n}\n"
  },
  {
    "path": "flake.nix",
    "chars": 4117,
    "preview": "{\n  description = \"Operon development environment\";\n\n  inputs = {\n    flake-parts.url = \"github:hercules-ci/flake-parts\""
  },
  {
    "path": "include/operon/algorithms/config.hpp",
    "chars": 930,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_ALGORITHM_C"
  },
  {
    "path": "include/operon/algorithms/ga_base.hpp",
    "chars": 4317,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef GA_BASE_HPP\n#defin"
  },
  {
    "path": "include/operon/algorithms/gp.hpp",
    "chars": 1574,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef GP_HPP\n#define GP_"
  },
  {
    "path": "include/operon/algorithms/nsga2.hpp",
    "chars": 2518,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_NSGA2_HPP\n#"
  },
  {
    "path": "include/operon/algorithms/solution_archive.hpp",
    "chars": 712,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_SOLUTION_AR"
  },
  {
    "path": "include/operon/analyzers/analyzer_base.hpp",
    "chars": 392,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_ANALYZER_BA"
  },
  {
    "path": "include/operon/analyzers/diversity.hpp",
    "chars": 1890,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef DIVERSITY_HPP\n#def"
  },
  {
    "path": "include/operon/ceres/integer_sequence_algorithm.h",
    "chars": 11421,
    "preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2022 Google Inc. All rights reserved.\n// http:/"
  },
  {
    "path": "include/operon/ceres/jet.h",
    "chars": 50731,
    "preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2022 Google Inc. All rights reserved.\n// http:/"
  },
  {
    "path": "include/operon/ceres/jet_fwd.h",
    "chars": 1994,
    "preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2022 Google Inc. All rights reserved.\n// http:/"
  },
  {
    "path": "include/operon/ceres/jet_traits.h",
    "chars": 7148,
    "preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2022 Google Inc. All rights reserved.\n// http:/"
  },
  {
    "path": "include/operon/ceres/port.h",
    "chars": 3682,
    "preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2022 Google Inc. All rights reserved.\n// http:/"
  },
  {
    "path": "include/operon/ceres/tiny_solver.h",
    "chars": 14311,
    "preview": "// Ceres Solver - A fast non-linear least squares minimizer\n// Copyright 2021 Google Inc. All rights reserved.\n// http:/"
  },
  {
    "path": "include/operon/collections/bitset.hpp",
    "chars": 3274,
    "preview": "#ifndef OPERON_BITSET_HPP\n#define OPERON_BITSET_HPP\n\n#include <bit>\n#include <cstddef>\n#include <cstdint>\n#include <util"
  },
  {
    "path": "include/operon/collections/projection.hpp",
    "chars": 3791,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_PROJECTION_"
  },
  {
    "path": "include/operon/core/aligned_allocator.hpp",
    "chars": 2068,
    "preview": "#ifndef OPERON_ALIGNED_ALLOCATOR_HPP\n#define OPERON_ALIGNED_ALLOCATOR_HPP\n\n#include <cstddef>\n#include <limits>\n#include"
  },
  {
    "path": "include/operon/core/buildinfo.hpp.in",
    "chars": 913,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BUILDINFO_H"
  },
  {
    "path": "include/operon/core/comparison.hpp",
    "chars": 4230,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_COMPARISON_"
  },
  {
    "path": "include/operon/core/concepts.hpp",
    "chars": 280,
    "preview": "#ifndef OPERON_CONCEPTS_HPP\n#define OPERON_CONCEPTS_HPP\n\n#include <concepts>\n#include <type_traits>\n\nnamespace Operon::C"
  },
  {
    "path": "include/operon/core/constants.hpp",
    "chars": 1900,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CONSTANTS_H"
  },
  {
    "path": "include/operon/core/contracts.hpp",
    "chars": 323,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CONTRACTS_H"
  },
  {
    "path": "include/operon/core/dataset.hpp",
    "chars": 5298,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef DATASET_H\n#define "
  },
  {
    "path": "include/operon/core/dispatch.hpp",
    "chars": 14867,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_EVAL_DETAIL"
  },
  {
    "path": "include/operon/core/distance.hpp",
    "chars": 549,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_DISTANCE_HP"
  },
  {
    "path": "include/operon/core/individual.hpp",
    "chars": 2943,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_INDIVIDUAL_"
  },
  {
    "path": "include/operon/core/node.hpp",
    "chars": 7261,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CORE_NODE_H"
  },
  {
    "path": "include/operon/core/operator.hpp",
    "chars": 889,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_OPERATOR_HP"
  },
  {
    "path": "include/operon/core/problem.hpp",
    "chars": 4611,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef PROBLEM_HPP\n#defin"
  },
  {
    "path": "include/operon/core/pset.hpp",
    "chars": 8477,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_PSET_HPP\n#d"
  },
  {
    "path": "include/operon/core/range.hpp",
    "chars": 1430,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_RANGE_HPP\n#"
  },
  {
    "path": "include/operon/core/subtree.hpp",
    "chars": 4655,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_SUBTREE_HPP"
  },
  {
    "path": "include/operon/core/symbol_library.hpp",
    "chars": 11084,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_SYMBOL_LIBR"
  },
  {
    "path": "include/operon/core/tree.hpp",
    "chars": 4737,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef TREE_HPP\n#define T"
  },
  {
    "path": "include/operon/core/types.hpp",
    "chars": 3267,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_TYPES_HPP\n#"
  },
  {
    "path": "include/operon/core/variable.hpp",
    "chars": 598,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_VARIABLE_HP"
  },
  {
    "path": "include/operon/core/version.hpp",
    "chars": 359,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_VERSION_HPP"
  },
  {
    "path": "include/operon/error_metrics/correlation_coefficient.hpp",
    "chars": 3243,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_METRICS_COR"
  },
  {
    "path": "include/operon/error_metrics/error_metrics.hpp",
    "chars": 570,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_ERROR_METRI"
  },
  {
    "path": "include/operon/error_metrics/mean_absolute_error.hpp",
    "chars": 2491,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_METRICS_MEA"
  },
  {
    "path": "include/operon/error_metrics/mean_squared_error.hpp",
    "chars": 2424,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_METRICS_MEA"
  },
  {
    "path": "include/operon/error_metrics/normalized_mean_squared_error.hpp",
    "chars": 2404,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_METRICS_NOR"
  },
  {
    "path": "include/operon/error_metrics/r2_score.hpp",
    "chars": 2764,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_METRICS_R2_"
  },
  {
    "path": "include/operon/error_metrics/root_mean_squared_error.hpp",
    "chars": 1235,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_METRICS_ROO"
  },
  {
    "path": "include/operon/error_metrics/sum_of_squared_errors.hpp",
    "chars": 2445,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_METRICS_SUM"
  },
  {
    "path": "include/operon/formatter/formatter.hpp",
    "chars": 2019,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_FORMAT_HPP\n"
  },
  {
    "path": "include/operon/hash/hash.hpp",
    "chars": 741,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_HASH_HPP\n#d"
  },
  {
    "path": "include/operon/hash/metrohash64.hpp",
    "chars": 1767,
    "preview": "// SPDX-License-Identifier: Apache-2.0\n// SPDX-FileCopyrightText: Copyright 2015-2018 J. Andrew Rogers\n\n#ifndef METROHAS"
  },
  {
    "path": "include/operon/hash/zobrist.hpp",
    "chars": 3050,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_HASH_ZOBRIS"
  },
  {
    "path": "include/operon/interpreter/backend/arma/derivatives.hpp",
    "chars": 9971,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_ARM"
  },
  {
    "path": "include/operon/interpreter/backend/arma/functions.hpp",
    "chars": 6966,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_ARM"
  },
  {
    "path": "include/operon/interpreter/backend/arma.hpp",
    "chars": 198,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_ARM"
  },
  {
    "path": "include/operon/interpreter/backend/blaze/derivatives.hpp",
    "chars": 10241,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_BLA"
  },
  {
    "path": "include/operon/interpreter/backend/blaze/functions.hpp",
    "chars": 7313,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_BLA"
  },
  {
    "path": "include/operon/interpreter/backend/blaze.hpp",
    "chars": 201,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_BLA"
  },
  {
    "path": "include/operon/interpreter/backend/eigen/derivatives.hpp",
    "chars": 10016,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_EIG"
  },
  {
    "path": "include/operon/interpreter/backend/eigen/functions.hpp",
    "chars": 7252,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_EIG"
  },
  {
    "path": "include/operon/interpreter/backend/eigen.hpp",
    "chars": 201,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_EIG"
  },
  {
    "path": "include/operon/interpreter/backend/eve/derivatives.hpp",
    "chars": 15764,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_EVE"
  },
  {
    "path": "include/operon/interpreter/backend/eve/functions.hpp",
    "chars": 10971,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_EVE"
  },
  {
    "path": "include/operon/interpreter/backend/eve.hpp",
    "chars": 195,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_EVE"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/derivatives.hpp",
    "chars": 13451,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_FAS"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/functions.hpp",
    "chars": 9194,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_fas"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/aq.hpp",
    "chars": 521,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_AQ_HPP\n#define OPERON_BACKEND_FAST_APPROX_AQ_HPP\n\n#include \"operon/core/types.hpp\"\n#i"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/exp.hpp",
    "chars": 2381,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_EXP_HPP\n#define OPERON_BACKEND_FAST_APPROX_EXP_HPP\n\n#include \"operon/core/types.hpp\"\n"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/inv.hpp",
    "chars": 2234,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_INV_HPP\n#define OPERON_BACKEND_FAST_APPROX_INV_HPP\n\n#include \"operon/core/types.hpp\"\n"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/log.hpp",
    "chars": 1661,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_LOG_HPP\n#define OPERON_BACKEND_FAST_APPROX_LOG_HPP\n\n#include \"operon/core/types.hpp\"\n"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/pow.hpp",
    "chars": 2386,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_POW_HPP\n#define OPERON_BACKEND_FAST_APPROX_POW_HPP\n\n#include \"inv.hpp\"\n#include \"exp."
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/sqrt.hpp",
    "chars": 1938,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_SQRT_HPP\n#define OPERON_BACKEND_FAST_APPROX_SQRT_HPP\n\n#include \"operon/core/types.hpp"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/tanh.hpp",
    "chars": 1635,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_TANH_HPP\n#define OPERON_BACKEND_FAST_APPROX_TANH_HPP\n\n#include \"operon/core/types.hpp"
  },
  {
    "path": "include/operon/interpreter/backend/fast_approx/impl/trig.hpp",
    "chars": 2173,
    "preview": "#ifndef OPERON_BACKEND_FAST_APPROX_TRIG_HPP\n#define OPERON_BACKEND_FAST_APPROX_TRIG_HPP\n\n#include \"operon/core/types.hpp"
  },
  {
    "path": "include/operon/interpreter/backend/fast_v1.hpp",
    "chars": 255,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_FAS"
  },
  {
    "path": "include/operon/interpreter/backend/fast_v2.hpp",
    "chars": 255,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_FAS"
  },
  {
    "path": "include/operon/interpreter/backend/fast_v3.hpp",
    "chars": 255,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_FAS"
  },
  {
    "path": "include/operon/interpreter/backend/fastor/derivatives.hpp",
    "chars": 10556,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_FAS"
  },
  {
    "path": "include/operon/interpreter/backend/fastor/functions.hpp",
    "chars": 6585,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_FAS"
  },
  {
    "path": "include/operon/interpreter/backend/fastor.hpp",
    "chars": 204,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_FAS"
  },
  {
    "path": "include/operon/interpreter/backend/plain/derivatives.hpp",
    "chars": 13147,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_PLA"
  },
  {
    "path": "include/operon/interpreter/backend/plain/functions.hpp",
    "chars": 7029,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_PLA"
  },
  {
    "path": "include/operon/interpreter/backend/plain.hpp",
    "chars": 201,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_PLA"
  },
  {
    "path": "include/operon/interpreter/backend/vdt/derivatives.hpp",
    "chars": 13247,
    "preview": "#ifndef OPERON_BACKEND_VDT_DERIVATIVES_HPP\n#define OPERON_BACKEND_VDT_DERIVATIVES_HPP\n\n#include \"functions.hpp\"\n\nnamespa"
  },
  {
    "path": "include/operon/interpreter/backend/vdt/functions.hpp",
    "chars": 14480,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_BACKEND_VDT"
  },
  {
    "path": "include/operon/interpreter/backend/vdt.hpp",
    "chars": 195,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_BACKEND_VDT"
  },
  {
    "path": "include/operon/interpreter/derivatives.hpp",
    "chars": 10145,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_INTERPRETER"
  },
  {
    "path": "include/operon/interpreter/dual.hpp",
    "chars": 429,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_AUTODIFF_FO"
  },
  {
    "path": "include/operon/interpreter/functions.hpp",
    "chars": 16022,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_INTERPRETER"
  },
  {
    "path": "include/operon/interpreter/interpreter.hpp",
    "chars": 13176,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_INTERPRETER"
  },
  {
    "path": "include/operon/mdspan/mdspan.hpp",
    "chars": 8091,
    "preview": "#ifndef OPERON_MDSPAN_HPP\n#define OPERON_MDSPAN_HPP\n\n#define MDSPAN_IMPL_STANDARD_NAMESPACE std\n#define MDSPAN_IMPL_PROP"
  },
  {
    "path": "include/operon/operators/creator.hpp",
    "chars": 3932,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CREATOR_HPP"
  },
  {
    "path": "include/operon/operators/crossover.hpp",
    "chars": 1912,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_CROSSOVER_H"
  },
  {
    "path": "include/operon/operators/evaluator.hpp",
    "chars": 26728,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_EVALUATOR_H"
  },
  {
    "path": "include/operon/operators/generator.hpp",
    "chars": 9757,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_GENERATOR_H"
  },
  {
    "path": "include/operon/operators/initializer.hpp",
    "chars": 3282,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_INITIALIZER"
  },
  {
    "path": "include/operon/operators/local_search.hpp",
    "chars": 867,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2024 Heal Research\n\n#ifndef OPERON_LOCAL_SEARC"
  },
  {
    "path": "include/operon/operators/mutation.hpp",
    "chars": 5448,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_MUTATION_HP"
  },
  {
    "path": "include/operon/operators/non_dominated_sorter.hpp",
    "chars": 3190,
    "preview": "// SPDX-License-Identifier: MIT\n// SPDX-FileCopyrightText: Copyright 2019-2023 Heal Research\n\n#ifndef OPERON_OPERATORS_N"
  }
]

// ... and 101 more files (download for full content)