Copy disabled (too large)
Download .txt
Showing preview only (43,226K chars total). Download the full file to get everything.
Repository: aardvark-platform/aardvark.base
Branch: master
Commit: 011bd5bb9187
Files: 804
Total size: 41.1 MB
Directory structure:
gitextract_19g_u3m2/
├── .claude/
│ └── CLAUDE.md
├── .config/
│ └── dotnet-tools.json
├── .github/
│ └── workflows/
│ ├── build.yml
│ ├── docs-check.yml
│ └── publish.yml
├── .gitignore
├── .vscode/
│ ├── settings.json
│ └── tasks.json
├── AGENTS.md
├── LICENSE
├── PACKAGES.md
├── README.md
├── RELEASE_NOTES.md
├── ai/
│ ├── ALGORITHMS.md
│ ├── COLLECTIONS.md
│ ├── DOC_ACCURACY_AUDIT.md
│ ├── FSHARP_INTEROP.md
│ ├── INCREMENTAL.md
│ ├── PIXIMAGE.md
│ ├── PRIMITIVE_TYPES.md
│ ├── README.md
│ ├── RECIPE_AI_FRIENDLINESS.md
│ ├── SEMANTICS_GEOMETRY_CORE.md
│ ├── SEMANTICS_LINEAR_ALGEBRA.md
│ ├── SERIALIZATION.md
│ ├── SYMBOL_INDEX.md
│ ├── TENSORS.md
│ └── UTILITIES.md
├── build.cmd
├── build.sh
├── check-docs.cmd
├── check-docs.sh
├── generate.cmd
├── generate.sh
├── global.json
├── paket.dependencies
├── src/
│ ├── Aardvark.Base/
│ │ ├── Aardvark.Base.csproj
│ │ ├── AlgoDat/
│ │ │ ├── AdaBoost.cs
│ │ │ ├── ConcurrentHashSet.cs
│ │ │ ├── ExtendedCore/
│ │ │ │ ├── BitHelpers.cs
│ │ │ │ └── SortedSetExt.cs
│ │ │ ├── INode.cs
│ │ │ ├── LruCache.cs
│ │ │ ├── Meta.cs
│ │ │ ├── MinimumSpanningTree.cs
│ │ │ ├── SalesmanOfDeath.cs
│ │ │ ├── ShortestPath.cs
│ │ │ └── Span.cs
│ │ ├── Delegates/
│ │ │ ├── Delegates.cs
│ │ │ ├── Delegates_auto.cs
│ │ │ ├── Delegates_template.cs
│ │ │ └── HigherOrderFunctions.cs
│ │ ├── Extensions/
│ │ │ ├── ArrayExtensions.cs
│ │ │ ├── CastExtensions.cs
│ │ │ ├── DagExtensions.cs
│ │ │ ├── DateTimeExtensions.cs
│ │ │ ├── DictionaryExtensions.cs
│ │ │ ├── EnumHelpers.cs
│ │ │ ├── EventHandlerExtensions.cs
│ │ │ ├── FuncActionExtensions.cs
│ │ │ ├── FuncActionExtensions_auto.cs
│ │ │ ├── FuncActionExtensions_template.cs
│ │ │ ├── HigherOrderFunctions.cs
│ │ │ ├── ICollectionExtensions.cs
│ │ │ ├── IEnumerableExtensions.cs
│ │ │ ├── IListExtensions.cs
│ │ │ ├── IsExternalInit.cs
│ │ │ ├── ListExtensions.cs
│ │ │ ├── NonGenericArray.cs
│ │ │ ├── SequenceExtensions_auto.cs
│ │ │ ├── SequenceExtensions_template.cs
│ │ │ ├── StreamExtensions.cs
│ │ │ ├── StringExtensions.cs
│ │ │ ├── Structs.cs
│ │ │ ├── SubRange.cs
│ │ │ ├── SystemDrawingExtensions.cs
│ │ │ ├── TupleExtensions.cs
│ │ │ ├── TypeExtensions.cs
│ │ │ └── VariousExtensions.cs
│ │ ├── Geodesy/
│ │ │ ├── GeoConsts.cs
│ │ │ └── GeoConversion.cs
│ │ ├── Geometry/
│ │ │ ├── Algorithms_auto.cs
│ │ │ ├── Algorithms_template.cs
│ │ │ ├── BbTree.cs
│ │ │ ├── ClippingFunctions_auto.cs
│ │ │ ├── ClippingFunctions_template.cs
│ │ │ ├── Interfaces/
│ │ │ │ ├── IBoundingBox_auto.cs
│ │ │ │ ├── IBoundingBox_template.cs
│ │ │ │ ├── IBoundingCircle.cs
│ │ │ │ ├── IBoundingSphere.cs
│ │ │ │ ├── IImmutablePolygon.cs
│ │ │ │ └── IPolygon.cs
│ │ │ ├── IntersectionTests_auto.cs
│ │ │ ├── IntersectionTests_template.cs
│ │ │ ├── Relations/
│ │ │ │ ├── LinearCombination_auto.cs
│ │ │ │ ├── LinearCombination_template.cs
│ │ │ │ ├── Orthogonality_auto.cs
│ │ │ │ ├── Orthogonality_template.cs
│ │ │ │ ├── Parallelism_auto.cs
│ │ │ │ ├── Parallelism_template.cs
│ │ │ │ ├── SubPrimitives_auto.cs
│ │ │ │ └── SubPrimitives_template.cs
│ │ │ ├── SpecialPoints_auto.cs
│ │ │ ├── SpecialPoints_template.cs
│ │ │ └── Types/
│ │ │ ├── Capsule/
│ │ │ │ ├── Capsule3_auto.cs
│ │ │ │ └── Capsule3_template.cs
│ │ │ ├── Circle/
│ │ │ │ ├── Circle2_auto.cs
│ │ │ │ ├── Circle2_template.cs
│ │ │ │ ├── Circle3_auto.cs
│ │ │ │ └── Circle3_template.cs
│ │ │ ├── Cone/
│ │ │ │ ├── Cone3_auto.cs
│ │ │ │ ├── Cone3_template.cs
│ │ │ │ ├── Conic2_auto.cs
│ │ │ │ └── Conic2_template.cs
│ │ │ ├── Cylinder/
│ │ │ │ ├── Cylinder3_auto.cs
│ │ │ │ └── Cylinder3_template.cs
│ │ │ ├── Ellipse/
│ │ │ │ ├── Ellipse2_auto.cs
│ │ │ │ ├── Ellipse2_template.cs
│ │ │ │ ├── Ellipse3_auto.cs
│ │ │ │ ├── Ellipse3_template.cs
│ │ │ │ ├── Ellipse_auto.cs
│ │ │ │ └── Ellipse_template.cs
│ │ │ ├── Geometry1i.cs
│ │ │ ├── Geometry1i_auto.cs
│ │ │ ├── Geometry1i_template.cs
│ │ │ ├── Geometry_auto.cs
│ │ │ ├── Geometry_template.cs
│ │ │ ├── Hull/
│ │ │ │ ├── Hull2_auto.cs
│ │ │ │ ├── Hull2_template.cs
│ │ │ │ ├── Hull3_auto.cs
│ │ │ │ └── Hull3_template.cs
│ │ │ ├── Line/
│ │ │ │ ├── Line2_auto.cs
│ │ │ │ ├── Line2_template.cs
│ │ │ │ ├── Line3_auto.cs
│ │ │ │ └── Line3_template.cs
│ │ │ ├── Line1iPoint.cs
│ │ │ ├── Plane/
│ │ │ │ ├── Plane2_auto.cs
│ │ │ │ ├── Plane2_template.cs
│ │ │ │ ├── Plane3_auto.cs
│ │ │ │ └── Plane3_template.cs
│ │ │ ├── Polygon/
│ │ │ │ ├── IImmutablePolygonExtensions_auto.cs
│ │ │ │ ├── IImmutablePolygonExtensions_template.cs
│ │ │ │ ├── ImmutablePolygon.cs
│ │ │ │ ├── Polygon2_auto.cs
│ │ │ │ ├── Polygon2_template.cs
│ │ │ │ ├── Polygon3_auto.cs
│ │ │ │ ├── Polygon3_template.cs
│ │ │ │ ├── PolygonExtensions_auto.cs
│ │ │ │ └── PolygonExtensions_template.cs
│ │ │ ├── Quad/
│ │ │ │ ├── Quad2_auto.cs
│ │ │ │ ├── Quad2_template.cs
│ │ │ │ ├── Quad3_auto.cs
│ │ │ │ └── Quad3_template.cs
│ │ │ ├── Quadric/
│ │ │ │ ├── Quadric_auto.cs
│ │ │ │ └── Quadric_template.cs
│ │ │ ├── Ray/
│ │ │ │ ├── Ray2_auto.cs
│ │ │ │ ├── Ray2_template.cs
│ │ │ │ ├── Ray3_auto.cs
│ │ │ │ └── Ray3_template.cs
│ │ │ ├── Sphere/
│ │ │ │ ├── Sphere3_auto.cs
│ │ │ │ └── Sphere3_template.cs
│ │ │ ├── Torus/
│ │ │ │ ├── Torus3_auto.cs
│ │ │ │ └── Torus3_template.cs
│ │ │ └── Triangle/
│ │ │ ├── Triangle2_auto.cs
│ │ │ ├── Triangle2_template.cs
│ │ │ ├── Triangle3_auto.cs
│ │ │ └── Triangle3_template.cs
│ │ ├── Hashing/
│ │ │ └── HashCode.cs
│ │ ├── Introspection/
│ │ │ ├── Aardvark.cs
│ │ │ ├── CachingProperties.cs
│ │ │ ├── Introspection.cs
│ │ │ ├── IntrospectionProperties.cs
│ │ │ ├── Native.cs
│ │ │ ├── Platform/
│ │ │ │ ├── Dl.cs
│ │ │ │ ├── Kernel32.cs
│ │ │ │ └── LdConfig.cs
│ │ │ ├── Plugins.cs
│ │ │ ├── RegexPatterns.cs
│ │ │ └── Utilities.cs
│ │ ├── Json/
│ │ │ └── JsonConverters.cs
│ │ ├── Math/
│ │ │ ├── Base/
│ │ │ │ ├── Adler32.cs
│ │ │ │ ├── AliasTable_auto.cs
│ │ │ │ ├── AliasTable_template.cs
│ │ │ │ ├── Complex_auto.cs
│ │ │ │ ├── Complex_template.cs
│ │ │ │ ├── Constant.cs
│ │ │ │ ├── Conversion.cs
│ │ │ │ ├── DistributionFunction.cs
│ │ │ │ ├── Fraction.cs
│ │ │ │ ├── Fun.cs
│ │ │ │ ├── Fun_auto.cs
│ │ │ │ ├── Fun_template.cs
│ │ │ │ ├── Half.cs
│ │ │ │ ├── MedianWindow.cs
│ │ │ │ ├── PhysicsConsts.cs
│ │ │ │ ├── Quaternion_auto.cs
│ │ │ │ ├── Quaternion_template.cs
│ │ │ │ ├── SampleGrid2d.cs
│ │ │ │ ├── Statistics.cs
│ │ │ │ └── WeightedIndex.cs
│ │ │ ├── Colors/
│ │ │ │ ├── Color.cs
│ │ │ │ ├── Color_auto.cs
│ │ │ │ ├── Color_template.cs
│ │ │ │ └── Spectrum.cs
│ │ │ ├── Curves/
│ │ │ │ └── Curves.cs
│ │ │ ├── Interfaces/
│ │ │ │ ├── IMatrix.cs
│ │ │ │ ├── IOpacity.cs
│ │ │ │ ├── IRGB.cs
│ │ │ │ ├── IRange.cs
│ │ │ │ ├── ISize_auto.cs
│ │ │ │ ├── ISize_template.cs
│ │ │ │ ├── ITensor.cs
│ │ │ │ ├── IValidity.cs
│ │ │ │ ├── IVector.cs
│ │ │ │ └── IVolume.cs
│ │ │ ├── Interfaces.cs
│ │ │ ├── Interpolation/
│ │ │ │ ├── Interpolation.cs
│ │ │ │ └── Mapping.cs
│ │ │ ├── LuFactorization.cs
│ │ │ ├── Numerics/
│ │ │ │ ├── CovarianceMatrix.cs
│ │ │ │ └── Polynomial.cs
│ │ │ ├── QrFactorization.cs
│ │ │ ├── RangesBoxes/
│ │ │ │ ├── Box.cs
│ │ │ │ ├── Box_auto.cs
│ │ │ │ ├── Box_template.cs
│ │ │ │ ├── Cell.cs
│ │ │ │ ├── Cell2d.cs
│ │ │ │ ├── OrientedBox_auto.cs
│ │ │ │ └── OrientedBox_template.cs
│ │ │ ├── Trafos/
│ │ │ │ ├── Affine_auto.cs
│ │ │ │ ├── Affine_template.cs
│ │ │ │ ├── CoordTransforms.cs
│ │ │ │ ├── CoordinateSystem.cs
│ │ │ │ ├── Euclidean_auto.cs
│ │ │ │ ├── Euclidean_template.cs
│ │ │ │ ├── M33_auto.cs
│ │ │ │ ├── M33_template.cs
│ │ │ │ ├── M44_auto.cs
│ │ │ │ ├── M44_template.cs
│ │ │ │ ├── MatrixArrayExtensions.cs
│ │ │ │ ├── Matrix_auto.cs
│ │ │ │ ├── Matrix_template.cs
│ │ │ │ ├── Rot2_auto.cs
│ │ │ │ ├── Rot2_template.cs
│ │ │ │ ├── Rot3_auto.cs
│ │ │ │ ├── Rot3_template.cs
│ │ │ │ ├── Scale_auto.cs
│ │ │ │ ├── Scale_template.cs
│ │ │ │ ├── Shift_auto.cs
│ │ │ │ ├── Shift_template.cs
│ │ │ │ ├── Similarity_auto.cs
│ │ │ │ ├── Similarity_template.cs
│ │ │ │ ├── Trafo_auto.cs
│ │ │ │ └── Trafo_template.cs
│ │ │ └── Vectors/
│ │ │ ├── HashCode.cs
│ │ │ ├── V3fCoder.cs
│ │ │ ├── VectorArrayExtensions.cs
│ │ │ ├── VectorIEnumerableExtensions_auto.cs
│ │ │ ├── VectorIEnumerableExtensions_template.cs
│ │ │ ├── VectorTypeConverter_auto.cs
│ │ │ ├── VectorTypeConverter_template.cs
│ │ │ ├── Vector_auto.cs
│ │ │ └── Vector_template.cs
│ │ ├── Random/
│ │ │ ├── ForcedRandomSeries.cs
│ │ │ ├── HaltonRandomSeries.cs
│ │ │ ├── IRandomDistribution.cs
│ │ │ ├── IRandomSeries.cs
│ │ │ ├── IRandomUniform.cs
│ │ │ ├── PerlinNoise.cs
│ │ │ ├── Prime.cs
│ │ │ ├── PseudoRandomSeries.cs
│ │ │ ├── Quasi.cs
│ │ │ ├── RandomDistributions.cs
│ │ │ ├── RandomIEnumerableExtensions.cs
│ │ │ ├── RandomSample.cs
│ │ │ └── RandomSystem.cs
│ │ ├── Reporting/
│ │ │ ├── FilterLogTarget.cs
│ │ │ ├── IJobReporter.cs
│ │ │ ├── ILogTarget.cs
│ │ │ ├── IReportable.cs
│ │ │ ├── IReporter.cs
│ │ │ ├── JobReporter.cs
│ │ │ ├── LogMsg.cs
│ │ │ ├── MultiLogTarget.cs
│ │ │ ├── NullReporter.cs
│ │ │ ├── PerThreadJobReporter.cs
│ │ │ ├── PerThreadLogTarget.cs
│ │ │ ├── Report.cs
│ │ │ ├── ReportJob.cs
│ │ │ ├── Skipper.cs
│ │ │ ├── TestInfo.cs
│ │ │ └── TextLogTarget.cs
│ │ ├── Sorting/
│ │ │ ├── ArrayExtensions.cs
│ │ │ ├── IEnumerableExtensions.cs
│ │ │ ├── ListExtensions.cs
│ │ │ ├── Sorting_auto.cs
│ │ │ └── Sorting_template.cs
│ │ ├── Symbol/
│ │ │ ├── Dict_auto.cs
│ │ │ ├── Dict_template.cs
│ │ │ ├── Dicts.cs
│ │ │ ├── IDict.cs
│ │ │ ├── SymMapBase.cs
│ │ │ ├── SymMapBaseTraversal.cs
│ │ │ └── Symbol.cs
│ │ ├── Text/
│ │ │ ├── Text.cs
│ │ │ └── TextParser.cs
│ │ ├── Tup/
│ │ │ ├── Tuples_auto.cs
│ │ │ └── Tuples_template.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Essentials/
│ │ ├── Aardvark.Base.Essentials.csproj
│ │ ├── Camera/
│ │ │ ├── CameraProjectionOrtho.cs
│ │ │ ├── CameraProjectionPerspective.cs
│ │ │ ├── CameraViewRaw.cs
│ │ │ ├── CameraViewWithSky.cs
│ │ │ ├── ICameraProjection.cs
│ │ │ ├── ICameraProjectionExtensions.cs
│ │ │ ├── ICameraView.cs
│ │ │ ├── ICameraViewExtensions.cs
│ │ │ ├── IRenderView.cs
│ │ │ └── IRenderViewExtensions.cs
│ │ ├── Editing/
│ │ │ ├── BehaviorDragAbsolute.cs
│ │ │ ├── BehaviorDragRelative.cs
│ │ │ ├── IBehavior.cs
│ │ │ ├── IBehaviorDeletable.cs
│ │ │ ├── IBehaviorPosition2d.cs
│ │ │ ├── IBehaviorSplittableEdge2d.cs
│ │ │ ├── IBehaviorTransform2d.cs
│ │ │ ├── IEditableEdge2d.cs
│ │ │ ├── IEditableFace2d.cs
│ │ │ ├── IEditableSequence.cs
│ │ │ └── IEditableVertex2d.cs
│ │ ├── NormalizedDeviceCoordinates.cs
│ │ ├── PixelPosition.cs
│ │ ├── Screenshot.cs
│ │ ├── System/
│ │ │ ├── Awaitable.cs
│ │ │ ├── Clock.cs
│ │ │ ├── Disposable.cs
│ │ │ ├── EventSource.cs
│ │ │ ├── EventSourceExtensions.cs
│ │ │ ├── EventSourceInterfaces.cs
│ │ │ ├── EventSourceSpecials.cs
│ │ │ ├── FilteredEventSource.cs
│ │ │ ├── IAwaitable.cs
│ │ │ ├── Reactive.cs
│ │ │ ├── Time.cs
│ │ │ └── WithCancellationExtension.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.FSharp/
│ │ ├── Aardvark.Base.FSharp.fsproj
│ │ ├── Ag.fs
│ │ ├── Algorithms/
│ │ │ └── PolygonSimplification.fs
│ │ ├── Color/
│ │ │ ├── ColorBrewer.fs
│ │ │ ├── ColorBrewerSchemes.fs
│ │ │ └── ColorBrewerSchemes.fsx
│ │ ├── Datastructures/
│ │ │ ├── Geometry/
│ │ │ │ ├── Boundable.fs
│ │ │ │ ├── Bvh.fs
│ │ │ │ └── KdTree.fs
│ │ │ ├── Immutable/
│ │ │ │ ├── FingerTree.fs
│ │ │ │ ├── Graph.fs
│ │ │ │ ├── MapExt.fs
│ │ │ │ ├── RangeSet_auto.fs
│ │ │ │ ├── RangeSet_template.fs
│ │ │ │ └── SetDelta.fs
│ │ │ └── Mutable/
│ │ │ ├── AVL.fs
│ │ │ ├── ConcurrentHashQueue.fs
│ │ │ ├── FixedSizeArray.fs
│ │ │ ├── OrderMaintenance.fs
│ │ │ ├── OrderMaintenanceTrie.fs
│ │ │ ├── ReferenceCountingSet.fs
│ │ │ ├── SkipList.fs
│ │ │ └── StableSet.fs
│ │ ├── Math/
│ │ │ ├── AverageWindow.fs
│ │ │ ├── Converters.fs
│ │ │ ├── Math.fs
│ │ │ ├── Matrix.fs
│ │ │ ├── SVDM33f.fs
│ │ │ └── Vectors.fs
│ │ ├── Native/
│ │ │ ├── BlobStore.fs
│ │ │ ├── FileTable.fs
│ │ │ ├── Manager.fs
│ │ │ ├── Memory.fs
│ │ │ ├── Pointer.fs
│ │ │ └── Store.fs
│ │ ├── Reflection/
│ │ │ ├── Formatf.fs
│ │ │ ├── FunctionReflection.fs
│ │ │ ├── IL.fs
│ │ │ ├── Multimethod.fs
│ │ │ ├── Quotations.fs
│ │ │ ├── ReflectionExtensions.fs
│ │ │ ├── TypeBuilder.fs
│ │ │ ├── TypeInfo.fs
│ │ │ ├── TypeMeta_auto.fs
│ │ │ ├── TypeMeta_template.fs
│ │ │ └── UnmanagedFunctions.fs
│ │ ├── Runtime/
│ │ │ ├── Assembler.fs
│ │ │ ├── Caches.fs
│ │ │ ├── CustomSchedulers.fs
│ │ │ ├── DynamicLinker.fs
│ │ │ ├── Fragments.fs
│ │ │ ├── NativeMemory.fs
│ │ │ └── WeakTable.fs
│ │ ├── Utilities/
│ │ │ ├── IO.fs
│ │ │ ├── Interop/
│ │ │ │ ├── ArraySegment.fs
│ │ │ │ ├── CSharpList.fs
│ │ │ │ ├── Dictionary.fs
│ │ │ │ ├── FSLibExtensions.fs
│ │ │ │ ├── HashSet.fs
│ │ │ │ ├── SortedSet.fs
│ │ │ │ ├── String.fs
│ │ │ │ └── Symbol.fs
│ │ │ ├── Lens.fs
│ │ │ ├── Logging.fs
│ │ │ ├── Measures.fs
│ │ │ ├── Monads.fs
│ │ │ ├── Monoid.fs
│ │ │ ├── Native.fs
│ │ │ ├── Pickler/
│ │ │ │ ├── AdaptivePicklers.fs
│ │ │ │ └── FsPicklerExtensions.fs
│ │ │ ├── PrimitiveValueConverter.fs
│ │ │ ├── Threading.fs
│ │ │ └── Weak.fs
│ │ ├── __project.fsx
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Fonts/
│ │ ├── Aardvark.Base.Fonts.fsproj
│ │ ├── BvhInternal.fs
│ │ ├── Font.fs
│ │ ├── FontResolver.fs
│ │ ├── Path.fs
│ │ ├── PathSegment.fs
│ │ ├── PathTessellator.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.IO/
│ │ ├── Aardvark.Base.IO.csproj
│ │ ├── Annotations.cs
│ │ ├── BaseCoder.cs
│ │ ├── BinaryReadingCoder.cs
│ │ ├── BinaryReadingCoder_auto.cs
│ │ ├── BinaryReadingCoder_template.cs
│ │ ├── BinaryWritingCoder.cs
│ │ ├── BinaryWritingCoder_auto.cs
│ │ ├── BinaryWritingCoder_template.cs
│ │ ├── ChunkedMemoryStream.cs
│ │ ├── CodingExtensions.cs
│ │ ├── Converter.cs
│ │ ├── FastObjectFactory.cs
│ │ ├── FieldCoderExtensions.cs
│ │ ├── GzipUtils.cs
│ │ ├── IAwakeable.cs
│ │ ├── ICoder.cs
│ │ ├── ICoder_auto.cs
│ │ ├── ICoder_template.cs
│ │ ├── IFieldCodeable.cs
│ │ ├── ITypedMap.cs
│ │ ├── NetworkOrderBinaryReader.cs
│ │ ├── NetworkOrderBinaryWriter.cs
│ │ ├── RegisterTypeInfoAttribute.cs
│ │ ├── StreamCodeReader.cs
│ │ ├── StreamCodeReader_auto.cs
│ │ ├── StreamCodeReader_template.cs
│ │ ├── StreamCodeWriter.cs
│ │ ├── StreamCodeWriter_auto.cs
│ │ ├── StreamCodeWriter_template.cs
│ │ ├── StreamWriter2.cs
│ │ ├── SymMap.cs
│ │ ├── TypeCoder.cs
│ │ ├── TypeCoder_auto.cs
│ │ ├── TypeCoder_template.cs
│ │ ├── TypeExtensions.cs
│ │ ├── TypeInfo.cs
│ │ ├── TypeInfoVersion.cs
│ │ ├── UberStream.cs
│ │ ├── WorkDir.cs
│ │ ├── XmlParser.cs
│ │ ├── XmlReadingCoder.cs
│ │ ├── XmlReadingCoder_auto.cs
│ │ ├── XmlReadingCoder_template.cs
│ │ ├── XmlWritingCoder.cs
│ │ ├── XmlWritingCoder_auto.cs
│ │ ├── XmlWritingCoder_template.cs
│ │ ├── ZipFileContainer.cs
│ │ ├── ZipFileHeader.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Incremental/
│ │ ├── Aardvark.Base.Incremental.fsproj
│ │ ├── AdaptiveFunc/
│ │ │ └── AdaptiveFunc.fs
│ │ ├── AdaptiveStream/
│ │ │ ├── AdaptiveStream.fs
│ │ │ └── AdaptiveStreamCore.fs
│ │ ├── AgInterop.fs
│ │ ├── Builders.fs
│ │ ├── ChangeTracker.fs
│ │ ├── IncrementalBvh.fs
│ │ ├── Proc/
│ │ │ ├── Proc.fs
│ │ │ ├── ProcList.fs
│ │ │ └── ThreadPool.fs
│ │ ├── Scripts/
│ │ │ ├── load-project.fsx
│ │ │ └── load-references.fsx
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Runtime/
│ │ ├── Aardvark.Base.Runtime.fsproj
│ │ ├── Coder/
│ │ │ ├── Code.fs
│ │ │ ├── Core.fs
│ │ │ ├── State.fs
│ │ │ ├── Utilities.fs
│ │ │ └── ValueCoders.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Telemetry/
│ │ ├── Aardvark.Base.Telemetry.csproj
│ │ ├── Debug.cs
│ │ ├── Environment.cs
│ │ ├── HardwareThread.cs
│ │ ├── IProbe.cs
│ │ ├── Probes.cs
│ │ ├── Registry.cs
│ │ ├── TelemetryExtensions.cs
│ │ ├── TimingStats.cs
│ │ ├── Views.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Tensors/
│ │ ├── Aardvark.Base.Tensors.fsproj
│ │ ├── Algorithms/
│ │ │ ├── Generator.fsx
│ │ │ ├── QR.fs
│ │ │ ├── SVD.fs
│ │ │ └── Solver.fs
│ │ ├── Extensions/
│ │ │ ├── TensorMath.fs
│ │ │ ├── TensorSlicing.fs
│ │ │ ├── TensorUtilitiesGenerated.fs
│ │ │ └── TensorUtilitiesGenerator.fsx
│ │ ├── Native/
│ │ │ ├── NativeTensorExtensions.fs
│ │ │ ├── NativeTensorGenerated.fs
│ │ │ └── NativeTensorGenerator.fsx
│ │ ├── PixImage/
│ │ │ ├── ImageTrafo.fs
│ │ │ ├── PixCube.fs
│ │ │ └── PixImageErrorMetric.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Tensors.CSharp/
│ │ ├── Aardvark.Base.Tensors.CSharp.csproj
│ │ ├── Algorithms/
│ │ │ ├── LuFactorization.cs
│ │ │ └── QrFactorization.cs
│ │ ├── PixImage/
│ │ │ ├── EdgeFilter.cs
│ │ │ ├── IPix.cs
│ │ │ ├── ImageLoadException.cs
│ │ │ ├── PixCube.cs
│ │ │ ├── PixImage.cs
│ │ │ ├── PixImageCreators.cs
│ │ │ ├── PixImageExtensions.cs
│ │ │ ├── PixImageMipMap.cs
│ │ │ ├── PixLoader.cs
│ │ │ ├── PixProcessor.cs
│ │ │ └── PixVolume.cs
│ │ ├── Tensor.cs
│ │ ├── TensorExtensions.cs
│ │ ├── TensorExtensions_auto.cs
│ │ ├── TensorExtensions_template.cs
│ │ ├── TensorMathExt_auto.cs
│ │ ├── TensorMathExt_template.cs
│ │ ├── Tensor_auto.cs
│ │ ├── Tensor_template.cs
│ │ ├── Tensors/
│ │ │ ├── Accessors.cs
│ │ │ ├── Accessors_auto.cs
│ │ │ ├── Accessors_template.cs
│ │ │ ├── ArrayExtensions.cs
│ │ │ ├── FilterKernel.cs
│ │ │ ├── ImageBorder.cs
│ │ │ ├── ImageTensors.cs
│ │ │ ├── Interfaces.cs
│ │ │ ├── Parallel.cs
│ │ │ └── Tools.cs
│ │ ├── Utilities/
│ │ │ ├── Polygon2dExtensions.cs
│ │ │ └── SpectrumExtensions.cs
│ │ └── paket.references
│ ├── Aardvark.Geometry/
│ │ ├── Aardvark.Geometry.fsproj
│ │ ├── Bvh.fs
│ │ ├── EllipsoidRegression.fs
│ │ ├── LinearRegression.fs
│ │ ├── PolyRegion2d.fs
│ │ ├── Region3d.fs
│ │ ├── TexturePacking.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.sln
│ ├── CodeGenerator/
│ │ ├── CodeGenerator.csproj
│ │ ├── CompilerServices.cs
│ │ ├── InternalsVisibleTo.cs
│ │ ├── Program.cs
│ │ ├── README.md
│ │ ├── TemplateProcessor.cs
│ │ ├── app.config
│ │ └── paket.references
│ ├── Demo/
│ │ ├── CoreTest/
│ │ │ ├── CoreTest.fsproj
│ │ │ ├── Program.fs
│ │ │ └── paket.references
│ │ ├── ExamplesCSharp/
│ │ │ ├── ExamplesCSharp.csproj
│ │ │ ├── Program.cs
│ │ │ └── paket.references
│ │ ├── IncrementalDemo.CSharp/
│ │ │ ├── IncrementalDemo.CSharp.csproj
│ │ │ ├── Program.cs
│ │ │ └── paket.references
│ │ ├── PixImageDemo/
│ │ │ ├── PixImageDemo.csproj
│ │ │ ├── Program.cs
│ │ │ └── paket.references
│ │ ├── RandomSampleDemo/
│ │ │ ├── Program.cs
│ │ │ ├── RandomSampleDemo.csproj
│ │ │ └── paket.references
│ │ ├── Scratch/
│ │ │ ├── Program.fs
│ │ │ ├── Scratch.fsproj
│ │ │ ├── Store.fs
│ │ │ └── paket.references
│ │ └── Sketch/
│ │ ├── App.config
│ │ ├── FingerTree.fsx
│ │ ├── FutureList.fsx
│ │ ├── Lazy.fsx
│ │ ├── Observable.fsx
│ │ ├── Program.fs
│ │ ├── Rampa.fsx
│ │ ├── Sketch.fsproj
│ │ ├── Sketch.sln
│ │ ├── UndoRedo.fsx
│ │ ├── Yampa.fsx
│ │ ├── adventure.txt
│ │ └── paket_.references
│ └── Tests/
│ ├── Aardvark.Base.Benchmarks/
│ │ ├── Aardvark.Base.Benchmarks.csproj
│ │ ├── CodeGenTest.cs
│ │ ├── ColorConversion.cs
│ │ ├── ConstantsBenchmark.cs
│ │ ├── Enumerators.cs
│ │ ├── Geometry/
│ │ │ ├── PolygonTransform.cs
│ │ │ ├── RayHitTest.cs
│ │ │ └── SolidAngle.cs
│ │ ├── HashCodeCombine.cs
│ │ ├── Hashes.cs
│ │ ├── Indexers_auto.cs
│ │ ├── Indexers_template.cs
│ │ ├── Lazy.cs
│ │ ├── Math/
│ │ │ ├── AngleBetween_auto.cs
│ │ │ ├── AngleBetween_template.cs
│ │ │ ├── DistanceRot3_auto.cs
│ │ │ ├── DistanceRot3_template.cs
│ │ │ ├── DistanceToLine.cs
│ │ │ ├── FractTest.cs
│ │ │ ├── IntegerPower_auto.cs
│ │ │ ├── IntegerPower_template.cs
│ │ │ ├── Log2Int.cs
│ │ │ ├── PowerOfTwo_auto.cs
│ │ │ ├── PowerOfTwo_template.cs
│ │ │ ├── Rot3GetEuler_auto.cs
│ │ │ ├── Rot3GetEuler_template.cs
│ │ │ ├── Rot3dTransform.cs
│ │ │ ├── RotateInto_auto.cs
│ │ │ ├── RotateInto_template.cs
│ │ │ ├── Tensors/
│ │ │ │ ├── MatrixMinor.cs
│ │ │ │ ├── MatrixMultiply.cs
│ │ │ │ ├── MatrixOrthogonalize_auto.cs
│ │ │ │ ├── MatrixOrthogonalize_template.cs
│ │ │ │ ├── MatrixSampling.cs
│ │ │ │ └── TensorMathBenchmark.cs
│ │ │ ├── Transform.cs
│ │ │ └── VectorLength.cs
│ │ ├── Program.cs
│ │ ├── StaticConstants.cs
│ │ ├── StreamWriterReader.cs
│ │ ├── TelemetryProbesBenchmark.cs
│ │ └── paket.references
│ ├── Aardvark.Base.FSharp.Benchmarks/
│ │ ├── Aardvark.Base.FSharp.Benchmarks.fsproj
│ │ ├── ActivePatterns.fs
│ │ ├── ArrayChooseBench.fs
│ │ ├── BvhIntersectBench.fs
│ │ ├── DynamicDispatchBench.fs
│ │ ├── NullCheckBench.fs
│ │ ├── Program.fs
│ │ ├── ReferenceCountingSetBench.fs
│ │ ├── TensorMathBench.fs
│ │ ├── TensorUtilitiesBench.fs
│ │ ├── Tuples_auto.fs
│ │ ├── Tuples_template.fs
│ │ ├── TypePatternsBench.fs
│ │ └── paket.references
│ ├── Aardvark.Base.FSharp.Tests/
│ │ ├── Aardvark.Base.FSharp.Tests.fsproj
│ │ ├── CachesTest.fs
│ │ ├── ControlTests.fs
│ │ ├── Datastructures/
│ │ │ ├── FSharpExtensionTests.fs
│ │ │ ├── MapExt.fs
│ │ │ ├── OrderMaintenanceTrie.fs
│ │ │ ├── RangeSetTests.fs
│ │ │ └── SortedSetExt.fs
│ │ ├── EnumTests.fs
│ │ ├── GeometryValueOptionTests.fs
│ │ ├── HMap.fs
│ │ ├── Math/
│ │ │ ├── MathTests.fs
│ │ │ ├── SVDTests.fs
│ │ │ └── TrafoTests.fs
│ │ ├── NativeMemory.fs
│ │ ├── NullCoalesceTests.fs
│ │ ├── PinnedValueTests.fs
│ │ ├── Program.fs
│ │ ├── PureAgTests.fs
│ │ ├── SizeOfTests.fs
│ │ ├── Tensors/
│ │ │ ├── PixTests.fs
│ │ │ ├── TensorMathTests.fs
│ │ │ └── TensorTests.fs
│ │ ├── TypeMetaTests.fs
│ │ └── paket.references
│ ├── Aardvark.Base.Fonts.Tests/
│ │ ├── Aardvark.Base.Fonts.Tests.fsproj
│ │ ├── Common.fs
│ │ ├── Loading.fs
│ │ ├── PathSegment.fs
│ │ ├── Program.fs
│ │ ├── paket.references
│ │ └── test.runsettings
│ ├── Aardvark.Base.Incremental.Tests/
│ │ ├── AListTests.fs
│ │ ├── AListTestsNew.fs
│ │ ├── AMapTests.fs
│ │ ├── ASetFoldTest.csv
│ │ ├── ASetPerformance.fs
│ │ ├── ASetPerformanceTests.fs
│ │ ├── ASetTests.fs
│ │ ├── Aardvark.Base.Incremental.Tests.fsproj
│ │ ├── AgTests.fs
│ │ ├── ModTests.fs
│ │ ├── Mutables.fs
│ │ ├── Performance.fs
│ │ ├── SizeOfVariousAdaptiveObjects.fs
│ │ ├── UndoRedo.fs
│ │ └── paket.references
│ ├── Aardvark.Base.Runtime.Tests/
│ │ ├── Aardvark.Base.Runtime.Tests.fsproj
│ │ ├── CoderTests.fs
│ │ ├── ReflectionTests.fs
│ │ └── paket.references
│ ├── Aardvark.Base.Tests/
│ │ ├── Aardvark.Base.Tests.csproj
│ │ ├── AlgoDat/
│ │ │ ├── DictTests.cs
│ │ │ ├── HigherOrderFunctionsTests.cs
│ │ │ └── SortingTests.cs
│ │ ├── CodeGenerator/
│ │ │ └── CodeGeneratorTests.cs
│ │ ├── Extensions/
│ │ │ ├── Arrays.cs
│ │ │ ├── DateTime.cs
│ │ │ ├── Enumerable.cs
│ │ │ ├── Hashes.cs
│ │ │ ├── ListHeapTests.cs
│ │ │ ├── Lists.cs
│ │ │ ├── StreamTests.cs
│ │ │ ├── Strings.cs
│ │ │ └── TaskWithCancellationTests.cs
│ │ ├── Geometry/
│ │ │ ├── Circle2dTests.cs
│ │ │ ├── Hull2dTests.cs
│ │ │ ├── Hull3dTests.cs
│ │ │ ├── IntersectionTestsTests.cs
│ │ │ ├── LineDistance.cs
│ │ │ ├── Plane3dTests.cs
│ │ │ └── PolygonClipping.cs
│ │ ├── IO/
│ │ │ └── UberStreamTests.cs
│ │ ├── Images/
│ │ │ ├── PixImageTests.cs
│ │ │ ├── PixSaveParamsTests.cs
│ │ │ ├── PixVolumeTests.cs
│ │ │ └── SystemDrawingTests.cs
│ │ ├── Json/
│ │ │ └── SystemTextJsonTests.cs
│ │ ├── Math/
│ │ │ ├── AliasTable.cs
│ │ │ ├── ColorTests.cs
│ │ │ ├── ComplexTests.cs
│ │ │ ├── Distributions.cs
│ │ │ ├── FunTests.cs
│ │ │ ├── HalfTests.cs
│ │ │ ├── PolynomialTests.cs
│ │ │ └── QuaternionTests.cs
│ │ ├── Plane/
│ │ │ └── PlaneTest.cs
│ │ ├── Program.cs
│ │ ├── Random/
│ │ │ ├── RandomIEnumerableExtensionsTests.cs
│ │ │ └── RandomSystemTests.cs
│ │ ├── RangesBoxes/
│ │ │ ├── BoxTests.cs
│ │ │ ├── Cell2dTests.cs
│ │ │ └── CellTests.cs
│ │ ├── Reporting/
│ │ │ └── ReportingTests.cs
│ │ ├── System/
│ │ │ └── EventSourceSlimTests.cs
│ │ ├── Telemetry/
│ │ │ └── TelemetryTests.cs
│ │ ├── Tensors/
│ │ │ └── TensorMatrixTests.cs
│ │ ├── TestSuite/
│ │ │ └── TestSuite.cs
│ │ ├── Trafos/
│ │ │ ├── AffineTests.cs
│ │ │ ├── EuclideanTests.cs
│ │ │ ├── MatrixTests.cs
│ │ │ ├── Rot2dTests.cs
│ │ │ ├── Rot3dTests.cs
│ │ │ ├── Scale3dTests.cs
│ │ │ ├── Shift3dTests.cs
│ │ │ ├── SimilarityTests.cs
│ │ │ ├── TrafoTesting.cs
│ │ │ └── TrafoTests.cs
│ │ ├── Vectors/
│ │ │ ├── V3fCoderTests.cs
│ │ │ └── VectorTests.cs
│ │ └── paket.references
│ └── Aardvark.Geometry.Tests/
│ ├── Aardvark.Geometry.Tests.fsproj
│ ├── PolyRegion2dTests.fs
│ ├── Program.fs
│ ├── Regression.fs
│ ├── TexturePacking.fs
│ └── paket.references
├── test.cmd
├── test.sh
└── tools/
├── DocsChecker/
│ ├── DocsAnalyzer.cs
│ ├── DocsChecker.csproj
│ ├── DocsRules.cs
│ ├── Program.cs
│ └── Properties/
│ └── AssemblyInfo.cs
└── DocsChecker.Tests/
├── DocsAnalyzerTests.cs
└── DocsChecker.Tests.csproj
================================================
FILE CONTENTS
================================================
================================================
FILE: .claude/CLAUDE.md
================================================
# AI Documentation
Read `ai/README.md` for indexed reference docs on types, algorithms, and utilities.
================================================
FILE: .config/dotnet-tools.json
================================================
{
"version": 1,
"isRoot": true,
"tools": {
"paket": {
"version": "10.0.0-alpha011",
"commands": [
"paket"
],
"rollForward": false
},
"aardpack": {
"version": "2.0.7",
"commands": [
"aardpack"
],
"rollForward": false
}
}
}
================================================
FILE: .github/workflows/build.yml
================================================
name: Build
on:
push:
paths-ignore:
- 'README.md'
- 'docs/**'
pull_request:
paths-ignore:
- 'README.md'
- 'docs/**'
jobs:
codegen-check:
runs-on: windows-latest
steps:
- uses: actions/checkout@v4
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
global-json-file: global.json
- name: Cache Paket
uses: actions/cache@v4
with:
path: |
~/.nuget/packages
paket-files
key: ${{ runner.os }}-paket-${{ hashFiles('paket.lock') }}
restore-keys: |
${{ runner.os }}-paket-
- name: Restore
shell: cmd
run: .\build.cmd restore
- name: Run forced code generation
shell: cmd
run: .\generate.cmd --force
- name: Fail on generated diffs
shell: pwsh
run: |
git diff --quiet -- src
if ($LASTEXITCODE -ne 0) {
Write-Host "Generated files are out of date:"
git diff --name-only -- src
exit 1
}
build:
needs: codegen-check
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
include:
- os: ubuntu-latest
run-build: bash ./build.sh
- os: windows-latest
run-build: .\build.cmd
- os: macos-latest
run-build: bash ./build.sh
steps:
- uses: actions/checkout@v4
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
global-json-file: global.json
- name: Cache Paket
uses: actions/cache@v4
with:
path: |
~/.nuget/packages
paket-files
key: ${{ runner.os }}-paket-${{ hashFiles('paket.lock') }}
restore-keys: |
${{ runner.os }}-paket-
- name: Build
run: ${{ matrix.run-build }}
================================================
FILE: .github/workflows/docs-check.yml
================================================
name: Docs Check
on:
push:
pull_request:
jobs:
docs-check:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
steps:
- uses: actions/checkout@v4
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
global-json-file: global.json
- name: Run docs checker (Unix)
if: runner.os != 'Windows'
run: bash ./check-docs.sh
- name: Run docs checker (Windows)
if: runner.os == 'Windows'
shell: cmd
run: .\check-docs.cmd
================================================
FILE: .github/workflows/publish.yml
================================================
name: Publish
on:
push:
branches:
- master
- v53
paths:
- RELEASE_NOTES.md
- .github/workflows/publish.yml
jobs:
release-check:
name: Check release version
runs-on: windows-latest
permissions:
contents: read
outputs:
should_publish: ${{ steps.compare.outputs.should_publish }}
release_notes_version: ${{ steps.compare.outputs.release_notes_version }}
latest_release_version: ${{ steps.compare.outputs.latest_release_version }}
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install Dotnet
uses: actions/setup-dotnet@v4
with:
global-json-file: global.json
- name: Restore Tools
run: dotnet tool restore
- name: Compare release versions
id: compare
shell: pwsh
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
function Normalize-Version([string] $Version) {
if ([string]::IsNullOrWhiteSpace($Version)) {
return ""
}
return $Version.Trim() -replace '^[vV]', ''
}
$parseOutput = & dotnet aardpack --parse-only
if ($LASTEXITCODE -ne 0) {
throw "dotnet aardpack --parse-only failed with exit code $LASTEXITCODE."
}
$releaseNotesVersion = ($parseOutput | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Select-Object -Last 1).Trim()
if ([string]::IsNullOrWhiteSpace($releaseNotesVersion)) {
throw "dotnet aardpack --parse-only did not return a release notes version."
}
$headers = @{
Authorization = "Bearer $env:GITHUB_TOKEN"
Accept = "application/vnd.github+json"
"X-GitHub-Api-Version" = "2022-11-28"
"User-Agent" = "github-actions"
}
$latestReleaseVersion = ""
$shouldPublish = "true"
try {
$latestRelease = Invoke-RestMethod `
-Uri "https://api.github.com/repos/${{ github.repository }}/releases/latest" `
-Headers $headers
$latestReleaseVersion = [string] $latestRelease.tag_name
if ((Normalize-Version $releaseNotesVersion) -eq (Normalize-Version $latestReleaseVersion)) {
$shouldPublish = "false"
}
}
catch {
$statusCode = $_.Exception.Response.StatusCode.value__
if ($statusCode -eq 404) {
Write-Host "No latest GitHub release found. Continuing publish workflow."
}
else {
throw
}
}
"release_notes_version=$releaseNotesVersion" >> $env:GITHUB_OUTPUT
"latest_release_version=$latestReleaseVersion" >> $env:GITHUB_OUTPUT
"should_publish=$shouldPublish" >> $env:GITHUB_OUTPUT
"## Publish release check" >> $env:GITHUB_STEP_SUMMARY
"" >> $env:GITHUB_STEP_SUMMARY
"- Release notes version: ``$releaseNotesVersion``" >> $env:GITHUB_STEP_SUMMARY
"- Latest GitHub release: ``$latestReleaseVersion``" >> $env:GITHUB_STEP_SUMMARY
"- Should publish: ``$shouldPublish``" >> $env:GITHUB_STEP_SUMMARY
pack:
name: Package
needs: release-check
if: needs.release-check.outputs.should_publish == 'true'
runs-on: windows-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install Dotnet
uses: actions/setup-dotnet@v4
with:
global-json-file: global.json
- name: Restore Tools
run: dotnet tool restore
- name: Restore
run: dotnet paket restore
- name: Run forced code generation
shell: cmd
run: .\generate.cmd --force
- name: Fail on generated diffs
shell: pwsh
run: |
git diff --quiet -- src
if ($LASTEXITCODE -ne 0) {
Write-Host "Generated files are out of date:"
git diff --name-only -- src
exit 1
}
- name: Build
shell: cmd
run: dotnet build -c Release src\Aardvark.sln
- name: Test
run: dotnet test src\Aardvark.sln -c Release --no-build --nologo --logger:"console;verbosity=normal"
- name: Pack
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: dotnet aardpack src\Aardvark.sln --notag --skip-build
- name: Upload Packages
uses: actions/upload-artifact@v4
with:
name: packages
path: bin\pack
- name: GitHub Packages
env:
NUGET_KEY: ${{ secrets.GITHUB_TOKEN }}
shell: cmd
run: dotnet nuget push "bin\pack\*.nupkg" -k %NUGET_KEY% -s "https://nuget.pkg.github.com/aardvark-platform/index.json" --skip-duplicate
- name: NuGet
env:
NUGET_KEY: ${{ secrets.NUGET_KEY }}
shell: cmd
run: dotnet nuget push "bin\pack\*.nupkg" -k %NUGET_KEY% -s "https://api.nuget.org/v3/index.json" --skip-duplicate
================================================
FILE: .gitignore
================================================
**/.DS_Store
/.paket/paket.exe
/src/Aardvark.Base/obj
/src/*.suo
/src/*.userprefs
/bin/net40
/bin/net45
/packages/*
!/packages/*.config
*.nupkg
obj
/src/Aardvark.sln.ide
*.swp
bin
*.*~
/buildLog.log
/src/.vs
tmp
/docs
!/docs/
!/docs/CONTRIBUTING.md
!/docs/INTEROP.md
!/docs/TROUBLESHOOTING.md
/src/Aardvark.Base/Images/TensorExtensions_generator.cs
/src/Demo/Sketch/.vs/Sketch/v14/*.suo
/TestResult.xml
/.fake
/paket-files
/tests.out
/*.log
/src/Aardvark.Base/Tensors/TensorMathExt_generator.cs
**/*.csproj.user
**/*_generator.cs
/.paket
*.fsproj.user
Aardvark.log
/build.fsx.lock
.ionide
/.vs
.idea
.boss/
src/Aardvark.sln.DotSettings.user
.claude/settings.local.json
================================================
FILE: .vscode/settings.json
================================================
{
"dotnet-test-explorer.testProjectPath": "src/Aardvark.sln",
"files.exclude": {
"**/.git": true,
"**/.svn": true,
"**/.hg": true,
"**/CVS": true,
"**/.DS_Store": true,
"**/Thumbs.db": true,
".paket": true,
".ionide": true,
"packages": true,
"paket-files": true,
"**/obj/": true
}
}
================================================
FILE: .vscode/tasks.json
================================================
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
{
"label": "restore-tools",
"command": "dotnet",
"type": "shell",
"args": [ "tool", "restore" ],
"group": "build",
"runOptions": {
"runOn": "folderOpen"
},
"presentation": {
"echo": false,
"reveal": "never",
"focus": false,
"panel": "shared",
"showReuseMessage": false,
"clear": false,
"close": true
}
},
{
"label": "restore",
"command": "dotnet",
"type": "shell",
"args": [ "paket", "restore" ],
"group": "build"
},
{
"label": "codegen",
"command": "dotnet",
"type": "shell",
"args": [ "run", "--project", "src/CodeGenerator/CodeGenerator.csproj" ],
"group": "build"
},
{
"label": "build",
"command": "dotnet",
"type": "shell",
"args": [
"build",
"src/Aardvark.sln",
// Ask dotnet build to generate full paths for file names.
"/property:GenerateFullPaths=true",
// Do not generate summary otherwise it leads to duplicate errors in Problems panel
"/consoleloggerparameters:NoSummary"
],
"group": "build",
"presentation": {
"reveal": "silent"
},
"problemMatcher": "$msCompile"
},
{
"label": "install",
"command": "dotnet",
"type": "shell",
"args": [
"paket",
"install"
],
"group": "build",
"presentation": {
"reveal": "always"
},
"problemMatcher": "$msCompile"
},
{
"label": "clean",
"command": "dotnet",
"type": "shell",
"args": [
"clean",
"src/Aardvark.sln"
],
"group": "build",
"presentation": {
"reveal": "always"
}
}
]
}
================================================
FILE: AGENTS.md
================================================
# AI Agent Guide
Repository-specific rules and verified operational facts for coding agents.
Primary AI reference index: `ai/README.md`
## Supported Commands
Use these commands for restore/build/test/codegen:
| Task | Command | Notes |
|------|---------|-------|
| Restore only | `./build.sh restore` or `.\build.cmd restore` | Restores dotnet tools + paket packages, auto-repairing missing Paket targets with `dotnet paket install`, and returns a nonzero exit code on the first failure |
| Build all | `./build.sh` or `.\build.cmd` | Builds `src/Aardvark.sln` and stops on the first failing step |
| Build one project | `dotnet build src/Aardvark.Base/Aardvark.Base.csproj -c Debug` | Use explicit project path |
| Test all | `./test.sh` or `.\test.cmd` | Runs the five maintained test projects, stopping on the first failing step; excludes benchmark projects and the deprecated incremental test project |
| Test one project | `dotnet test src/Tests/Aardvark.Base.Tests/Aardvark.Base.Tests.csproj -c Debug` | Prefer this over whole-solution test |
| Test with filter | `dotnet test src/Tests/Aardvark.Base.Tests/Aardvark.Base.Tests.csproj --filter "FullyQualifiedName~Vector"` | Works with NUnit adapter; use a concrete test project |
| Codegen | `./generate.sh` or `.\generate.cmd` | Required after template changes |
| Check docs drift | `./check-docs.sh` or `.\check-docs.cmd` | Validates docs against source anchors and anti-drift rules |
## Dependency Management (Paket)
This repo uses Paket, not `dotnet add package`.
| Task | Command |
|------|---------|
| Add package | `dotnet paket add <pkg> --project <proj>` |
| Update group | `dotnet paket update --group Main` |
| Re-resolve lock | `dotnet paket install` |
| Restore packages | `dotnet paket restore` |
Rules:
- Never edit `paket.lock` manually
- Never use `dotnet add package` in this repo
- Change constraints in `paket.dependencies`, then regenerate lock with Paket
- Top-level `build.*` / `test.*` scripts auto-run `dotnet paket install` when `.paket/Paket.Restore.targets` is missing; otherwise they use `dotnet paket restore`
- Top-level `build.*` / `test.*` scripts now stop immediately on the first failing restore/build/test command and return that nonzero exit code
## Release Notes
When a change needs release notes:
- `aardvark.build` reads the first `### <version>` section as the current package version
- unreleased notes may appear above that first version section as plain text or bullet points
- do not add a markdown heading such as `### Preliminary` above the first version section
- do not append new notes inside an older released version block
- if you add pending/preliminary notes, place them above the first version section instead of inside the previous released block
## File Ownership by Change Type
| Change Type | Files to Modify | Files to Avoid |
|-------------|-----------------|----------------|
| Add C# feature | `src/Aardvark.Base/**/*.cs`, `src/Aardvark.Base.IO/**/*.cs`, `src/Aardvark.Base.Essentials/**/*.cs` | `*_auto.cs`, `*_template.cs` unless you are updating generation templates intentionally |
| Add F# feature | `src/Aardvark.Base.FSharp/**/*.fs`, `src/Aardvark.Base.Incremental/**/*.fs`, `src/Aardvark.Base.Tensors/**/*.fs`, `src/Aardvark.Geometry/**/*.fs`, `src/Aardvark.Base.Runtime/**/*.fs`, `src/Aardvark.Base.Fonts/**/*.fs` | Generated `*_auto.fs` unless template-driven change |
| Add tests | `src/Tests/**/*Tests.cs`, `src/Tests/**/*Tests.fs` | Unrelated production modules |
| Fix bug | Smallest relevant source area + regression test | Broad refactors without tests |
| Update dependencies | `paket.dependencies` (+ Paket-generated lock update) | Manual lock edits |
## Cross-Language Reality (Important)
Do not assume strict one-way C#/F# dependency rules here. This solution intentionally mixes languages:
- F# projects reference C# projects
- Some C# projects also reference F# projects (for example `Aardvark.Base.IO` references `Aardvark.Base.Tensors.fsproj`)
Guideline for agents:
- Preserve existing dependency direction used by neighboring projects
- If introducing a new reference, check existing project patterns first
- Avoid creating dependency cycles
## Framework, SDK, and Project Matrix
- SDK pin: `.NET SDK 8.0.0` with `rollForward: latestFeature` (see `global.json`)
- Not all projects target the same framework
Current project reality:
- Mixed `net8.0;netstandard2.0`: `Aardvark.Base`, `Aardvark.Base.FSharp`, `Aardvark.Base.IO`
- `netstandard2.0` only: `Aardvark.Base.Essentials`, `Aardvark.Base.Telemetry`, `Aardvark.Base.Tensors`, `Aardvark.Base.Tensors.CSharp`, `Aardvark.Base.Runtime`, `Aardvark.Base.Fonts`, `Aardvark.Geometry`
- `net8.0` test/demo projects: most projects in `src/Tests` and `src/Demo`
- Deprecated legacy test project: `src/Tests/Aardvark.Base.Incremental.Tests/Aardvark.Base.Incremental.Tests.fsproj` still targets `netcoreapp3.0`, is intentionally excluded from `src/Aardvark.sln` and the standard `test.sh` / `test.cmd` path, and is tracked for removal-or-migration in GitHub issue `#94`
- C# language version is not uniform (`12.0` in `Aardvark.Base`, `10.0` in some other C# projects)
## Common Failure Modes
| Symptom | Cause | Fix |
|---------|-------|-----|
| `dotnet paket restore` fails | Paket/tool state mismatch | `dotnet tool restore` then `dotnet paket restore`; if `.paket/Paket.Restore.targets` is missing or scripts are not being used, run `dotnet paket install` |
| Compile errors in generated files | Template/output out of sync | Run `./generate.sh` or `.\generate.cmd` |
| Build fails due framework mismatch | Running old SDK/runtime | Install .NET 8 SDK; verify `dotnet --info` and `global.json` |
| Test filter returns zero tests | Wrong filter syntax | Use `FullyQualifiedName~...` pattern |
| Docs check fails | Broken links, stale examples, missing anchors, mojibake | Run `./check-docs.sh` or `.\check-docs.cmd` and fix the reported file/pattern |
| Rendering namespace not found | Wrong package assumption | `Aardvark.Rendering` comes from downstream package, not this repo |
## Project Structure
```text
src/
|- Aardvark.Base/ (core C# math/geometry/types)
|- Aardvark.Base.Essentials/ (additional C# utilities)
|- Aardvark.Base.IO/ (I/O and image codecs; C#)
|- Aardvark.Base.Telemetry/ (telemetry probes; C#)
|- Aardvark.Base.Tensors.CSharp/ (C# tensor/piximage layer)
|- Aardvark.Base.FSharp/ (F# functional extensions)
|- Aardvark.Base.Incremental/ (adaptive system; F#)
|- Aardvark.Base.Tensors/ (tensor features; F#)
|- Aardvark.Base.Runtime/ (runtime helpers; F#)
|- Aardvark.Base.Fonts/ (font/text support; F#)
|- Aardvark.Geometry/ (geometry algorithms; F#)
|- Tests/ (C# + F# test projects)
|- Demo/ (sample apps)
|- CodeGenerator/ (template/code generation tooling)
```
## AI Reference Docs
See `ai/README.md` for task-based lookup across:
- primitive math/geometry types
- linear algebra semantics (layout/interoperability)
- geometry semantics (transform conventions)
- piximage/tensor APIs
- algorithms and collections
- serialization
- utilities
- F# interop
- incremental/adaptive system
## Agent Workflow Tips
1. Read only the doc needed for your task, not all docs
2. Verify API names with `rg` before using examples from docs
3. Prefer local source as the final truth if docs and code disagree
4. Run focused tests for touched modules before broad test runs
5. When changing templates, regenerate before building
6. When changing docs, run `./check-docs.sh` or `.\check-docs.cmd`
---
Last updated: 2026-02-26
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Aardvark Platform
Copyright (C) 2006-2019 Aardvark Platform Team
https://aardvark.graphics
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: PACKAGES.md
================================================
# Approach
Stable packages will be pushed to nuget by the maintainers.
# Developer packages
Community packages go to github, for this register your github token using:
`paket config add-token https://nuget.pkg.github.com/aardvark-platform <token>`
use build pushgithub
================================================
FILE: README.md
================================================
# Aardvark.Base
[](https://github.com/aardvark-platform/aardvark.base/actions/workflows/build.yml)
[](https://github.com/aardvark-platform/aardvark.base/actions/workflows/publish.yml)
[](https://github.com/aardvark-platform/aardvark.base/blob/master/LICENSE)
[](https://www.nuget.org/packages/Aardvark.Base/)
High-performance .NET foundation for visual computing, real-time graphics and geometry processing. Cross-platform (Windows/Linux/macOS), targets .NET Standard 2.0 and .NET 8.0.
Foundation of the [Aardvark Platform](https://github.com/aardvark-platform) ecosystem, powering advanced libraries for rendering (Aardvark.Rendering), UI (Aardvark.Media), VR/AR applications, and scientific visualization.
## Core Components
**Mathematics & Geometry**
- Vectors, matrices, quaternions, transformations (2D/3D/4D)
- Ranges, boxes, spheres, planes, rays, frustums
- Polygons, meshes, BVH acceleration structures
- Linear/ellipsoid regression, geometric algorithms
**Image Processing**
- PixImage with full tensor capabilities
- Format support: JPEG, PNG, TIFF, EXR, WebP, DDS
- Mipmaps, cube maps, volume textures
- Hardware-accelerated scaling and transformations
**Data Structures & Algorithms**
- Incremental/reactive programming primitives
- Efficient collections (IntDict, SymbolDict, MapExt)
- Spatial indexing (KdTree, BVH)
- Fast serialization/deserialization
## Quick Start
```csharp
using Aardvark.Base;
// Vectors and matrices
var v = new V3d(1, 2, 3);
var m = M44d.RotationX(45.0.RadiansFromDegrees());
var transformed = m.TransformPos(v);
// Image processing
var image = PixImage.Load("image.jpg");
var scaled = image.Scaled(0.5);
scaled.Save("output.png");
// Geometry
var box = new Box3d(V3d.Zero, V3d.One);
var ray = new Ray3d(V3d.Zero, V3d.XAxis);
var hit = ray.Intersects(box, out double t);
```
## Installation
```
dotnet add package Aardvark.Base
dotnet add package Aardvark.Base.FSharp # F# extensions
```
## Resources
- [Gallery](https://github.com/aardvark-platform/aardvark.docs/wiki/Gallery)
- [Packages & Repositories](https://github.com/aardvark-platform/aardvark.docs/wiki/Packages-and-Repositories)
- [Documentation](https://github.com/aardvark-platform/aardvark.base/wiki)
- [API Reference](https://aardvarkians.com/)
- [Platform Overview](https://github.com/aardvark-platform/aardvark.docs/wiki)
- [Discord Community](https://discord.gg/UyecnhM)
- [AI Reference](./ai/) - Technical docs for AI coding assistants
## License
[Apache 2.0](LICENSE)
================================================
FILE: RELEASE_NOTES.md
================================================
- [IO] Hardened `UberStream` constructor and read/write argument validation
- [Base] Made `EnumerableEx.AllDistinct` and `AllEqual` enumerate inputs only once
- [PixImage] Fixed save-parameter validation messages to report numeric values without a leading dollar sign
- [Base] Hardened `Stream.ReadBytes` argument validation before reading
- [Random] Fixed `TakeRandomly` to reject NaN probabilities
- [Base] Fixed `SingleValueSymbolDict` value-only construction and shared-value setter/add behavior
- [Essentials] Fixed `EventSourceSlim<T>` next-value awaitables and non-generic `IEvent` members
- [Base] Completed `SingleEntryDict` lookup, removal, and re-add behavior
- [Geometry] Fixed `Plane3.Project` array-slice validation for ranges ending at the array length
- [Base] Fixed `EnumerableEx.SelectToList` overloads for arrays and lists
- [Base] Fixed `StringFun.Plural` for empty and one-character words
- [Base] Fixed `ListFun.Map3` to truncate to the shortest input list when the third list is shortest
- [Base] Hardened `Adler32` input validation for null inputs and invalid array ranges
- [Random] Fixed `RandomSystem` boundary handling for inclusive integer and open/closed floating-point samples
- [Geometry] Implemented `Quad2.Contains(...)` overloads for lines, triangles, quads, and circles
- [FSharp] Fixed null-argument validation for custom `Seq` helpers
- [FSharp] Fixed `Seq.foldi` to pass the correct element index
- [Essentials] Fixed `Task.WithCancellation` for already-canceled tokens
### 5.3.23
- [CI] Added a publish workflow early exit when release notes already match the latest GitHub Release
### 5.3.22
- [Telemetry] Fixed `WallClockTimer` timer disposal so repeated `Dispose` calls do not corrupt timer state
- [Introspection] Fixed native library loading on Windows using netstandard2.0 (https://github.com/aardvark-platform/aardvark.base/issues/86)
- [Base] Fixed `Dict.Contains(key, value)` for collided entries in hash buckets
- [Base] Fixed reentrant `Dict.GetOrCreate`
- [Base] Fixed linear polynomial real roots
- [Base] Fixed special dict setter behavior
- [Base] Added fast values enumerator API for dict types
- [PixImage] Improved reporting of inner exceptions thrown by loaders and processors
- [FSharp] Added `Array.chooseV` and `Array.chooseiV`
- [FSharp] Added `Array.zipV` and `Array.unzipV`
- [FSharp] Fixed null-input handling for custom array ValueOption helpers
- [FSharp] Added intersection methods using `ValueOption` for `BvhTree` and `KdTree`
### 5.3.21
- [Base] Simplified computation of Constant<T>.MachineEpsilon
- [FSharp] Fixed MapExt.choose2 and MapExt.map2
### 5.3.20
- [Base] Improved native library loading and symlink creation
- [FSharp] Added utilities for copying streams
- [Fonts] Added Font.LoadFromAssembly for loading embedded fonts
- [Fonts] Improved error reporting by font resolver
- [Fonts] Added missing Symbola font
- [Fonts] Implemented font resolver for Linux
- [Base] Added hashing extensions for typed arrays in NET Standard 2.0 to improve binary compatibility with .NET 8 build.
### 5.3.19
- [Color] Added missing over- and underflow checks
- [PixCube] Added null- and length checks for input arrays
- [PixCube] Added IsEmpty
### 5.3.18
- Added ReadOnlySpan overloads for Cell, Cell2d, and range types
- [Tensors] Added and improved XML documentation
- [Tensors] Added PixImage and PixVolume constructors for data arrays
- [Color] Added over- and underflow checks for integer-based arithmetic operators
- [Color] Deprecated addition and subtraction of different types
- [Color] Deprecated integer-based multiplication and division
- [FSharpMath] Added min, max overloads for uint vectors
- [Introspection] Added overloads for unpacking native dependencies for a specific platform
### 5.3.17
- [FSharp] Added non-generic isNull and notNull
- [FSharp] Added generic inc and dec
- [FSharp] Fixed generic constraint of NativePtr.stackUseArr
### 5.3.16
- Fixed Cell.XYZ bug and improved doc comments
- [FSharp] Added PinnedValue and PinnedValue<'T> utility for pinning values and arrays with IDisposable semantics
- [FSharp] Added explicit type parameters to NativePtr functions
- [PixImage] Improved error messages regarding image loaders
### 5.3.15
- [Geometry] fixed GetPlane/GetTrafo for LinearRegression2d
- [Math] Added Fun.IsPowerOfTwo, Fun.NextPowerOfTwo, Fun.PrevPowerOfTwo overloads for uint32 and uint64
### 5.3.14
- [FSharp] Added workaround for compiler-related bug in NativePtr.pin, pinArr, and pinArri (https://github.com/dotnet/fsharp/issues/18689)
- [FSharp] Added tryLastV for Seq, List, and Array
### 5.3.13
- [FSharp] Added null-coalesing operator ||?
- [FSharp] Added Seq.asArray
- [FSharp] Added IDictionary and IReadOnlyDictionary interfaces for MapExt
- [FSharp] Added tryFindV, tryPickV, pickV, tryHeadV for Seq, List, and Array
- [Base] Added IDictionary and IReadOnlyDictionary interfaces for Dict, IntDict, SymbolDict, DictIEq
- [Base] Added ContainsValue() for Dict types
- [Ag] Use ValueOption internally and added overloads for public API returning ValueOption
### 5.3.12
- Fixed regression in range constructors
### 5.3.11
- Fixed range constructors for empty and null arrays and sequences
- Added GrayAlpha pixel format constants
- Added ToString() override for PixFormat
- Added PixFileFormat.Webp and PixWebpSaveParams
- Added more known image file extensions
- Added PixTiffSaveParams for choosing the compression scheme when saving TIFF images
- Added PixExrSaveParams for choosing the compression scheme when saving EXR images
### 5.3.10
- [IO] Added SymMap constructor overload
### 5.3.9
- [Base] Added AliasTable
- [Base] Added Triangle.Distance
- [Base] Added Triangle.SolidAngle
- [FSharp] Added NativePtr.stackUseArr
- [FSharp] Added Map.tryFindV
- [FSharp] Added Map.ofSeqWithDuplicates
- [FSharp] Added choosei, collecti for Seq, List, Array
- [FSharp] Added assignment operators
- [FSharp] Added Type.CLRSize extension property
- [Introspection] Made native library loading more robust
- [Introspection] Fixed issue with plugin cache invalidation
- [Report] Using Stopwatch.GetTimestamp() instead of Stopwatch instance in ReportJob
### 5.3.8
- [FSharp] Added stableSum and stableSumBy for List, Array, and Seq
- added basic BbTree implementation without operations
### 5.3.7
- Marked quaternion to matrix conversion obsolete as it is misleading
- Added conversions between ranges and 2D vectors
- Added Lerp and InvLerp for integer ranges and boxes
- Unified native dependency unpacking and added Aardvark.UnpackAndListNativeDependencies
### 5.3.6
- Updated System.Text.Json dependency (CVE-2024-43485)
- Added angle conversion utilities for ranges
- Added Ray3.Transformed overloads
- Added Ray3.Normalized
- Added Vec.AngleBetweenSigned for 2D vectors
- Added Fun.WrapToPi
- Added 2D ray-circle intersection methods
### 5.3.5
- [Base] added IsEmpty/IsEmptyOrNull overloads for Array/ICollection with efficient implementation
- [Base] added FindValue and FindNeighboursV to SortedSet
- [FSharp] changed MemoryManager/FreeList to use value tuples/options and use new SortedSet methods
- [FSharp] added Path.normalizeDirectorySeparators
- [FSharp] fixed Path.withTrailingSlash and Path.withoutTrailingSlash to consider Path.AltDirectorySeparatorChar
### 5.3.4
- [FSharp] Moved pin utilities to modules; added pinArri, temp
- Prevent multiple invocations of Aardvark.Init
- Added new PixProcessor API for plugin-based scaling, rotating and remapping of images (replaces PixImage.SetScaledFun et al.)
### 5.3.3
- Optimized ReferenceCountingSet (struct enumerator, internal struct tuples)
- Restored MD5 hashing extensions (fixes: https://github.com/aardvark-platform/aardvark.base/issues/72)
- [Introspection] Native libraries are now unpacked to the default Aardvark cache directory with subfolders for each platform (fixes: https://github.com/aardvark-platform/aardvark.base/issues/81).
- [Introspection] Improved support for single file deployment. Fixed plugin loading and caching (fixes: https://github.com/aardvark-platform/aardvark.base/issues/65).
- [Introspection] Made assembly loading more robust for NET 8. If an assembly cannot be resolved the entry path is checked for the assembly file, making it possible to load assemblies by name that are not runtime or compilation dependencies (see also: https://github.com/Particular/Workshop/issues/64).
- [FSharp] Added RequireQualifiedAccess attribute to ProcListValue
- [FSharp] Added RequireQualifiedAccess attribute to Tree
- [FSharp] Added pin, pinArr, and NativePtr.Address
- Added Stream.ReadBytes extension
### 5.3.2
- [FSharp] Revert LookupTable utilities to use lists instead of seq
### 5.3.1
- [FSharp] Added Stream.readAllBytes
- [FSharp] Added Path.withTrailingSlash and withoutTrailingSlash
- [FSharp] Added approximateEquals
- [FSharp] Reworked LookupTable utilities
- [FSharp] Optimized and reworked type patterns
- [FSharp] Imported PrimitiveValueConverter from Aardvark.Rendering
### 5.3.0
- https://github.com/aardvark-platform/aardvark.base/wiki/Aardvark-5.3-changelog
### 5.3.0-prerelease0005
- Reintroduced `IPixImage` as `IPix`
- Renamed `PixImageCube` to `PixCube`
### 5.3.0-prerelease0004
- Fixed PixImage/Volume conversion with redundant channels
- Added Width, Height, and Depth properties for PixImage and PixVolume
### 5.3.0-prerelease0003
- Restored Error<'T>
- [PixImageMipMap] Re-added PixFormat and reverted rename of ImageArray field
- [PixImageMipMap] Renamed Count to LevelCount
- [PixImageCube] Reverted rename of MipMapArray field
- [PixLoader] Added CanEncode and CanDecode
- Made Array and Data of PixImage and PixVolume consistent with tensors
### 5.3.0-prerelease0002
- Removed Result<'T> alias
- [FSharpMath] Fixed conflicts in SRTP member names with .NET
- [Color] Added Fun.Lerp overloads with vector parameter
### 5.3.0-prerelease0001
- Initial prerelease
### 5.2.32
- Fixed Type.GetCLRSize for structs
- Use .NET functions for Array.Copy and Set
- Fixed Array CopyTo extension overloads for copying between an array and native memory
- Changed SymMapBaseCollectionTraversal.Collect typeName argument to Symbol
- Added ToBase64 extensions with span
- Added generic Compute**Hash overloads (avoiding GetCLRSize)
- Added AsCastSpan extension
### 5.2.31
* fixed Hash Computations for non-primitive types
* added `AsByteSpan` extension method for System.Array/string in >=net6.0
### 5.2.30
* removed UnsafeCoerce usages and several other net6.0+ fixes
### 5.2.29
* Fixed color parsing to be independent of the current culture (regression in 5.2.27)
* Added more value variants for Dictionary, Dict, and SymbolDict functions
### 5.2.28
* Added Brewer color schemes
* Added String.replace
* Added IDictionary.TryPop overload with output argument
### 5.2.27
* Improved and fixed RangeSet implementation
* Added utilities for ValueOption
* Added more ArraySegment utilities
* [Text] Fixed NestedBracketSplitCount
* [Color] Fixed overflow issue in C4ui constructors
* [Color] Improved color parsing, now supports hexadecimal color strings
* [PixImage] Fixed file handle leak in Windows Media loader
* [MapExt] Added value variants of some operations
### 5.2.26
* LinearRegression3d: made fields public
* Added getLines, normalizeLineEndings, withLineNumbers in String module
* Fixed FGetValueOrDefault dictionary extension
* Added value variants for Dict functions
* Added F# ArraySegment utilities
* [Introspection] Tidied up exception reporting
### 5.2.25
* Fixed issue with PixImageMipMap loading
* Improved exception message of EnumHelpers methods
* [Introspection] Use XML serialization for plugin cache
* Replaced netcoreapp3.1 target with net6.0
### 5.2.24
* fixed and optimized Cell.Contains
* update Aardvark.Build to 1.0.19
### 5.2.23
* Fixed build for VS 2019 / .NET 6
### 5.2.22
* Fixed RandomSample.Lambertian internal calculation precision
* Added float bits method overloads for unsigned vectors
* Use reflection-based PixImageMipMap creation
* [TypeInfo] Added color-related types and patterns
* [Trafo] Implemented infinite far plane for perspective projection
* [Trafo] Added reversed perspective projection variants
* [Introspection] Increased verbosity level of custom attribute error
### 5.2.21
* Made non-generic PixImage creation more flexible and robust
* Added NativePtr.Item and NativePtr.Value
* Added Buffer.MemoryCopy overloads with nativeint arguments
### 5.2.20
* [Base] added float overloads to RandomSample methods
* [Base] changed array memory copies to use Buffer.MemoryCopy
* [PixImage] respect channel order in format and type conversion
* [PixImage] improved support for dual-channel images
* [PixImage] fixed and improved format conversion
* [Tensors] added simple accessors for Gray and BW
* [Vrml] added support for gzip compressed files
* [Vrml] allow registration of custom field parsers
* [Vrml] improved robustness in case of unknown field tokens
### 5.2.19
* Added IPixMipmapLoader for loading images with mipmap chains
* Marked some exotic image loading functions obsolete
### 5.2.18
* made introspection attribute querying more robust
### 5.2.17
* JSON support
- add missing Range1* types
- handling of special float values (NaN, +Inf, -Inf)
* Add Vec.w
* Update Aardvark.Build
### 5.2.16
* support System.Text.Json for primitive types
(vectors, matrices, boxes, transforms, geometric primitives, ...)
### 5.2.15
* Added File.writeAll* variants that create parent directories
* [IO] Added logging output in case there is a stream position mismatch
* [PixImage] Print path when loading from file stream
### 5.2.14
* Updated to ImageSharp 2.1
* Implemented default PixImage scaling function
* Configurable PixImage functions throw proper exceptions
* Added float16 support for PixImageMipMap
* [Introspection] changed logging message when using CustomEntryAssembly from warning to normal
### 5.2.13
* Added uint32 vector types (V2ui, V3ui, V4ui)
* Added Disposable.empty
* Inlined color conversion methods, deprecating lambdas
* Implemented color conversions for Float16
* [Patterns] Added 2x3 matrices
### 5.2.12
* Added Fun.PowerOfTwo for int32 vectors
* [FSharpMath] Added exp2, step, and linearstep
* [Patterns] Added missing vector and matrix types
* Added Fun.Step and Fun.Linearstep
### 5.2.11
* [Ag] Removed compiler message
### 5.2.10
* fixed VRML transformations (missing normalization)
### 5.2.9
* Executable memory tools are now obsolete (use Aardvark.Assembler nuget package instead)
### 5.2.8
* revert obsolete AMD64 assembler to original behaviour
### 5.2.7
* fixed AMD64 assembler Begin/End (saving callee saved registers)
### 5.2.6
- [PixImage.SystemDrawing] removed System.Drawing.Common upper version constraint
- [IO] BinaryReadingCoder: patch object reference after converter/proxy conversion (#77)
### 5.2.5
- Ported System.Drawing bitmap extensions to new PixLoader API (renamed to Aardvark.PixImage.SystemDrawing)
- Added Aardvark.PixImage.WindowsMedia
- Added Trafo.(Inv)TransformPosProj(Full)
- Added constructors and comments for tensor info structs
### 5.2.4
- Added new API for PixImage loading and saving
- Added PixImage.meanSquaredError and PixImage.peakSignalToNoiseRatio
- Moved System.Drawing primitives extensions to Aardvark.Base.SystemDrawingInterop
### 5.2.3
- Added transform methods for Trafo types
- Added float32 overload for WeightedSum
- Fixed Plane3d.Transformed methods
- Added remainder operator for vector types
- Made Col.FormatDefaultOf more flexible
- [Report] Create directory for log file if it does not exist
- Added RangeSet64
### 5.2.2
- [ImageSharp] Implemented proper per row processing
### 5.2.1
- [ImageSharp] Switched to contiguous image buffers
### 5.2.0
- https://github.com/aardvark-platform/aardvark.docs/wiki/Aardvark-5.2-changelog
### 5.1.27
- added Transformed method for MatrixInfo and VolumeInfo
- fixed ldconfig regex for entries with ABI
### 5.1.26
- added PixImage and PixVolume related extensions to native tensors
- added PolyRegion2d.Overlaps(Box2d)
- fixed byte color indexing
- removed unnecessary DevILSharp references
- added Map.unionMany
- fixed Ceres native unpack
- workaround for loading native IPP dependencies
### 5.1.25
- another SHA1 truncate
### 5.1.24
- "simulated" MD5 via truncated SHA1 (please don't hit me security bubble)
### 5.1.23
- switched MD5 to SHA1
### 5.1.22
- updated to FSharp.Core >= 5.0.0
### 5.1.21
- [Report] workaround for getting/setting Console.ForegroundColor when not available. added `NoTarget` to Report for disabling
### 5.1.20
- add Cell.GetCommonRoot(...) and corresponding constructor overloads; same for Cell2d
### 5.1.19
- fixed cell-from-box constructor for boxes with Max including 0.0
- Relax asserts in matrix and rot methods and constructors
### 5.1.18
- cleaned up and fixed cell construction from boxes
### 5.1.17
- Add Fun.Log2CeilingInt
- Fix power of two edge cases in Cell and Cell2d
### 5.1.16
- updated build script
- fixed PixImage.CreateRaw loader fallback
- fixed default AssemblyFilter
- fixed Introspection ignoring GLSLangSharp
- unbreak Cell to work with fixed Log2Int (same for Cell2d)
### 5.1.15
- added functions for computing mipmap level count and size
- added support for signed integer PixImages
- changed default introspection cache location to LocalApplicationData
- fixed Log2Int
- fixed missing FileStream Dispose in Vrml97 parser
### 5.1.14
- fixed Introspection caching
### 5.1.13
- added Plane2d.Intersects overload that was removed accidentally
### 5.1.12
- added missing XmlIgnore attribute to vector swizzles
- added ValuesWithKeyEnumerator to Dicts
- preparations for .net 5 single file deployment
- added missing finite checks to vectors and matrices
- added vector variants for Fun.FloatToBits and Fun.FloatFromBits
- fixed Box2d - Line2d intersection test
- fixed Plane2d - Ray2d intersection test
- fixed polygon extensions
### 5.1.11
- added some IAssemblerStream methods (AddInt, MulInt, etc.)
### 5.1.10
- fixed mscorlib recursive resource lookup (#61)
- added Constant<T> initialization (#59)
### 5.1.9
- removed System.Reactive depdendency
- raised FSharp.Core version to >= 4.7.0
### 5.1.8
- added polygon transformataions (#57)
- prioritization of custom images loaders: considering last registered first
- consistency and completeness of Ray3d.Hits overloads
- changed Ray3d.Hits default range to [0, double.MaxValue]
### 5.1.6
- fixed Fun.Frac for tiny negative numbers
- added invLerp to FSharpMath
### 5.1.5
- devil loader functions are now public
### 5.1.4
- updated to FSharp.Data.Adaptive 1.2
- added IEquatable to math types
- added Array.binarySearch
### 5.1.3
- udpated build script
### 5.1.2
- testing
- new package mechanism
### 5.1.1
- switched to FSharp.Data.Adaptive 1.1
================================================
FILE: ai/ALGORITHMS.md
================================================
# Aardvark.Base Algorithms Reference
Source-verified map of key algorithm types and entry points.
## ShortestPath<T>
`ShortestPath<T>` implements `IShortestPath<T>` and runs asynchronous shortest-path computation.
Key methods:
- `CalculateShortestPaths(T seed)`
- `CalculateShortestPathsByIndex(int seedIndex)`
- `GetMinimalPath(T target)`
- `GetMinimalPathByIndex(int targetIndex)`
- `Cancel()`
Constructors:
```csharp
new ShortestPath<T>(List<T> nodes, List<(int,int)> edges, Func<T,T,float> getCost);
new ShortestPath<T>(T[] nodes, List<int>[] neighbors, Func<T,T,float> getCost);
```
## BbTree
Bounding-box hierarchy in `Geometry/BbTree.cs`.
Constructor:
```csharp
new BbTree(Box3d[] boundingBoxes, BbTree.BuildFlags flags = BbTree.BuildFlags.Default, int[] countArray = null);
```
Useful members:
- `NodeCount`
- `Box3d`
- `IndexArray`
- `LeafArray`
- `LeftBoxArray`
- `RightBoxArray`
- `GetLeft(i)`, `GetRight(i)`
`BbTreeHit` contains `NodeIndex` and `RayT`.
## Linear Algebra Numerics
Available in `Math/LuFactorization.cs` and `Math/QrFactorization.cs`:
- `LuFactorize`
- `LuSolve`
- `LuInverse`
- `QrFactorize`
`LuFactorize` is in-place.
## Probability Sampling
### Alias tables
Types:
- `AliasTableF`
- `AliasTableD`
Construction/update:
```csharp
var t = new AliasTableD(pdf, 1.0 / pdf.Sum());
t.Update(newPdf, 1.0 / newPdf.Sum());
int index = t.Sample(rnd.UniformDouble());
```
`FromPdf` / `FromNormalizedPdf` exist as instance methods on the class.
### DistributionFunction
`DistributionFunction` provides CDF-based sampling:
```csharp
var d = new DistributionFunction(pdf);
int i = d.Sample(rnd);
int j = DistributionFunction.SampleCDF(d.CDF, rnd.UniformDouble());
```
## Polynomial
`Polynomial` is in `Math/Numerics/Polynomial.cs` (not `Math/Base`).
Examples:
- `coeff.Evaluate(x)`
- `coeff.Derivative()`
- `Polynomial.RealRootsOfNormed(...)`
## Source Anchors
- `src/Aardvark.Base/AlgoDat/ShortestPath.cs`
- `src/Aardvark.Base/Geometry/BbTree.cs`
- `src/Aardvark.Base/Math/LuFactorization.cs`
- `src/Aardvark.Base/Math/QrFactorization.cs`
- `src/Aardvark.Base/Math/Base/AliasTable_auto.cs`
- `src/Aardvark.Base/Math/Base/DistributionFunction.cs`
- `src/Aardvark.Base/Math/Numerics/Polynomial.cs`
================================================
FILE: ai/COLLECTIONS.md
================================================
# Aardvark.Base Collections Reference
Source-verified reference for custom collection and symbol infrastructure.
## Symbol and TypedSymbol
`Symbol` is interned and integer-backed.
```csharp
Symbol s0 = Symbol.Create("name");
Symbol s1 = "name"; // implicit conversion
Symbol s2 = Symbol.Create(Guid.NewGuid());
Symbol empty = Symbol.Empty;
Symbol neg = -s0; // negative key variant
```
Important members:
- `Id`
- `IsEmpty` / `IsNotEmpty`
- `IsPositive` / `IsNegative`
- `ToGuid()`
`TypedSymbol<T>` provides compile-time value type pairing for typed dictionary access.
## Dict Family
Main types in `Symbol/Dict_auto.cs`:
- `Dict<TKey, TValue>`
- `DictSet<TKey>`
- `SymbolDict<TValue>`
- `SymbolSet`
Common helpers:
- `GetOrCreate(...)`
- `TryRemove(...)`
- `ValuesWithKey(...)`
`SymbolDict<T>` also has typed overloads:
- `Add<TType>(TypedSymbol<TType> key, TType value)`
- `Get<TType>(TypedSymbol<TType> key)`
- `TryGetValue<TType>(TypedSymbol<TType> key, out TType value)`
## LruCache<TKey, TValue>
`LruCache` is synchronized and capacity-driven.
Constructors:
```csharp
new LruCache<TKey, TValue>(capacity);
new LruCache<TKey, TValue>(capacity, sizeFun, readFun, deleteAct);
```
Key operations:
- indexer `cache[key]` (auto-load with `readFun`)
- `GetOrAdd(...)`
- `TryRemove(...)`
- `Remove(...)`
- mutable `Capacity` (can trigger eviction)
## ConcurrentHashSet<T>
Defined in namespace `System.Collections.Concurrent`.
Core operations:
```csharp
set.Add(item);
set.Remove(item); // no TryRemove API on this type
set.Contains(item);
set.Clear();
set.UnionWith(other);
```
## SingleEntryDict
`SingleEntryDict<TKey, TValue>` exists in `Symbol/Dicts.cs` and is optimized for one optional key/value entry. It supports normal `IDict<TKey, TValue>` lookup, removal, and re-adding the configured key after removal.
## Source Anchors
- `src/Aardvark.Base/Symbol/Symbol.cs`
- `src/Aardvark.Base/Symbol/Dict_auto.cs`
- `src/Aardvark.Base/Symbol/Dicts.cs`
- `src/Aardvark.Base/Symbol/IDict.cs`
- `src/Aardvark.Base/AlgoDat/LruCache.cs`
- `src/Aardvark.Base/AlgoDat/ConcurrentHashSet.cs`
================================================
FILE: ai/DOC_ACCURACY_AUDIT.md
================================================
# AI Docs Accuracy Audit
Audit baseline for coding-agent docs in this repository.
## Last Audit
- Date: 2026-02-26
- Scope: `AGENTS.md`, `ai/*.md`, `docs/*.md`, selected source anchors
## Verified Corrections in This Audit
1. Added task-split docs for semantic depth:
- `ai/SEMANTICS_LINEAR_ALGEBRA.md`
- `ai/SEMANTICS_GEOMETRY_CORE.md`
2. Added symbol-first discovery index:
- `ai/SYMBOL_INDEX.md`
3. Rewrote inaccurate AI topic docs:
- `ai/UTILITIES.md`
- `ai/COLLECTIONS.md`
- `ai/ALGORITHMS.md`
- `ai/PIXIMAGE.md`
- `ai/TENSORS.md`
4. Corrected user-facing docs that had stale command guidance:
- `docs/CONTRIBUTING.md`
- `docs/INTEROP.md`
- `docs/TROUBLESHOOTING.md`
5. Added drift tooling:
- `tools/DocsChecker/*`
- `check-docs.sh`
- `check-docs.cmd`
- `.github/workflows/docs-check.yml`
## Known High-Risk Drift Areas
- Generated code APIs (`*_auto.cs`, `*_auto.fs`)
- Cross-language dependencies between C# and F# projects
- Matrix/transform semantics and interop assumptions
- Pix/tensor APIs where historical examples often reference removed overloads
## Maintenance Rule
If a PR changes public API behavior or key semantics:
1. Update the relevant doc in `ai/` or `docs/`.
2. Run docs checker (`./check-docs.sh` or `.\check-docs.cmd`).
3. Keep source anchors in sync with actual file locations/symbol names.
## Rules Touched In This Iteration
Docs checker hardening added:
1. Expanded required file coverage to additional AI topic docs.
2. Expanded forbidden/required pattern checks for common stale examples.
3. Expanded source-anchor coverage across primitives, tensors/pix, telemetry/random, collections, and algorithms.
4. Added fixture-based checker tests (`tools/DocsChecker.Tests`).
5. Enabled Linux + Windows hard-fail docs-check workflow matrix.
================================================
FILE: ai/FSHARP_INTEROP.md
================================================
# Aardvark.Base F# Interop Reference
AI-targeted reference for using Aardvark.Base types from F#. Covers modules, extension functions, and idiomatic patterns.
---
## Namespace and Module Structure
### Common Open Statements
```fsharp
open Aardvark.Base // Core types: V3d, M44d, Box3d, etc.
open Aardvark.Base.Sorting // Sorting extension methods
```
### Module Hierarchy
| Namespace | Contents |
|-----------|----------|
| `Aardvark.Base` | All primitive types + F# modules |
| `Aardvark.Base.Sorting` | Array sorting extensions |
---
## Vec Module
Functional wrappers for vector operations. Works with any vector type (V2d, V3f, V4i, etc.).
```fsharp
open Aardvark.Base
// Dot product
let d = Vec.dot V3d.XAxis V3d.YAxis // 0.0
// Cross product (3D only)
let c = Vec.cross V3d.XAxis V3d.YAxis // V3d.ZAxis
// Length and normalization
let len = Vec.length V3d.One // sqrt(3)
let lenSq = Vec.lengthSquared V3d.One // 3.0
let unit = Vec.normalize V3d.One // unit vector
// Distance
let dist = Vec.distance V3d.Zero V3d.One
let distSq = Vec.distanceSquared V3d.Zero V3d.One
// Swizzles
let x = Vec.x v3d
let xy = Vec.xy v3d // V2d
let xyz = Vec.xyz v4d // V3d
// Reflection/refraction
let refl = Vec.reflect normal incident
let refr = Vec.refract eta normal incident
// Component-wise comparisons
Vec.anySmaller V3d.One V3d.Zero // false
Vec.allGreater V3d.One V3d.Zero // true
Vec.anyEqual v1 v2
Vec.allDifferent v1 v2
```
---
## Mat Module
Functional wrappers for matrix operations.
```fsharp
open Aardvark.Base
// Transpose, determinant, inverse
let mt = Mat.transpose M33d.Identity
let d = Mat.det M22d.Identity
let inv = Mat.inverse M33d.Identity
// Transform vectors
let v4 = Mat.transform M44d.Identity V4d.One
let pos = Mat.transformPos M44d.Identity V3d.One // w=1
let dir = Mat.transformDir M44d.Identity V3d.One // w=0
let proj = Mat.transformPosProj M44d.Identity V3d.One // with perspective divide
// Component-wise comparisons
Mat.anyEqual m1 m2
Mat.allSmaller m1 m2
```
---
## Trafo Module
Functional wrappers for transformation types.
```fsharp
open Aardvark.Base
let t = Trafo3d.Translation(V3d(1, 2, 3))
// Access matrices
let fwd = Trafo.forward t // M44d forward matrix
let bwd = Trafo.backward t // M44d inverse matrix
// Invert
let inv = Trafo.inverse t
// Compose and transform
let pos = V3d.Zero |> Mat.transformPos (t |> Trafo.forward)
```
---
## Lens System
Functional lenses for immutable state updates. Used extensively with Adaptify-generated models.
### Lens Type
```fsharp
type Lens<'s, 'a> =
abstract Get : 's -> 'a
abstract Set : 's * 'a -> 's
abstract Update : 's * ('a -> 'a) -> 's
```
### Operators
| Operator | Signature | Description |
|----------|-----------|-------------|
| `\|.` | `Lens<'s,'a> -> Lens<'a,'b> -> Lens<'s,'b>` | Compose lenses |
| `\|?` | `Lens<'s, Option<'a>> -> 'a -> Lens<'s,'a>` | Default for None |
### Usage
```fsharp
open Aardvark.Base
// Adaptify generates lenses like Model.position_
// Compose with |. operator
let nestedLens = Model.inner_ |. Inner.value_
// Get value
let v = nestedLens.Get model
// Set value
let model' = nestedLens.Set(model, newValue)
// Update value
let model'' = nestedLens.Update(model, fun v -> v + 1)
```
### Predefined Lenses
```fsharp
// Set membership lens
Set.Lens.contains "item" // Lens<Set<string>, bool>
// Map item lens
Map.Lens.item "key" // Lens<Map<string,'v>, Option<'v>>
// List item lens
List.Lens.item 0 // Lens<list<'a>, Option<'a>>
```
---
## Color Module (ColorBrewer)
Color scheme generation for data visualization.
```fsharp
open Aardvark.Base
// Get sequential color scheme
let colors = ColorBrewer.getColors ColorBrewer.SchemeType.Sequential "Blues" 5
// Available scheme types
ColorBrewer.SchemeType.Sequential // Light to dark
ColorBrewer.SchemeType.Diverging // Two-ended
ColorBrewer.SchemeType.Qualitative // Distinct categories
```
---
## Interop Modules
F# extensions for .NET collections.
### Dictionary Extensions
```fsharp
open Aardvark.Base
let dict = System.Collections.Generic.Dictionary<string, int>()
// F#-style access
dict.["key"] <- 42
let v = dict.["key"]
// TryFind returns Option
match dict.TryFind "key" with
| Some v -> ...
| None -> ...
```
### HashSet Extensions
```fsharp
open Aardvark.Base
let set = System.Collections.Generic.HashSet<int>()
// Set operations return new sets
let union = set.Union otherSet
let inter = set.Intersect otherSet
```
---
## Memory and Native Utilities
### MicroTime (High-Resolution Timing)
```fsharp
open Aardvark.Base
let start = MicroTime.Now
// ... work ...
let elapsed = MicroTime.Now - start
printfn "Elapsed: %A" elapsed
```
### Mem (Memory Sizes)
```fsharp
open Aardvark.Base
let size = Mem.mebibytes 512L
printfn "%d bytes" size.Bytes
```
---
## Common Patterns
### Pipeline with Transformations
```fsharp
let result =
V3d.Zero
|> Mat.transformPos (Trafo3d.Translation(V3d.One) |> Trafo.forward)
|> Mat.transformDir (Trafo3d.RotationZ(Constant.Pi) |> Trafo.forward)
```
### Lens-Based State Updates
```fsharp
// Update nested model immutably
let model' =
model
|> (Model.camera_ |. Camera.position_).Set(V3d(0, 0, 10))
|> (Model.camera_ |. Camera.target_).Set(V3d.Zero)
```
### Vector Comparisons in Conditionals
```fsharp
if Vec.allSmaller point boxMax && Vec.allGreater point boxMin then
// point is inside box
()
```
---
## Gotchas
1. **Module Suffix Convention**: F# modules like `Vec`, `Mat`, `Trafo` use `CompilationRepresentationFlags.ModuleSuffix` to avoid name collisions with types. Don't confuse `Vec` (module) with `V3d` (type)
2. **Inline Functions**: Most `Vec` and `Mat` functions are `inline` with SRTP constraints. This means they work on any type with matching static members, but error messages can be cryptic if types don't match
3. **Lens Composition Order**: `outer |. inner` reads left-to-right (outer first, then inner). This is opposite to function composition `>>`. Think of `|.` as "then focus on"
4. **Option Lenses**: `Map.Lens.item` returns `Lens<_, Option<_>>`. Use `|?` operator to provide a default, or handle `None` explicitly
---
## See Also
- [PRIMITIVE_TYPES.md](PRIMITIVE_TYPES.md) - C# API reference for V3d, M44d, Trafo3d (same types, method syntax)
- [COLLECTIONS.md](COLLECTIONS.md) - Symbol and SymbolDict (usable from F# with same API)
- [ALGORITHMS.md](ALGORITHMS.md) - Graph and spatial algorithms callable from F#
================================================
FILE: ai/INCREMENTAL.md
================================================
# Incremental/Adaptive System
Reactive computation with automatic dependency tracking. Values form a DAG; changes propagate lazily through dependencies.
## Architecture
Built on **FSharp.Data.Adaptive** (external NuGet package). Aardvark.Base.Incremental adds:
- `afun` - adaptive functions
- `astate` - stateful adaptive computations
- `Controller` - UI-like state with previous-value tracking
- `astream` - event streams with history (experimental)
- `Proc` - cancellable continuations
Namespace: `FSharp.Data.Adaptive` (core types from external package)
## Core Types
### Adaptive Values
| Type | Description |
|------|-------------|
| `aval<'a>` / `IAdaptiveValue<T>` | Read-only adaptive value |
| `cval<'a>` / `ChangeableValue<T>` | Mutable adaptive value (source) |
```fsharp
// F#
let counter = cval 0
let doubled = counter |> AVal.map ((*) 2)
let value = AVal.force doubled // 0
```
```csharp
// C#
var counter = new ChangeableValue<int>(0);
var doubled = counter.Map(x => x * 2);
int value = doubled.GetValue(); // 0
```
### Adaptive Collections
| Type | C# Type | Delta Type |
|------|---------|------------|
| `aset<'a>` | `ChangeableHashSet<T>` | `HashSetDelta<T>` |
| `amap<'k,'v>` | `ChangeableHashMap<K,V>` | `HashMapDelta<K,V>` |
| `alist<'a>` | `ChangeableIndexList<T>` | `IndexListDelta<T>` |
Collections track changes via delta objects. Use readers to get incremental updates.
```csharp
// C#
var set = new ChangeableHashSet<int>(new[] { 1, 2, 3 });
var filtered = set.Filter(x => x > 1);
var reader = filtered.GetReader();
// Get deltas since last read
var deltas = reader.GetChanges(AdaptiveToken.Top);
foreach (var d in deltas)
{
if (d.Count > 0) Console.WriteLine($"add {d.Value}");
else Console.WriteLine($"rem {d.Value}");
}
```
## Transactions
Mutations must occur inside transactions. Changes batch until transaction ends.
```fsharp
// F#
transact (fun () ->
counter.Value <- 1
counter.Value <- 2 // only final value propagates
)
```
```csharp
// C#
using (Adaptive.Transact)
{
counter.Value = 1;
counter.Value = 2; // only final value propagates
}
```
### AdaptiveToken
Tracks evaluation context and dependencies. Use `AdaptiveToken.Top` for top-level reads.
```fsharp
let value = myAVal.GetValue(AdaptiveToken.Top)
```
```csharp
var value = myAVal.GetValue(AdaptiveToken.Top);
```
## F# Operators
From `FSharp.Data.Adaptive.Operators`:
| Operator | Description | Example |
|----------|-------------|---------|
| `%+` | Adaptive add | `a %+ b` |
| `%-` | Adaptive subtract | `a %- b` |
| `%*` | Adaptive multiply | `a %* b` |
| `%/` | Adaptive divide | `a %/ b` |
| `%&&` | Adaptive AND | `a %&& b` |
| `%||` | Adaptive OR | `a %|| b` |
| `%?` / `%.` | Conditional | `cond %? trueVal %. falseVal` |
| `!!` | Force value | `!!aval` |
| `~~` | Make constant | `~~42` |
```fsharp
open FSharp.Data.Adaptive.Operators
let a = cval 10
let b = cval 20
let sum = a %+ b // aval<int> = 30
let forced = !!sum // int = 30
let const = ~~100 // aval<int> (constant)
```
## Adaptive Functions (afun)
Functions that depend on adaptive values. Re-evaluated when dependencies change.
```fsharp
type afun<'a, 'b> // IAdaptiveFunc in C#
```
### AFun Module
| Function | Description |
|----------|-------------|
| `AFun.create f` | Wrap pure function |
| `AFun.constant v` | Always return v |
| `AFun.bind f m` | Bind aval to afun |
| `AFun.compose g f` | Compose: f then g |
| `AFun.apply v f` | Apply afun to aval |
| `AFun.run v f` | Run afun with constant input |
```fsharp
// Builder syntax
let myFunc = afun {
let! scale = scaleAVal
return fun x -> x * scale
}
// Composition
let combined = f >>. g // f then g
let combined = g <<. f // same as above
```
### Integration
```fsharp
let result : aval<'b> = AFun.apply inputAVal myFunc
```
## Adaptive State (astate)
Stateful computations that thread state through evaluation.
```fsharp
type astate<'s, 'a> = { runState: afun<'s, 's * 'a> }
```
### AState Module
| Function | Description |
|----------|-------------|
| `AState.create v` | Return value, preserve state |
| `AState.map f m` | Transform result |
| `AState.bind f m` | Sequence computations |
| `AState.getState` | Get current state |
| `AState.putState s` | Replace state |
| `AState.modifyState f` | Transform state |
```fsharp
let computation = astate {
let! current = AState.getState
do! AState.modifyState ((+) 1)
return current
}
```
### Controller Pattern
Tracks previous values across evaluations. Used for UI-like delta computation.
```fsharp
type Controller<'a> = astate<ControllerState, 'a>
```
| Function | Description |
|----------|-------------|
| `withLast aval` | Get `(previous, current)` tuple |
| `pre aval` | Get previous value |
| `differentiate aval` | Get `current - previous` |
```fsharp
let deltaController = controller {
let! (prev, curr) = withLast positionAVal
return curr - prev // movement delta
}
let myFunc : afun<'a, 'b> = controller.Run(deltaController)
```
## Adaptive Streams (astream)
Event streams with timestamped history. **Experimental** - namespace: `Aardvark.Base.Incremental.Experimental`
```fsharp
type astream<'a> // IAdaptiveStream in C#
type EventHistory<'a> =
| Cancel
| Faulted of Exception
| History of list<DateTime * 'a>
```
### IStreamReader
```fsharp
type IStreamReader<'a> =
inherit IDisposable
inherit IAdaptiveObject
abstract GetHistory : IAdaptiveObject -> EventHistory<'a>
abstract SubscribeOnEvaluate : (EventHistory<'a> -> unit) -> IDisposable
```
### EventHistory Module
| Function | Description |
|----------|-------------|
| `EventHistory.empty` | Empty history |
| `EventHistory.map f h` | Transform events |
| `EventHistory.choose f h` | Filter/transform |
| `EventHistory.filter f h` | Filter events |
| `EventHistory.union l r` | Merge histories |
| `EventHistory.concat hs` | Concatenate list |
## Proc (Cancellable Continuations)
Continuation-based async with cancellation support.
```fsharp
type Proc<'a, 'r>
type ProcResult<'a> =
| Value of 'a
| Cancelled
| Faulted of exn
```
### Creating Procs
| Method | Description |
|--------|-------------|
| `Proc.Create v` | Immediate value |
| `Proc.Await task` | Await Task<T> |
| `Proc.Await async` | Await Async<T> |
| `Proc.Await sem` | Await SemaphoreSlim |
| `Proc.Sleep ms` | Delay |
### Running Procs
| Method | Description |
|--------|-------------|
| `Proc.RunSynchronously(p, ?ct)` | Block until complete |
| `Proc.StartAsTask(p, ?ct)` | Return Task<ProcResult> |
| `Proc.Start(p, ?ct)` | Fire and forget |
### Builder Syntax
```fsharp
let download url = proc {
let! response = httpClient.GetAsync(url)
let! content = response.Content.ReadAsStringAsync()
return content
}
// Run with cancellation
use cts = new CancellationTokenSource()
let result = Proc.RunSynchronously(download "http://...", cts.Token)
match result with
| Value content -> printfn "Got: %s" content
| Cancelled -> printfn "Cancelled"
| Faulted e -> printfn "Error: %A" e
```
## ChangeTracker
Detect value changes with memoization. Used internally by afun/astate.
```fsharp
// Default equality
let hasChanged = ChangeTracker.track<MyType>
if hasChanged newValue then
// value changed since last call
// Custom equality
let hasChanged = ChangeTracker.trackCustom (Some myEqualityFn)
```
## Common Patterns
### Reactive Collection Processing
```csharp
var items = new ChangeableHashSet<Item>();
var processed = items
.Filter(x => x.IsActive)
.Map(x => ProcessItem(x));
var reader = processed.GetReader();
// On each frame/update:
var changes = reader.GetChanges(AdaptiveToken.Top);
ApplyChanges(changes);
```
### Nested Collections (SelectMany)
```csharp
var outer = new ChangeableHashSet<IAdaptiveHashSet<int>>();
var flattened = outer.SelectMany(x => x);
// flattened updates when outer or any inner set changes
```
### Constant Optimization
```fsharp
// Check if value is constant (never changes)
if myAVal.IsConstant then
// Can cache result permanently
```
## Gotchas
1. **Always use transactions** - mutations outside `transact`/`Adaptive.Transact` throw
2. **Force outside transactions** - calling `GetValue`/`AVal.force` inside transact can cause reentrancy issues
3. **Dispose readers** - `IStreamReader` and collection readers hold references; dispose when done
4. **astream is experimental** - namespace is `Aardvark.Base.Incremental.Experimental`, API may change
5. **Proc vs Async** - Proc is simpler continuation-based; use for UI/rendering pipelines, Async for I/O
6. **Controller state** - `ControllerState` tracks pulled values between evaluations; initialize via `controller.Run`
## See Also
- [FSHARP_INTEROP.md](FSHARP_INTEROP.md) - F# modules and functional patterns
- FSharp.Data.Adaptive documentation: https://fsprojects.github.io/FSharp.Data.Adaptive/
================================================
FILE: ai/PIXIMAGE.md
================================================
# Aardvark.Base Pix/Image Reference
Source-verified orientation for `PixImage`, `PixVolume`, and related types.
## Core Types
- `PixImage` / `PixImage<T>`
- `PixVolume` / `PixVolume<T>`
- `PixCube`
- `PixImageMipMap`
- `PixFormat`
- `PixFileFormat`
- `PixProcessorCaps`
## Loading and Info
Static load methods are on non-generic `PixImage`:
```csharp
PixImage img = PixImage.Load("a.png");
PixImage img2 = PixImage.Load(stream);
PixImage raw = PixImage.LoadRaw("a.png");
PixImageInfo info = PixImage.GetInfoFromFile("a.png");
```
Typed load is via constructor:
```csharp
var typed = new PixImage<byte>("a.png");
```
No static `PixImage.Load<T>(...)` API exists.
## Saving
```csharp
img.Save("out.png");
img.Save("out.jpg", new PixJpegSaveParams(90));
img.Save(stream, PixFileFormat.Png);
img.SaveAsJpeg("out.jpg", 90);
img.SaveAsPng("out.png", 6);
```
## Processing and Conversion
Common `PixImage<T>` methods:
- `Resized(...)`
- `Scaled(...)`
- `Rotated(...)`
- `SubImage(...)` (view on shared storage)
- `ToPixImage<TOut>()`
- `ToFormat(Col.Format)`
- `ToImageLayout()`
- `GetChannel(long)` / `GetChannel(Col.Channel)`
`SubImage(...)` returns a view; edits affect shared data.
## Loaders and Processors
Loader hooks:
```csharp
PixImage.SetLoader(loader, priority);
PixImage.AddLoader(loader);
```
Processor lookup:
```csharp
var p = PixImage.GetProcessors(PixProcessorCaps.Scale);
```
`PixProcessorCaps` values:
- `None`
- `Scale`
- `Rotate`
- `Remap`
- `All`
## PixFormat and File Formats
`PixFormat` is defined in `Aardvark.Base` (`Color.cs`) as `(Type, Col.Format)`.
Common predefined values:
- `PixFormat.ByteGray`
- `PixFormat.ByteRGB`
- `PixFormat.ByteRGBA`
- `PixFormat.FloatGray`
- `PixFormat.FloatRGB`
`PixFileFormat` enum is in `PixImage.cs` and contains formats such as `Png`, `Jpeg`, `Bmp`, `Tiff`, `Exr`, `Webp`, and others.
## Mipmaps and Cubemaps
`PixImageMipMap`:
- `Load(string|Stream, IPixLoader?)`
- `Create(baseImage, interpolation, maxCount, powerOfTwo)`
- `LevelCount`
`PixCube`:
- six `PixImageMipMap` faces addressed by `CubeSide`
## Source Anchors
- `src/Aardvark.Base.Tensors.CSharp/PixImage/PixImage.cs`
- `src/Aardvark.Base.Tensors.CSharp/PixImage/PixVolume.cs`
- `src/Aardvark.Base.Tensors.CSharp/PixImage/PixCube.cs`
- `src/Aardvark.Base.Tensors.CSharp/PixImage/PixImageMipMap.cs`
- `src/Aardvark.Base.Tensors.CSharp/PixImage/PixProcessor.cs`
- `src/Aardvark.Base/Math/Colors/Color.cs`
================================================
FILE: ai/PRIMITIVE_TYPES.md
================================================
# Aardvark.Base Primitive Types Reference
Fast orientation for core math and geometry types in `Aardvark.Base`.
Use this with:
- `SEMANTICS_LINEAR_ALGEBRA.md` for matrix/vector layout and interop details
- `SEMANTICS_GEOMETRY_CORE.md` for geometry conventions and transform semantics
## Naming Convention
Pattern: `{TypeName}{Dimension}{Suffix}`
| Suffix | Meaning |
|--------|---------|
| `i` | `int` |
| `l` | `long` |
| `f` | `float` |
| `d` | `double` |
| `b` | `byte` |
Examples:
- `V3d` = 3D vector (`double`)
- `M44f` = 4x4 matrix (`float`)
- `Box3d` = 3D axis-aligned box (`double`)
## Important Reality
- Core vector/matrix structs are mutable value types (`struct`), not uniformly `readonly struct`.
- For matrix/vector math in 3D, prefer explicit methods (`TransformPos`, `TransformDir`) over ambiguous shorthand.
## Vector Families
Common families:
- `V2*`, `V3*`, `V4*`
- integer and floating-point variants (`i`, `l`, `f`, `d`)
Typical APIs:
```csharp
var a = new V3d(1, 2, 3);
var b = new V3d(4, 5, 6);
var dot = V3d.Dot(a, b);
var cross = V3d.Cross(a, b);
var dist = V3d.Distance(a, b);
var unit = a.Normalized;
```
## Matrix Families
Common families:
- `M22*`, `M23*`, `M33*`, `M34*`, `M44*`
### M44d Construction (Verified)
```csharp
var t = M44d.Translation(new V3d(1, 2, 3));
var s = M44d.Scale(new V3d(2, 2, 2));
var r = M44d.RotationZ(0.5);
var fromRows = M44d.FromRows(
new V4d(1, 0, 0, 0),
new V4d(0, 1, 0, 0),
new V4d(0, 0, 1, 0),
new V4d(0, 0, 0, 1)
);
var rot = Rot3d.RotationZ(0.5);
var rotAsMatrix = (M44d)rot;
```
### M44d Operations (Verified)
```csharp
var m = M44d.Translation(new V3d(1, 2, 3));
var p = m.TransformPos(new V3d(5, 6, 7)); // includes translation
var d = m.TransformDir(new V3d(0, 1, 0)); // ignores translation
var h = m * new V4d(5, 6, 7, 1); // valid homogeneous multiply
```
Notes:
- `M44d * V4d` and `V4d * M44d` are defined.
- `M44d * V3d` is not defined.
- `M44d.Transform(V3d)` is not a supported API; use `TransformPos`/`TransformDir`.
## Transformation Types
3D families:
- `Rot3*`, `Shift3*`, `Scale3*`, `Euclidean3*`, `Similarity3*`, `Affine3*`, `Trafo3*`
Typical `Trafo3d` usage:
```csharp
var trafo = Trafo3d.Translation(new V3d(1, 0, 0)) * Trafo3d.Scale(2.0);
var fwd = trafo.Forward; // M44d
var bwd = trafo.Backward; // M44d inverse
var p = trafo.TransformPos(new V3d(1, 2, 3));
```
## Geometry Core Families
Common primitives:
- `Box2*`, `Box3*`
- `Ray2*`, `Ray3*`
- `Plane2*`, `Plane3*`
- `Sphere3*`, `Circle2*`, `Circle3*`
- `Triangle2*`, `Triangle3*`
- `Hull2*`, `Hull3*`
Typical APIs:
```csharp
var box = new Box3d(V3d.Zero, V3d.One);
var ray = new Ray3d(V3d.Zero, V3d.XAxis);
var contains = box.Contains(new V3d(0.5, 0.5, 0.5));
var hit = ray.Hits(box, out double t);
```
## Gotchas
1. Matrix convention details (layout, multiplication side, interop) are critical for performance and correctness: use `SEMANTICS_LINEAR_ALGEBRA.md`.
2. `TransformPos` vs `TransformDir` matters for translation handling.
3. Subtle precision loss exists when converting from `d` variants to `f` variants.
## Source Anchors
- `src/Aardvark.Base/Math/Vectors/Vector_auto.cs` (`V3d`)
- `src/Aardvark.Base/Math/Trafos/Matrix_auto.cs` (`M44d`, transforms, operators)
- `src/Aardvark.Base/Math/Trafos/Rot3_auto.cs` (`Rot3d` to `M44d` cast)
- `src/Aardvark.Base/Math/RangesBoxes/Box_auto.cs` (`Box3d`)
- `src/Aardvark.Base/Geometry/Types/Ray/Ray3_auto.cs` (`Ray3d` hit methods)
================================================
FILE: ai/README.md
================================================
# Aardvark.Base AI Reference
Task-first docs for coding agents.
Goal: open one focused document, not the whole `ai/` folder.
## Fast Path
1. Find symbols in [SYMBOL_INDEX.md](SYMBOL_INDEX.md).
2. Open one task doc from the table below.
3. Verify critical names in source with `rg`.
## Task Docs
| Need | Read |
|------|------|
| Primitive math and geometry types | [PRIMITIVE_TYPES.md](PRIMITIVE_TYPES.md) |
| Matrix/vector layout and interop semantics | [SEMANTICS_LINEAR_ALGEBRA.md](SEMANTICS_LINEAR_ALGEBRA.md) |
| Geometry and transform semantics | [SEMANTICS_GEOMETRY_CORE.md](SEMANTICS_GEOMETRY_CORE.md) |
| Images, volumes, loaders, processors | [PIXIMAGE.md](PIXIMAGE.md) |
| Tensor containers, views, strides | [TENSORS.md](TENSORS.md) |
| Graph/spatial/numeric algorithms | [ALGORITHMS.md](ALGORITHMS.md) |
| Symbols, dicts, caches, concurrent set | [COLLECTIONS.md](COLLECTIONS.md) |
| Logging, telemetry, random, geodesy | [UTILITIES.md](UTILITIES.md) |
| Serialization/coder APIs | [SERIALIZATION.md](SERIALIZATION.md) |
| F# wrappers and idioms | [FSHARP_INTEROP.md](FSHARP_INTEROP.md) |
| Incremental/adaptive system | [INCREMENTAL.md](INCREMENTAL.md) |
## Meta Docs
| Need | Read |
|------|------|
| Symbol-to-doc lookup | [SYMBOL_INDEX.md](SYMBOL_INDEX.md) |
| Drift and accuracy audit log | [DOC_ACCURACY_AUDIT.md](DOC_ACCURACY_AUDIT.md) |
| AI-friendliness recipe for other repos | [RECIPE_AI_FRIENDLINESS.md](RECIPE_AI_FRIENDLINESS.md) |
## Accuracy Contract
- Docs are orientation, source is truth.
- If a method/type matters, verify with `rg` before coding.
- If docs and code differ, fix docs in the same change.
- Prefer examples that reflect current scripts and project targets.
---
Last verified against repository state: 2026-02-26
================================================
FILE: ai/RECIPE_AI_FRIENDLINESS.md
================================================
# Recipe: Making a Repository AI-Friendly
Step-by-step guide for Claude instances to add AI-optimized documentation to similar codebases.
---
## Overview
This recipe transforms a typical .NET/F# repository into one that AI coding assistants can navigate and modify efficiently. The pattern was extracted from commits that added ~3300 lines of targeted documentation to Aardvark.Base.
**Time estimate**: 2-4 hours for a medium codebase (50-200 source files).
---
## Step 1: Add `.editorconfig`
Consistent formatting reduces diff noise and prevents AI-generated code from introducing style conflicts.
```ini
root = true
[*]
charset = utf-8
insert_final_newline = true
trim_trailing_whitespace = true
end_of_line = lf
[*.{cs,fs,fsx,fsi}]
indent_style = space
indent_size = 4
[*.{csproj,fsproj,props,targets,sln}]
indent_style = space
indent_size = 2
[*.{json,yml,yaml,xml}]
indent_style = space
indent_size = 2
[*.md]
trim_trailing_whitespace = false
[*.sh]
end_of_line = lf
[*.cmd]
end_of_line = crlf
```
---
## Step 2: Add `.gitattributes`
Cross-platform line endings prevent spurious diffs when AI generates code on different OSes.
```
* text=auto
# Source code
*.cs text eol=lf
*.fs text eol=lf
*.fsx text eol=lf
*.fsi text eol=lf
# Build files
*.csproj text eol=lf
*.fsproj text eol=lf
*.sln text eol=lf
*.props text eol=lf
*.targets text eol=lf
# Config
*.json text eol=lf
*.yml text eol=lf
*.yaml text eol=lf
# Docs
*.md text eol=lf
*.txt text eol=lf
# Scripts
*.sh text eol=lf
*.cmd text eol=crlf
*.bat text eol=crlf
# Binary
*.png binary
*.jpg binary
*.dll binary
*.exe binary
*.pdb binary
*.nupkg binary
*.zip binary
```
---
## Step 3: Create `AGENTS.md` at Repo Root
This is the entry point for AI agents. Include:
1. **Link to detailed docs** (if any)
2. **Supported commands table** (build, test, restore)
3. **Dependency management rules** (npm, pip, NuGet, Paket, etc.)
4. **File ownership by change type**
5. **Framework/SDK constraints**
6. **Common failure modes with fixes**
7. **Project structure overview**
8. **Tips for AI agents**
9. **Release notes placement rule** when the repo keeps unreleased notes above versioned sections
### Template
```markdown
# AI Agent Guide
This repository has AI-targeted reference documentation in `ai/README.md`.
## Supported Commands
| Task | Command | Notes |
|------|---------|-------|
| Restore | `./build.sh restore` or `.\build.cmd restore` | Restores tools + packages |
| Build | `./build.sh` or `.\build.cmd` | Builds entire solution |
| Test | `./test.sh` or `.\test.cmd` | Runs the real test projects; excludes benchmark projects |
| Build one | `dotnet build src/Foo/Foo.csproj` | Single project |
## Dependency Management
| Task | Command |
|------|---------|
| Add package | `<your package manager command>` |
| Update | `<your update command>` |
**Rules:**
- <package manager specific rules>
## File Ownership by Change Type
| Change Type | Files to Modify | Files to NOT Touch |
|-------------|-----------------|-------------------|
| Add feature | `src/**/*.cs` | `*_auto.cs` (generated) |
| Add test | `tests/**/*Tests.cs` | Source files, other tests |
| Fix bug | Relevant source + test | Unrelated modules |
## Framework & SDK Rules
- **.NET Version**: X.Y (see `global.json`)
- **Target Frameworks**: netstandard2.0, net8.0
- **LangVersion**: 12
## Common Failure Modes & Fixes
| Symptom | Cause | Fix |
|---------|-------|-----|
| Package restore fails | Outdated lock file | `<regenerate command>` |
| SDK not found | Wrong .NET version | Install .NET X.Y |
## Project Structure
```
src/
├── Core/ # Main library
├── Extensions/ # Optional modules
└── Tests/ # Test projects
```
## Tips for AI Agents
1. Read only what you need; each doc is self-contained
2. Check the "Gotchas" section before writing code
3. If the repo has `RELEASE_NOTES.md`, say where unreleased notes belong.
### Release Notes Placement
If the repository keeps unreleased notes separately from numbered releases:
- tell agents whether tooling reads the first `### <version>` section as the current version
- if plain pending notes above the first version are allowed, say that explicitly
- explicitly forbid adding a markdown heading such as `### Preliminary` above that first version section when tooling would treat it as structural
- explicitly forbid adding new notes inside the previous released version block
- if pending notes belong above the first version, say that directly instead of telling agents to write into the previous released block
3. Run tests after changes
4. Use provided build scripts
```
---
## Step 4: Create `ai/README.md` Index
This is a compact index so the AI knows which doc to read for each task.
### Template
```markdown
# <Project> AI Reference
Index for AI coding assistants. Read only the doc you need.
## By Task
| Task | Document | Size |
|------|----------|------|
| Core types, APIs | CORE.md | ~10 KB |
| Data structures | DATA_STRUCTURES.md | ~8 KB |
| Algorithms | ALGORITHMS.md | ~8 KB |
| Serialization | SERIALIZATION.md | ~7 KB |
| Configuration | CONFIG.md | ~5 KB |
## By Type
- `FooClass`, `BarStruct` → CORE.md
- `MyCollection<T>` → DATA_STRUCTURES.md
```
**Key rules:**
- Include approximate file sizes (AI can estimate reading cost)
- Group by task AND by type name
- Keep it under 50 lines
---
## Step 5: Create Topic-Specific Reference Docs in `ai/`
Each doc covers one topic. Target 6-12 KB per doc (500-1000 lines).
### Document Structure
```markdown
# <Project> <Topic> Reference
AI-targeted reference for <topic description>.
---
## <Major Section 1>
### <Subsection>
| Type | Properties | Notes |
|------|------------|-------|
| Foo | Bar, Baz | Description |
### Usage
```<lang>
// Example code
```
---
## <Major Section 2>
...
---
## Usage Patterns
### Pattern Name
```<lang>
// Complete working example
```
---
## Gotchas
1. **Gotcha Title**: Explanation of the trap and how to avoid it
2. **Another Gotcha**: ...
---
## See Also
- [OTHER_DOC.md](OTHER_DOC.md) - Why this is related
```
### Formatting Rules
1. **Tables over prose** - Types, properties, commands in tables
2. **Code examples** - Complete, copy-paste-ready
3. **Gotchas section** - Common mistakes (3-5 items)
4. **See Also** - Cross-references to related docs
5. **No fluff** - Skip introductions, motivation, history
### Step 5b: F# Considerations
If your repo has F# code alongside C#:
1. **Document `open` statements** - F# uses `open Namespace` instead of `using`. List common opens and what they provide
2. **Cover F# modules** - F# modules (like `Vec`, `Mat`) wrap C# static methods. Document these separately from the C# API
3. **Note function conventions**:
- F# prefers curried functions: `transformPos matrix point`
- C# uses tupled: `TransformPos(matrix, point)`
- Document both forms if available
4. **Dual-language examples** - For key operations, show both:
```csharp
// C#
var result = V3d.Cross(a, b);
```
```fsharp
// F#
let result = Vec.cross a b
```
5. **Document lenses** - If using Adaptify or similar, document the lens system and composition operators
---
## Step 6: Add `.claude/CLAUDE.md` Pointer
Minimal file that tells Claude Code where to find docs.
```markdown
# AI Documentation
Read `ai/README.md` for indexed reference docs.
```
---
## Step 7: Document Complex Build Systems
If your repo has code generation, custom build steps, or unusual tooling, create a README in that component's directory.
### Template for Code Generators
```markdown
# <Generator Name>
## Purpose
<One paragraph explaining what it generates and why>
## How to Run
```bash
./generate.sh # Unix
.\generate.cmd # Windows
```
## When to Run
Run after modifying any `*_template.*` file.
## Input Files
`*_template.cs` files containing:
- <syntax description>
## Output Files
`*_auto.cs` files that are:
- AUTO GENERATED - DO NOT EDIT
- <what they contain>
## Generated Files Summary
| Template | Output | Purpose |
|----------|--------|---------|
| Foo_template.cs | Foo_auto.cs | Generates type variants |
```
---
## Step 8: Improve CI Configuration
AI agents benefit from CI that:
- Uses caching (faster feedback loop)
- Sets `fail-fast: false` (see all failures, not just first)
- Has correct path-ignore globs
### GitHub Actions Example
```yaml
name: Build
on:
push:
paths-ignore:
- 'README.md'
- 'docs/**'
pull_request:
paths-ignore:
- 'README.md'
- 'docs/**'
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
steps:
- uses: actions/checkout@v4
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
global-json-file: global.json
- name: Cache packages
uses: actions/cache@v4
with:
path: |
~/.nuget/packages
key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
- name: Build
run: <build command>
```
---
## Checklist
Before considering the repository AI-friendly, verify:
- [ ] `.editorconfig` exists with language-specific rules
- [ ] `.gitattributes` handles line endings and binary files
- [ ] `AGENTS.md` at root with commands, rules, structure
- [ ] `ai/README.md` index with task-based lookup
- [ ] `ai/*.md` docs for each major topic (3-10 docs typical)
- [ ] `.claude/CLAUDE.md` points to ai/README.md
- [ ] Build system READMEs for code generators or unusual tooling
- [ ] CI uses caching and fail-fast: false
- [ ] All `ai/*.md` docs have Gotchas and See Also sections
- [ ] All `ai/*.md` docs are 6-12 KB (not too long to read, not too short to be useful)
---
## Anti-Patterns to Avoid
1. **Walls of prose** - AI skims; tables and code are better
2. **Incomplete examples** - Every code block should work if pasted
3. **Missing gotchas** - The mistakes AI makes repeatedly belong here
4. **Giant monolithic docs** - Split by topic; 6-12 KB per file
5. **Stale docs** - Update when behavior changes; delete obsolete content
6. **Documenting the obvious** - Skip "what is a vector"; focus on API specifics
7. **Duplicating source comments** - Reference docs should add value beyond inline docs
---
## Maintenance
When making changes to the codebase:
1. **New types/APIs**: Update relevant `ai/*.md` doc
2. **New failure mode**: Add to AGENTS.md failure table
3. **New build step**: Add to AGENTS.md commands table
4. **Breaking change**: Update Gotchas section
5. **Removing feature**: Delete from docs (don't leave stale references)
---
*Last updated: December 2025*
================================================
FILE: ai/SEMANTICS_GEOMETRY_CORE.md
================================================
# Aardvark.Base Geometry Semantics
Use this for transform correctness questions in geometry code.
## Transform Semantics
For `M44d` and `Trafo3d`:
- `TransformPos` treats input as point (`w=1`)
- `TransformDir` treats input as direction (`w=0`)
- `TransformPosProj` performs perspective division
Use the right method for normals/vectors/points. Most correctness bugs come from mixing them.
## Trafo3d Forward/Backward
`Trafo3d` stores both matrices:
- `Forward`: model -> transformed space
- `Backward`: inverse transform
`InvTransformPos` and related methods use `Backward`.
## Trafo3d Multiplication Order
`Trafo3d` composition is backward relative to raw matrix multiplication for natural postfix usage.
```csharp
var combined = t0 * t1; // not equivalent to new Trafo3d(t0.Forward * t1.Forward, ...)
```
For ambiguity-sensitive code, inspect resulting `Forward` explicitly.
## Matrix and Geometry Interop
When crossing APIs that use transposed conventions, use:
- `m.Transposed`
- `m.TransposedTransformPos(...)`
- `m.TransposedTransformDir(...)`
Do not assume identical handedness or memory/algebra conventions across systems.
## Geodesy Units (Geo)
`Geo.XyzFromLonLatHeight` and `Geo.LonLatHeightFromXyz` use:
- longitude/latitude in degrees
- height in meters
- ellipsoid from `GeoEllipsoid` (`Wgs84`, `Grs80`, `Bessel1841`, ...)
## Source Anchors
- `src/Aardvark.Base/Math/Trafos/Matrix_auto.cs` (`TransformPos`, `TransformDir`, transposed variants)
- `src/Aardvark.Base/Math/Trafos/Trafo_auto.cs` (`Trafo3d`, `Forward`, `Backward`, operator `*`)
- `src/Aardvark.Base/Geodesy/GeoConversion.cs` (`XyzFromLonLatHeight`, `LonLatHeightFromXyz`)
- `src/Aardvark.Base/Geodesy/GeoConsts.cs` (`GeoEllipsoid`)
================================================
FILE: ai/SEMANTICS_LINEAR_ALGEBRA.md
================================================
# Aardvark.Base Linear Algebra Semantics
Use this when matrix/vector layout and interop correctness matter.
## M44d Convention (Verified)
`M44d` fields are named by row/column: `Mrc`.
- `M00..M03` = row 0
- `M10..M13` = row 1
- `M20..M23` = row 2
- `M30..M33` = row 3
`double[]` export order is row-major:
```csharp
var a = (double[])m;
// a = [M00, M01, M02, M03, M10, ... , M33]
```
## Multiplication Semantics
`M44d` supports both:
- `m * v` where `v` is a column vector
- `v * m` where `v` is a row vector
Column-vector form (`m * v`) is the canonical transform style for `TransformPos`/`TransformDir`.
```csharp
V4d c = m * v;
V4d r = v * m;
```
## Point vs Direction
For `M44d`:
- `TransformDir(v)` ignores translation (`w = 0`)
- `TransformPos(p)` applies translation (`w = 1`)
- translation lives in `M03/M13/M23`
## Direct Answer: Row-Major or Column-Major?
Both concerns exist, but they are different:
- In-memory field/array layout is row-major.
- Algebra supports column-vector and row-vector multiplication operators.
If your external system is column-major memory, conversion is required at the boundary.
## Efficient Layout Conversion
### Row-major array -> M44d
```csharp
var m = new M44d(rowMajor16);
```
### Column-major array -> M44d
```csharp
var m = M44d.FromCols(
new V4d(cm[0], cm[1], cm[2], cm[3]),
new V4d(cm[4], cm[5], cm[6], cm[7]),
new V4d(cm[8], cm[9], cm[10], cm[11]),
new V4d(cm[12], cm[13], cm[14], cm[15])
);
```
### M44d -> column-major array
```csharp
var cm = new[]
{
m.M00, m.M10, m.M20, m.M30,
m.M01, m.M11, m.M21, m.M31,
m.M02, m.M12, m.M22, m.M32,
m.M03, m.M13, m.M23, m.M33
};
```
### Opposite algebra convention
If the other side interprets transforms with opposite multiplication side, transpose at the boundary:
```csharp
var boundaryMatrix = m.Transposed;
```
For one-off transforms, use `TransposedTransformDir` / `TransposedTransformPos` to avoid manual transpose logic.
## Trafo3d Composition Note
`Trafo3d` multiplication order is intentionally reversed relative to raw `M44d` multiplication:
```csharp
var t = t0 * t1;
// forward = t1.Forward * t0.Forward
```
This is documented in `Trafo_auto.cs` and affects composition assumptions.
## Source Anchors
- `src/Aardvark.Base/Math/Trafos/Matrix_auto.cs` (`M44d`, `FromRows`, `FromCols`, `operator*`, `TransformPos`, `TransposedTransformPos`)
- `src/Aardvark.Base/Math/Trafos/Trafo_auto.cs` (`Trafo3d` operator `*` composition semantics)
================================================
FILE: ai/SERIALIZATION.md
================================================
# Aardvark.Base Serialization Reference
AI-targeted reference for the ICoder serialization system - bidirectional read/write abstraction.
---
## ICoder Pattern
The ICoder interface provides a unified API for both reading and writing. The same code handles both directions.
```csharp
public partial interface ICoder
{
bool IsReading { get; }
bool IsWriting { get; }
int CoderVersion { get; }
int MemoryVersion { get; }
int StreamVersion { get; }
void Code(ref object obj);
void CodeT<T>(ref T obj);
// ... type-specific methods
}
```
### Key Insight
Same method signature for read and write:
- **Writing**: reads value from `ref` parameter, writes to stream
- **Reading**: reads from stream, assigns to `ref` parameter
```csharp
// This code works for BOTH reading and writing
public void Serialize(ICoder coder)
{
coder.CodeInt32(ref _x);
coder.CodeString(ref _name);
coder.CodeV3d(ref _position);
}
```
---
## Implementations
### BinaryWritingCoder
Writes objects to binary stream.
```csharp
using (var coder = new BinaryWritingCoder(stream))
{
object data = myObject;
coder.Code(ref data);
}
```
### BinaryReadingCoder
Reads objects from binary stream.
```csharp
using (var coder = new BinaryReadingCoder(stream))
{
object data = null;
coder.Code(ref data);
var myObject = (MyType)data;
}
```
---
## Type-Specific Methods
### Primitive Types
```csharp
void CodeBool(ref bool value);
void CodeByte(ref byte value);
void CodeSByte(ref sbyte value);
void CodeInt16(ref short value);
void CodeUInt16(ref ushort value);
void CodeInt32(ref int value);
void CodeUInt32(ref uint value);
void CodeInt64(ref long value);
void CodeUInt64(ref ulong value);
void CodeFloat(ref float value);
void CodeDouble(ref double value);
void CodeChar(ref char value);
void CodeString(ref string value);
void CodeGuid(ref Guid value);
void CodeType(ref Type value);
void CodeSymbol(ref Symbol value);
```
### Aardvark Types
```csharp
// Vectors
void CodeV2i(ref V2i value);
void CodeV2f(ref V2f value);
void CodeV2d(ref V2d value);
void CodeV3i(ref V3i value);
void CodeV3f(ref V3f value);
void CodeV3d(ref V3d value);
void CodeV4i(ref V4i value);
void CodeV4f(ref V4f value);
void CodeV4d(ref V4d value);
// Matrices
void CodeM22f(ref M22f value);
void CodeM33f(ref M33f value);
void CodeM44f(ref M44f value);
void CodeM22d(ref M22d value);
void CodeM33d(ref M33d value);
void CodeM44d(ref M44d value);
// Transformations
void CodeTrafo2f(ref Trafo2f value);
void CodeTrafo3f(ref Trafo3f value);
void CodeTrafo2d(ref Trafo2d value);
void CodeTrafo3d(ref Trafo3d value);
// Colors
void CodeC3b(ref C3b value);
void CodeC4b(ref C4b value);
void CodeC3f(ref C3f value);
void CodeC4f(ref C4f value);
// Geometric
void CodeBox2i(ref Box2i value);
void CodeBox3i(ref Box3i value);
void CodeBox2f(ref Box2f value);
void CodeBox3f(ref Box3f value);
void CodeBox2d(ref Box2d value);
void CodeBox3d(ref Box3d value);
```
### Collections
```csharp
void CodeT<T>(ref T obj);
void CodeTArray<T>(ref T[] array);
void CodeList_of_T_<T>(ref List<T> list);
void CodeHashSet_of_T_<T>(ref HashSet<T> set);
void Code(Type t, ref Array array);
void Code(Type t, ref IList list);
void Code(Type t, ref IDictionary dict);
```
### Tensors
```csharp
void Code(Type t, ref IArrayVector vector);
void Code(Type t, ref IArrayMatrix matrix);
void Code(Type t, ref IArrayVolume volume);
void Code(Type t, ref IArrayTensor4 tensor4);
void Code(Type t, ref IArrayTensorN tensor);
```
### Struct Arrays
```csharp
void CodeStructArray<T>(ref T[] a) where T : struct;
void CodeStructList<T>(ref List<T> l) where T : struct;
```
---
## Extended Interfaces
### IReadingCoder
```csharp
public interface IReadingCoder : ICoder
{
// Code count with creation function
int CodeCount<T>(ref T value, Func<int, T> creator) where T : class;
}
```
### IWritingCoder
```csharp
public interface IWritingCoder : ICoder
{
// Code count with counting function
int CodeCount<T>(ref T value, Func<T, int> counter) where T : class;
}
```
---
## Version Handling
ICoder supports versioned serialization:
```csharp
coder.MemoryVersion // current in-memory format version
coder.StreamVersion // version in the stream being read
coder.CoderVersion // coder implementation version
```
Use for backward compatibility:
```csharp
public void Serialize(ICoder coder)
{
coder.CodeInt32(ref _x);
if (coder.StreamVersion >= 2)
{
coder.CodeString(ref _newField);
}
else if (coder.IsReading)
{
_newField = "default"; // provide default for old data
}
}
```
---
## TypeInfo Registration
Register custom types for polymorphic serialization:
```csharp
coder.Add(new TypeInfo[] {
new TypeInfo(typeof(MyType), "MyType", /* version */ 1),
// ...
});
coder.Del(typeInfoArray); // remove registration
```
---
## Usage Patterns
### Basic Serialization
```csharp
// Write
using (var stream = File.Create("data.bin"))
using (var coder = new BinaryWritingCoder(stream))
{
var position = new V3d(1, 2, 3);
var name = "test";
coder.CodeV3d(ref position);
coder.CodeString(ref name);
}
// Read
using (var stream = File.OpenRead("data.bin"))
using (var coder = new BinaryReadingCoder(stream))
{
var position = default(V3d);
var name = default(string);
coder.CodeV3d(ref position);
coder.CodeString(ref name);
}
```
### Unified Read/Write Method
```csharp
public class MyData
{
private V3d _position;
private string _name;
private List<int> _values;
public void Code(ICoder coder)
{
coder.CodeV3d(ref _position);
coder.CodeString(ref _name);
coder.CodeList_of_T_(ref _values);
}
}
// Write
myData.Code(writingCoder);
// Read
myData.Code(readingCoder);
```
### Conditional Coding
```csharp
public void Code(ICoder coder)
{
coder.CodeInt32(ref _count);
if (coder.IsWriting && _data != null)
{
coder.CodeTArray(ref _data);
}
else if (coder.IsReading)
{
_data = new float[_count];
coder.CodeTArray(ref _data);
}
}
```
---
## Special Methods
### Symbol Variants
```csharp
// Symbol known to be from a GUID
void CodeGuidSymbol(ref Symbol v);
// Symbol known to be positive (has string representation)
void CodePositiveSymbol(ref Symbol v);
```
### Set Types
```csharp
void CodeIntSet(ref IntSet v);
void CodeSymbolSet(ref SymbolSet v);
```
### Enum Coding
```csharp
void CodeEnum(Type t, ref object value);
```
---
## Gotchas
1. **Unidirectional Reference Pattern**: The `ref` parameter pattern is elegant but *confusing* for debugging. Read-mode passes `null` into `ref`, write-mode reads from the ref. Always verify `IsReading`/`IsWriting` in conditional logic
2. **Version Mismatch Silent Failures**: If code reads a newer format than `StreamVersion`, old fields stay at default values without warning. Use version guards explicitly; don't assume forward compatibility
3. **Polymorphic Type Registration**: Polymorphic serialization requires exact `TypeInfo` registration. Missing a subclass? It silently serializes as the base type, causing silent data loss on read
---
## See Also
- [PRIMITIVE_TYPES.md](PRIMITIVE_TYPES.md) - All primitives (V3d, M44d, Trafo3d) have `CodeXxx` methods
- [TENSORS.md](TENSORS.md) - N-dimensional tensors serialize via `Code(Type t, ref IArrayVolume volume)`
- [PIXIMAGE.md](PIXIMAGE.md) - `PixImage` serialization for binary save/load workflows
- [COLLECTIONS.md](COLLECTIONS.md) - `Symbol`, `SymbolDict`, `LruCache` serialization patterns
================================================
FILE: ai/SYMBOL_INDEX.md
================================================
# Aardvark.Base Symbol Index
Quick symbol-to-doc map for incremental discovery.
## Core Math / Geometry
| Symbol | Primary Doc |
|--------|-------------|
| `V2d`, `V3d`, `V4d` | [PRIMITIVE_TYPES.md](PRIMITIVE_TYPES.md) |
| `M22d..M44d` | [PRIMITIVE_TYPES.md](PRIMITIVE_TYPES.md) |
| `Rot3d`, `Trafo3d` | [PRIMITIVE_TYPES.md](PRIMITIVE_TYPES.md) |
| `M44d` layout/interoperability | [SEMANTICS_LINEAR_ALGEBRA.md](SEMANTICS_LINEAR_ALGEBRA.md) |
| Transform semantics (`TransformPos`, `TransformDir`) | [SEMANTICS_GEOMETRY_CORE.md](SEMANTICS_GEOMETRY_CORE.md) |
| `Box3d`, `Ray3d`, `Plane3d` | [PRIMITIVE_TYPES.md](PRIMITIVE_TYPES.md) |
## Images / Tensors
| Symbol | Primary Doc |
|--------|-------------|
| `PixImage`, `PixImage<T>` | [PIXIMAGE.md](PIXIMAGE.md) |
| `PixVolume`, `PixVolume<T>` | [PIXIMAGE.md](PIXIMAGE.md) |
| `PixCube`, `PixImageMipMap` | [PIXIMAGE.md](PIXIMAGE.md) |
| `PixFormat`, `PixFileFormat`, `PixProcessorCaps` | [PIXIMAGE.md](PIXIMAGE.md) |
| `Vector<T>`, `Matrix<T>`, `Volume<T>`, `Tensor4<T>` | [TENSORS.md](TENSORS.md) |
| `MatrixInfo`, `VolumeInfo`, `Tensor4Info` | [TENSORS.md](TENSORS.md) |
## Algorithms / Numerics
| Symbol | Primary Doc |
|--------|-------------|
| `ShortestPath<T>` | [ALGORITHMS.md](ALGORITHMS.md) |
| `BbTree` | [ALGORITHMS.md](ALGORITHMS.md) |
| `AliasTableF`, `AliasTableD` | [ALGORITHMS.md](ALGORITHMS.md) |
| `DistributionFunction` | [ALGORITHMS.md](ALGORITHMS.md) |
| `Polynomial` | [ALGORITHMS.md](ALGORITHMS.md) |
| `LuFactorize`, `LuSolve`, `QrFactorize` | [ALGORITHMS.md](ALGORITHMS.md) |
## Collections / Infrastructure
| Symbol | Primary Doc |
|--------|-------------|
| `Symbol`, `TypedSymbol<T>` | [COLLECTIONS.md](COLLECTIONS.md) |
| `Dict<TKey,TValue>`, `SymbolDict<T>`, `SymbolSet` | [COLLECTIONS.md](COLLECTIONS.md) |
| `LruCache<TKey,TValue>` | [COLLECTIONS.md](COLLECTIONS.md) |
| `ConcurrentHashSet<T>` | [COLLECTIONS.md](COLLECTIONS.md) |
| `Report` | [UTILITIES.md](UTILITIES.md) |
| `Telemetry` | [UTILITIES.md](UTILITIES.md) |
| `RandomSystem`, `RandomSample`, `HaltonRandomSeries` | [UTILITIES.md](UTILITIES.md) |
| `Geo`, `GeoEllipsoid` | [UTILITIES.md](UTILITIES.md) |
## F# / Incremental
| Symbol | Primary Doc |
|--------|-------------|
| `Vec`, `Mat`, `Trafo`, `Lens` | [FSHARP_INTEROP.md](FSHARP_INTEROP.md) |
| `aval`, `cval`, `aset`, `amap`, `alist` | [INCREMENTAL.md](INCREMENTAL.md) |
## Verification Tip
After landing on a doc, validate exact API names in source:
```bash
rg "SymbolName" src
```
================================================
FILE: ai/TENSORS.md
================================================
# Aardvark.Base Tensor Types Reference
Source-verified reference for stride-based tensor containers.
## Core Model
Indexing is stride-based:
```
index = Origin + x * DX + y * DY + z * DZ + ...
```
Metadata structs:
- `VectorInfo`
- `MatrixInfo`
- `VolumeInfo`
- `Tensor4Info`
Data containers:
- `Vector<Td>`
- `Matrix<Td>`
- `Volume<Td>`
- `Tensor4<Td>`
These are `struct` types in generated `Tensor_auto.cs`.
## Default Dense Layouts
`MatrixInfo(size)` defaults to:
- `DX = 1`
- `DY = SX`
Image layouts (`ImageTensors.cs`):
- Matrix: `DX = 1`, `DY = SX`
- Volume: `DZ = 1`, `DX = SZ`, `DY = SX * DX`
- Tensor4: `DW = 1`, `DX = SW`, `DY = SX * DX`, `DZ = SY * DY`
## Views vs Copies
Subview methods return views on shared data:
- `SubMatrix(...)`, `SubMatrixWindow(...)`
- `SubVolume(...)`, `SubVolumeWindow(...)`
- `SubTensor4(...)`, `SubTensor4Window(...)`
`Transposed` is a stride/view transform, not deep copy.
Use `Copy()` or `CopyWindow()` when you need independent storage.
## Matrix Convenience Methods
On `Matrix<T>`:
- `Row(y)` and `Col(x)` (return `Vector<T>`)
- `Transposed`
- `SetByCoord(...)`
- `Foreach...` variants for iteration
## Image Layout Helpers
In `Tensors/ImageTensors.cs`:
- `HasImageLayout(...)`
- `CreateImageVolume(...)`
- `CreateImageTensor4(...)`
- `ToImage(...)` / `ToImageWindow(...)`
- `CopyToImage(...)` / `CopyToImageWindow(...)`
These are important for high-performance pix/tensor interoperability.
## Source Anchors
- `src/Aardvark.Base.Tensors.CSharp/Tensor_auto.cs`
- `src/Aardvark.Base.Tensors.CSharp/Tensors/ImageTensors.cs`
================================================
FILE: ai/UTILITIES.md
================================================
# Aardvark.Base Utilities Reference
Source-verified orientation for reporting, telemetry, random, traversal, and geodesy APIs.
## Report
`Report` is global process state.
Common methods:
```csharp
Report.Line("msg");
Report.Warn("msg");
Report.Debug("msg");
Report.Trace("msg");
Report.Error("msg");
Report.Fatal("msg");
Report.BeginTimed("load");
// ...
Report.End();
Report.Progress(0.5);
Report.ProgressDelta(0.1);
```
Key settings:
```csharp
Report.Verbosity = 2;
Report.MultiThreaded = true;
Report.ThrowOnError = false;
```
## Telemetry
Core probe types:
- `Telemetry.Counter`
- `Telemetry.StopWatchTime`
- `Telemetry.WallClockTime`
- `Telemetry.CpuTime`
Registration:
```csharp
var c = new Telemetry.Counter();
Telemetry.Register("Frames", c);
Telemetry.Register("Frames/s", c.RatePerSecond());
```
Reset API:
```csharp
Telemetry.ResetTelemetrySystem();
```
## Random
`RandomSystem` implements `IRandomUniform`.
```csharp
var rnd = new RandomSystem(1);
int raw = rnd.UniformInt();
int bounded = rnd.UniformInt(100); // extension method on IRandomUniform
double u = rnd.UniformDouble();
```
Geometric sampling:
```csharp
var dir = RandomSample.Spherical(rnd, 0);
var hemi = RandomSample.Lambertian(V3d.ZAxis, rnd, 0);
var disk = RandomSample.Disk(rnd, 0);
```
Low-discrepancy:
```csharp
var halton = new HaltonRandomSeries(2, rnd);
double q = Quasi.QuasiHaltonWithIndex(2, 0.123);
```
## INode Traversal
`INode` extensions:
- `DepthFirst()`
- `BreadthFirst()`
- `NodesAtDepth(depth)`
- `DescendentsAndSelf()` and `Descendents()` (spelling in code is `Descendents`)
## Geodesy
Main conversions:
```csharp
var xyz = Geo.XyzFromLonLatHeight(new V3d(lonDeg, latDeg, hMeters), GeoEllipsoid.Wgs84);
var llh = Geo.LonLatHeightFromXyz(xyz, GeoEllipsoid.Wgs84);
```
`GeoEllipsoid` presets include `Wgs84`, `Grs80`, `Bessel1841`.
## Constants
`Constant<T>` exposes machine-epsilon/tiny/parseable min/max style values.
Mathematical constants are on non-generic classes:
- `Constant.Pi`, `Constant.E`
- `ConstantF.Pi`, `ConstantF.E`
## Source Anchors
- `src/Aardvark.Base/Reporting/Report.cs`
- `src/Aardvark.Base.Telemetry/Probes.cs`
- `src/Aardvark.Base.Telemetry/Registry.cs`
- `src/Aardvark.Base.Telemetry/IProbe.cs`
- `src/Aardvark.Base.Telemetry/TelemetryExtensions.cs`
- `src/Aardvark.Base/Random/RandomSystem.cs`
- `src/Aardvark.Base/Random/IRandomUniform.cs`
- `src/Aardvark.Base/Random/RandomSample.cs`
- `src/Aardvark.Base/Random/HaltonRandomSeries.cs`
- `src/Aardvark.Base/Random/Quasi.cs`
- `src/Aardvark.Base/AlgoDat/INode.cs`
- `src/Aardvark.Base/Geodesy/GeoConversion.cs`
- `src/Aardvark.Base/Geodesy/GeoConsts.cs`
- `src/Aardvark.Base/Math/Base/Constant.cs`
================================================
FILE: build.cmd
================================================
@echo off
dotnet tool restore
IF ERRORLEVEL 1 EXIT /B %ERRORLEVEL%
REM `dotnet paket restore` alone does not recreate Paket.Restore.targets if it is missing.
IF NOT EXIST ".paket\Paket.Restore.targets" (
dotnet paket install
IF ERRORLEVEL 1 EXIT /B %ERRORLEVEL%
) ELSE (
dotnet paket restore
IF ERRORLEVEL 1 EXIT /B %ERRORLEVEL%
)
IF "%1"=="restore" exit /B
dotnet build src\Aardvark.sln
IF ERRORLEVEL 1 EXIT /B %ERRORLEVEL%
================================================
FILE: build.sh
================================================
#!/bin/bash
set -eu
mode="${1-}"
dotnet tool restore
# `dotnet paket restore` alone does not recreate Paket.Restore.targets if it is missing.
if [ ! -f ".paket/Paket.Restore.targets" ]; then
dotnet paket install
else
dotnet paket restore
fi
if [ "$mode" = "restore" ]; then
exit 0
fi
dotnet build src/Aardvark.sln
================================================
FILE: check-docs.cmd
================================================
@echo off
dotnet run --project tools\DocsChecker\DocsChecker.csproj -c Release
================================================
FILE: check-docs.sh
================================================
#!/bin/bash
set -euo pipefail
dotnet run --project tools/DocsChecker/DocsChecker.csproj -c Release
================================================
FILE: generate.cmd
================================================
@echo off
dotnet build src\CodeGenerator\CodeGenerator.csproj
dotnet bin\Debug\net8.0\CodeGenerator.dll %*
================================================
FILE: generate.sh
================================================
#! /bin/sh
dotnet build src/CodeGenerator/CodeGenerator.csproj
dotnet bin/Debug/net8.0/CodeGenerator.dll "$@"
================================================
FILE: global.json
================================================
{
"sdk": {
"version": "8.0.0",
"rollForward": "latestFeature",
"allowPrerelease": false
}
}
================================================
FILE: paket.dependencies
================================================
framework: netstandard2.0, net8.0
storage: none
source https://api.nuget.org/v3/index.json
nuget Aardvark.Build ~> 2.0.7
nuget FSharp.Core >= 8.0.300 lowest_matching: true
nuget System.Collections.Immutable >= 8.0.0 lowest_matching: true
nuget System.Reflection.Metadata >= 8.0.0 lowest_matching: true
nuget System.Text.Json >= 8.0.5 lowest_matching: true
nuget System.Dynamic.Runtime ~> 4.3.0
nuget Aardvark.Base.TypeProviders ~> 4.5.15
nuget FSharp.Data.Adaptive ~> 1.2.0
nuget CSharp.Data.Adaptive ~> 1.2.0
nuget Unofficial.LibTessDotNet ~> 2.0.2
nuget FsPickler ~> 5.3.2
nuget FsPickler.Json ~> 5.3.2
nuget Unofficial.Typography ~> 0.1.0
nuget FuzzySharp ~> 2.0.2
nuget SingleFileExtractor.Core ~> 2.2.1
group CodeGenerator
framework net8.0
storage: none
source https://api.nuget.org/v3/index.json
nuget Microsoft.NETFramework.ReferenceAssemblies = 1.0.0
nuget Microsoft.CodeAnalysis.CSharp ~> 4.1.0
group Demo
framework net8.0
storage: none
source https://api.nuget.org/v3/index.json
nuget System.Reactive ~> 6.0.0
nuget CSharp.Data.Adaptive ~> 1.2.0
group Test
framework: net8.0
storage: none
source https://api.nuget.org/v3/index.json
nuget NUnit ~> 3.14.0
nuget FsUnit ~> 5.6.1
nuget FsCheck ~> 2.16.6
nuget FsCheck.NUnit ~> 2.16.6
nuget NUnit3TestAdapter ~> 4.5.0
nuget Microsoft.NET.Test.Sdk ~> 17.9.0
nuget Expecto ~> 10.2.1
nuget Expecto.FsCheck ~> 10.2.1
nuget YoloDev.Expecto.TestSdk ~> 0.14.3
nuget BenchmarkDotNet ~> 0.13.12
================================================
FILE: src/Aardvark.Base/Aardvark.Base.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net8.0;netstandard2.0</TargetFrameworks>
<LangVersion>12.0</LangVersion>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<OutputPath>..\..\bin\Debug</OutputPath>
<NoWarn>1701;1702;1705;1591</NoWarn>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<OutputPath>..\..\bin\Release</OutputPath>
<NoWarn>1701;1702;1705;1591</NoWarn>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<ItemGroup>
<Compile Remove="**\*_template.cs" />
<Compile Remove="**\*_generator.cs" />
</ItemGroup>
<ItemGroup>
<None Include="**\*_template.cs" />
</ItemGroup>
<ItemGroup>
<None Remove="Geometry\Polygon2_template.cs" />
</ItemGroup>
<ItemGroup>
<CodeAnalysisDictionary Include="Geometry\Types\Polygon\Polygon2_template.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Aardvark.Base.Telemetry\Aardvark.Base.Telemetry.csproj" />
</ItemGroup>
<Import Project="..\..\.paket\Paket.Restore.targets" />
</Project>
================================================
FILE: src/Aardvark.Base/AlgoDat/AdaBoost.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
namespace Aardvark.Base
{
/// <summary>
/// Adaptive boosting creates a strong binary classifier
/// out of an ensemble of weak classifiers.
/// </summary>
public static class AdaBoost
{
/// <summary>
/// Creates a strong binary classifier out of an ensemble of weak classifiers.
/// </summary>
/// <typeparam name="T">Type of items to be classified.</typeparam>
/// <param name="items">Training set.</param>
/// <param name="groundTruth">Correct classification of training set.</param>
/// <param name="getNextWeakClassifier">
/// Returns a new weak classifier for given weighted items.
/// (double[] weights, T[] items, bool[] groundTruth) => T => bool.
/// </param>
/// <param name="iterations">Maximium number of weak classifiers to combine.</param>
/// <param name="onIteration">Optional callback for each learning iteration.
/// If onIteration returns true, then learning is stopped.</param>
/// <param name="stopIfWeakClassifierHasLessImportanceThan">Default is 0.0, which means that the
/// maximum number of iterations will be performed.</param>
/// <returns>A strong classifier for Ts based on a weighted majority vote of
/// weak classifiers.</returns>
public static Func<T, bool> Train<T>(
T[] items, bool[] groundTruth,
Func<double[], T[], bool[], Func<T, bool>> getNextWeakClassifier,
int iterations,
Func<Func<T, bool>, bool> onIteration = null,
double stopIfWeakClassifierHasLessImportanceThan = 0.0
)
{
var count = items.Length;
var ws = new double[count].Set(1.0 / count);
var classifiers = new List<Func<T, bool>>();
var alphas = new List<double>();
while (iterations-- > 0)
{
try
{
// get next weak classifier (based on examples and weights)
var classifier = getNextWeakClassifier(ws, items, groundTruth);
// predict values with new classifier
var predictions = items.Select(x => classifier(x)).ToArray();
// compare predictions to reality (and compute error rate e)
double e = 0.0;
for (var j = 0; j < count; j++)
{
e += ws[j] * (predictions[j] == groundTruth[j] ? 0 : 1);
}
if (Math.Abs(0.5 - e) < 0.02) { iterations++; continue; }
if (e == 0.0) // we found a perfect classifier
{
classifiers.Clear(); classifiers.Add(classifier);
alphas.Clear(); alphas.Add(1.0);
break;
}
// compute importance for this classifier
// (higher error rate gives less importance)
var alpha = 0.5 * Math.Log((1 - e) / e);
if (Math.Abs(alpha) < stopIfWeakClassifierHasLessImportanceThan) break;
// increase weights of incorrectly classified examples, and
// decrease weights of correctly classified examples
var up = Math.Exp(alpha);
var down = Math.Exp(-alpha);
for (var j = 0; j < count; j++)
{
ws[j] *= (predictions[j] == groundTruth[j]) ? down : up;
}
var wnormf = 1.0 / ws.Sum(); // normalization factor for weights
for (var j = 0; j < count; j++) ws[j] *= wnormf;
// add classifier and its importance to list
classifiers.Add(classifier);
alphas.Add(alpha);
// optional callback
if (onIteration != null)
{
var c = new Classifier<T>(
Enumerable.Range(0, ws.Length).Select(i => new WeightedExample<T>(ws[i], items[i])),
Enumerable.Range(0, alphas.Count).Select(i => new WeakClassifier<T>(alphas[i], classifiers[i]))
);
if (onIteration(c.Classify))
{
break;
}
}
}
catch /*(Exception e)*/
{
Report.Warn("AdaBoost.Train");
}
}
// create strong classifier from weak classifiers
return new Classifier<T>(
Enumerable.Range(0, ws.Length).Select(i => new WeightedExample<T>(ws[i], items[i])),
Enumerable.Range(0, alphas.Count).Select(i => new WeakClassifier<T>(alphas[i], classifiers[i]))
).Classify;
}
private readonly struct Classifier<T>
{
private readonly WeakClassifier<T>[] m_weakClassifiers;
public Classifier(
IEnumerable<WeightedExample<T>> examples,
IEnumerable<WeakClassifier<T>> weakClassifiers
)
{
m_weakClassifiers = weakClassifiers.ToArray();
}
public bool Classify(T x) => SumAlphaWeightedWeakClassifiers(x) > 0.0;
/// <summary>
/// Computes propability of positive classification given x.
/// </summary>
public double P(T x) => 1.0 / (1.0 + Math.Exp(-2.0 * SumAlphaWeightedWeakClassifiers(x)));
private double SumAlphaWeightedWeakClassifiers(T x)
=> m_weakClassifiers.Sum(c => c.Alpha * (c.Classifier(x) ? +1 : -1));
}
private readonly struct WeightedExample<T>
{
public readonly double Weight;
public readonly T Example;
public WeightedExample(double weight, T example)
{
Weight = weight;
Example = example;
}
}
private readonly struct WeakClassifier<T>
{
public readonly double Alpha;
public readonly Func<T, bool> Classifier;
public WeakClassifier(double alpha, Func<T, bool> classifier)
{
Alpha = alpha;
Classifier = classifier ?? throw new ArgumentNullException("classifier");
}
}
}
}
================================================
FILE: src/Aardvark.Base/AlgoDat/ConcurrentHashSet.cs
================================================
using System.Collections.Generic;
using System.Linq;
namespace System.Collections.Concurrent
{
/// <summary>
/// Represents a thread-safe collection that can be accessed by multiple threads concurrently.
/// </summary>
public class ConcurrentHashSet<T> : IEnumerable<T>, ICollection<T>
{
//int does not waste too much memory and might be used for reference-counting
//or similar features. TODO: investigate if this is faster using reference types.
private readonly ConcurrentDictionary<T, int> m_entries;
#region Constructors
public ConcurrentHashSet()
{
m_entries = new ConcurrentDictionary<T, int>();
}
public ConcurrentHashSet(int concurrencyLevel, int capacity)
{
m_entries = new ConcurrentDictionary<T, int>(concurrencyLevel, capacity);
}
public ConcurrentHashSet(IEqualityComparer<T> comparer)
{
m_entries = new ConcurrentDictionary<T, int>(comparer);
}
public ConcurrentHashSet(IEnumerable<T> collection)
{
m_entries = new ConcurrentDictionary<T, int>(collection.Select(e => new KeyValuePair<T, int>(e, 1)));
}
public ConcurrentHashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer)
{
m_entries = new ConcurrentDictionary<T, int>(collection.Select(e => new KeyValuePair<T, int>(e, 1)), comparer);
}
#endregion
#region Properties
public int Count => m_entries.Count;
#endregion
#region Methods
public void Clear() => m_entries.Clear();
public bool Add(T item) => m_entries.TryAdd(item, 1);
public bool Remove(T item) => m_entries.TryRemove(item, out int dummy);
public void UnionWith(IEnumerable<T> other)
{
foreach (var e in other)
Add(e);
}
#endregion
#region IEnumerable Members
public Enumerator GetEnumerator() => new Enumerator(this);
IEnumerator<T> IEnumerable<T>.GetEnumerator() => new Enumerator(this);
IEnumerator IEnumerable.GetEnumerator() => new Enumerator(this);
#endregion
#region ICollection Members
public bool Contains(T item) => m_entries.ContainsKey(item);
public void CopyTo(T[] array, int arrayIndex) => m_entries.Keys.CopyTo(array, arrayIndex);
public bool IsReadOnly => false;
void ICollection<T>.Add(T item) => Add(item);
#endregion
public readonly struct Enumerator : IEnumerator<T>, System.Collections.IEnumerator
{
private readonly IEnumerator<KeyValuePair<T, int>> m_enumerator;
internal Enumerator(ConcurrentHashSet<T> set)
{
m_enumerator = set.m_entries.GetEnumerator();
}
public T Current => m_enumerator.Current.Key;
public void Dispose() => m_enumerator.Dispose();
object IEnumerator.Current => ((IEnumerator)m_enumerator).Current;
public bool MoveNext() => m_enumerator.MoveNext();
public void Reset() => m_enumerator.Reset();
}
}
}
================================================
FILE: src/Aardvark.Base/AlgoDat/ExtendedCore/BitHelpers.cs
================================================
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Collections;
using System.Text;
namespace Aardvark.Base
{
/// <summary>
/// ABOUT:
/// Helps with operations that rely on bit marking to indicate whether an item in the
/// collection should be added, removed, visited already, etc.
///
/// BitHelper doesn't allocate the array; you must pass in an array or ints allocated on the
/// stack or heap. ToIntArrayLength() tells you the int array size you must allocate.
///
/// USAGE:
/// Suppose you need to represent a bit array of length (i.e. logical bit array length)
/// BIT_ARRAY_LENGTH. Then this is the suggested way to instantiate BitHelper:
/// ***************************************************************************
/// int intArrayLength = BitHelper.ToIntArrayLength(BIT_ARRAY_LENGTH);
/// BitHelper bitHelper;
/// if (intArrayLength less than stack alloc threshold)
/// int* m_arrayPtr = stackalloc int[intArrayLength];
/// bitHelper = new BitHelper(m_arrayPtr, intArrayLength);
/// else
/// int[] m_arrayPtr = new int[intArrayLength];
/// bitHelper = new BitHelper(m_arrayPtr, intArrayLength);
/// ***************************************************************************
///
/// IMPORTANT:
/// The second ctor args, length, should be specified as the length of the int array, not
/// the logical bit array. Because length is used for bounds checking into the int array,
/// it's especially important to get this correct for the stackalloc version. See the code
/// samples above; this is the value gotten from ToIntArrayLength().
///
/// The length ctor argument is the only exception; for other methods -- MarkBit and
/// IsMarked -- pass in values as indices into the logical bit array, and it will be mapped
/// to the position within the array of ints.
///
/// FUTURE OPTIMIZATIONS:
/// A method such as FindFirstMarked/Unmarked Bit would be useful for callers that operate
/// on a bit array and then need to loop over it. In particular, if it avoided visiting
/// every bit, it would allow good perf improvements when the bit array is sparse.
/// </summary>
unsafe internal sealed class BitHelperExt
{ // should not be serialized
private const byte MarkedBitFlag = 1;
private const byte IntSize = 32;
// m_length of underlying int array (not logical bit array)
private readonly int _length;
// ptr to stack alloc'd array of ints
private readonly int* _arrayPtr;
// array of ints
private readonly int[] _array;
// whether to operate on stack alloc'd or heap alloc'd array
private readonly bool _useStackAlloc;
/// <summary>
/// Instantiates a BitHelper with a heap alloc'd array of ints
/// </summary>
/// <param name="bitArrayPtr">int array to hold bits</param>
/// <param name="length">length of int array</param>
internal BitHelperExt(int* bitArrayPtr, int length)
{
_arrayPtr = bitArrayPtr;
_length = length;
_useStackAlloc = true;
}
/// <summary>
/// Instantiates a BitHelper with a heap alloc'd array of ints
/// </summary>
/// <param name="bitArray">int array to hold bits</param>
/// <param name="length">length of int array</param>
internal BitHelperExt(int[] bitArray, int length)
{
_array = bitArray;
_length = length;
}
/// <summary>
/// Mark bit at specified position
/// </summary>
/// <param name="bitPosition"></param>
internal void MarkBit(int bitPosition)
{
int bitArrayIndex = bitPosition / IntSize;
if (bitArrayIndex < _length && bitArrayIndex >= 0)
{
int flag = (MarkedBitFlag << (bitPosition % IntSize));
if (_useStackAlloc)
{
_arrayPtr[bitArrayIndex] |= flag;
}
else
{
_array[bitArrayIndex] |= flag;
}
}
}
/// <summary>
/// Is bit at specified position marked?
/// </summary>
/// <param name="bitPosition"></param>
/// <returns></returns>
internal bool IsMarked(int bitPosition)
{
int bitArrayIndex = bitPosition / IntSize;
if (bitArrayIndex < _length && bitArrayIndex >= 0)
{
int flag = (MarkedBitFlag << (bitPosition % IntSize));
if (_useStackAlloc)
{
return ((_arrayPtr[bitArrayIndex] & flag) != 0);
}
else
{
return ((_array[bitArrayIndex] & flag) != 0);
}
}
return false;
}
/// <summary>
/// How many ints must be allocated to represent n bits. Returns (n+31)/32, but
/// avoids overflow
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
internal static int ToIntArrayLength(int n)
{
return n > 0 ? ((n - 1) / IntSize + 1) : 0;
}
}
}
================================================
FILE: src/Aardvark.Base/AlgoDat/ExtendedCore/SortedSetExt.cs
================================================
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
/*============================================================
**
**
** Purpose: A generic sorted set.
**
** This is a copy of SortedSet extending it with neighbourhood information
===========================================================*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Aardvark.Base
{
//
// A binary search tree is a red-black tree if it satifies the following red-black properties:
// 1. Every node is either red or black
// 2. Every leaf (nil node) is black
// 3. If a node is red, the both its children are black
// 4. Every simple path from a node to a descendant leaf contains the same number of black nodes
//
// The basic idea of red-black tree is to represent 2-3-4 trees as standard BSTs but to add one extra bit of information
// per node to encode 3-nodes and 4-nodes.
// 4-nodes will be represented as: B
// R R
// 3 -node will be represented as: B or B
// R B B R
//
// For a detailed description of the algorithm, take a look at "Algorithm" by Rebert Sedgewick.
//
internal delegate bool TreeWalkPredicate<T>(SortedSetExt<T>.Node node);
internal enum TreeRotation
{
LeftRotation = 1,
RightRotation = 2,
RightLeftRotation = 3,
LeftRightRotation = 4,
}
public class Optional<T>
{
public bool HasValue;
public T Value;
private Optional()
{
HasValue = false;
Value = default(T);
}
public Optional(T value)
{
HasValue = true;
Value = value;
}
public static Optional<T> None = new Optional<T>();
}
[DebuggerDisplay("Count = {Count}")]
public class SortedSetExt<T> : ISet<T>, ICollection<T>, ICollection, IReadOnlyCollection<T>
{
#region local variables/constants
private Node _root;
private readonly IComparer<T> _comparer;
private int _count;
private int _version;
private Object _syncRoot;
internal const int StackAllocThreshold = 100;
#endregion
#region Constructors
public SortedSetExt()
{
_comparer = Comparer<T>.Default;
}
public SortedSetExt(IComparer<T> comparer)
{
if (comparer == null)
{
_comparer = Comparer<T>.Default;
}
else
{
_comparer = comparer;
}
}
public SortedSetExt(IEnumerable<T> collection) : this(collection, Comparer<T>.Default) { }
public SortedSetExt(IEnumerable<T> collection, IComparer<T> comparer)
: this(comparer)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
// these are explicit type checks in the mould of HashSet. It would have worked better
// with something like an ISorted<T> (we could make this work for SortedList.Keys etc)
SortedSetExt<T> baseSortedSet = collection as SortedSetExt<T>;
SortedSetExt<T> baseTreeSubSet = collection as TreeSubSet;
if (baseSortedSet != null && baseTreeSubSet == null && AreComparersEqual(this, baseSortedSet))
{
//breadth first traversal to recreate nodes
if (baseSortedSet.Count == 0)
{
return;
}
//pre order way to replicate nodes
Stack<Node> theirStack = new Stack<SortedSetExt<T>.Node>(2 * log2(baseSortedSet.Count) + 2);
Stack<Node> myStack = new Stack<SortedSetExt<T>.Node>(2 * log2(baseSortedSet.Count) + 2);
Node theirCurrent = baseSortedSet._root;
Node myCurrent = (theirCurrent != null ? new SortedSetExt<T>.Node(theirCurrent.Item, theirCurrent.IsRed) : null);
_root = myCurrent;
while (theirCurrent != null)
{
theirStack.Push(theirCurrent);
myStack.Push(myCurrent);
myCurrent.Left = (theirCurrent.Left != null ? new SortedSetExt<T>.Node(theirCurrent.Left.Item, theirCurrent.Left.IsRed) : null);
theirCurrent = theirCurrent.Left;
myCurrent = myCurrent.Left;
}
while (theirStack.Count != 0)
{
theirCurrent = theirStack.Pop();
myCurrent = myStack.Pop();
Node theirRight = theirCurrent.Right;
Node myRight = null;
if (theirRight != null)
{
myRight = new SortedSetExt<T>.Node(theirRight.Item, theirRight.IsRed);
}
myCurrent.Right = myRight;
while (theirRight != null)
{
theirStack.Push(theirRight);
myStack.Push(myRight);
myRight.Left = (theirRight.Left != null ? new SortedSetExt<T>.Node(theirRight.Left.Item, theirRight.Left.IsRed) : null);
theirRight = theirRight.Left;
myRight = myRight.Left;
}
}
_count = baseSortedSet._count;
}
else
{
T[] els = collection.ToArray();
int count = els.Length;
if (count > 0)
{
Array.Sort(els, 0, count, _comparer);
int index = 1;
for (int i = 1; i < count; i++)
{
if (comparer.Compare(els[i], els[i - 1]) != 0)
{
els[index++] = els[i];
}
}
count = index;
_root = ConstructRootFromSortedArray(els, 0, count - 1, null);
_count = count;
}
}
}
#endregion
#region Bulk Operation Helpers
private void AddAllElements(IEnumerable<T> collection)
{
foreach (T item in collection)
{
if (!this.Contains(item))
Add(item);
}
}
private void RemoveAllElements(IEnumerable<T> collection)
{
T min = this.Min;
T max = this.Max;
foreach (T item in collection)
{
if (!(_comparer.Compare(item, min) < 0 || _comparer.Compare(item, max) > 0) && this.Contains(item))
this.Remove(item);
}
}
private bool ContainsAllElements(IEnumerable<T> collection)
{
foreach (T item in collection)
{
if (!this.Contains(item))
{
return false;
}
}
return true;
}
//
// Do a in order walk on tree and calls the delegate for each node.
// If the action delegate returns false, stop the walk.
//
// Return true if the entire tree has been walked.
// Otherwise returns false.
//
internal bool InOrderTreeWalk(TreeWalkPredicate<T> action)
{
return InOrderTreeWalk(action, false);
}
// Allows for the change in traversal direction. Reverse visits nodes in descending order
internal virtual bool InOrderTreeWalk(TreeWalkPredicate<T> action, bool reverse)
{
if (_root == null)
{
return true;
}
// The maximum height of a red-black tree is 2*lg(n+1).
// See page 264 of "Introduction to algorithms" by Thomas H. Cormen
// note: this should be logbase2, but since the stack grows itself, we
// don't want the extra cost
Stack<Node> stack = new Stack<Node>(2 * (int)(SortedSetExt<T>.log2(Count + 1)));
Node current = _root;
while (current != null)
{
stack.Push(current);
current = (reverse ? current.Right : current.Left);
}
while (stack.Count != 0)
{
current = stack.Pop();
if (!action(current))
{
return false;
}
Node node = (reverse ? current.Left : current.Right);
while (node != null)
{
stack.Push(node);
node = (reverse ? node.Right : node.Left);
}
}
return true;
}
//
// Do a left to right breadth first walk on tree and
// calls the delegate for each node.
// If the action delegate returns false, stop the walk.
//
// Return true if the entire tree has been walked.
// Otherwise returns false.
//
internal virtual bool BreadthFirstTreeWalk(TreeWalkPredicate<T> action)
{
if (_root == null)
{
return true;
}
Queue<Node> processQueue = new Queue<Node>();
processQueue.Enqueue(_root);
Node current;
while (processQueue.Count != 0)
{
current = processQueue.Dequeue();
if (!action(current))
{
return false;
}
if (current.Left != null)
{
processQueue.Enqueue(current.Left);
}
if (current.Right != null)
{
processQueue.Enqueue(current.Right);
}
}
return true;
}
#endregion
#region Properties
public int Count
{
get
{
VersionCheck();
return _count;
}
}
public IComparer<T> Comparer
{
get
{
return _comparer;
}
}
bool ICollection<T>.IsReadOnly
{
get
{
return false;
}
}
bool ICollection.IsSynchronized
{
get
{
return false;
}
}
object ICollection.SyncRoot
{
get
{
if (_syncRoot == null)
{
System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null);
}
return _syncRoot;
}
}
#endregion
#region Subclass helpers
//virtual function for subclass that needs to update count
internal virtual void VersionCheck() { }
//virtual function for subclass that needs to do range checks
internal virtual bool IsWithinRange(T item)
{
return true;
}
#endregion
#region ICollection<T> Members
/// <summary>
/// Add the value ITEM to the tree, returns true if added, false if duplicate
/// </summary>
/// <param name="item">item to be added</param>
public bool Add(T item)
{
return AddIfNotPresent(item);
}
void ICollection<T>.Add(T item)
{
AddIfNotPresent(item);
}
/// <summary>
/// Adds ITEM to the tree if not already present. Returns TRUE if value was successfully added
/// or FALSE if it is a duplicate
/// </summary>
internal virtual bool AddIfNotPresent(T item)
{
if (_root == null)
{ // empty tree
_root = new Node(item, false);
_count = 1;
_version++;
return true;
}
//
// Search for a node at bottom to insert the new node.
// If we can guanratee the node we found is not a 4-node, it would be easy to do insertion.
// We split 4-nodes along the search path.
//
Node current = _root;
Node parent = null;
Node grandParent = null;
Node greatGrandParent = null;
//even if we don't actually add to the set, we may be altering its structure (by doing rotations
//and such). so update version to disable any enumerators/subsets working on it
_version++;
int order = 0;
while (current != null)
{
order = _comparer.Compare(item, current.Item);
if (order == 0)
{
// We could have changed root node to red during the search process.
// We need to set it to black before we return.
_root.IsRed = false;
return false;
}
// split a 4-node into two 2-nodes
if (Is4Node(current))
{
Split4Node(current);
// We could have introduced two consecutive red nodes after split. Fix that by rotation.
if (IsRed(parent))
{
InsertionBalance(current, ref parent, grandParent, greatGrandParent);
}
}
greatGrandParent = grandParent;
grandParent = parent;
parent = current;
current = (order < 0) ? current.Left : current.Right;
}
Debug.Assert(parent != null, "Parent node cannot be null here!");
// ready to insert the new node
Node node = new Node(item);
if (order > 0)
{
parent.Right = node;
}
else
{
parent.Left = node;
}
// the new node will be red, so we will need to adjust the colors if parent node is also red
if (parent.IsRed)
{
InsertionBalance(node, ref parent, grandParent, greatGrandParent);
}
// Root node is always black
_root.IsRed = false;
++_count;
return true;
}
/// <summary>
/// Remove the T ITEM from this SortedSet. Returns true if successfully removed.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public bool Remove(T item)
{
return this.DoRemove(item); // hack so it can be made non-virtual
}
internal virtual bool DoRemove(T item)
{
if (_root == null)
{
return false;
}
// Search for a node and then find its succesor.
// Then copy the item from the succesor to the matching node and delete the successor.
// If a node doesn't have a successor, we can replace it with its left child (if not empty.)
// or delete the matching node.
//
// In top-down implementation, it is important to make sure the node to be deleted is not a 2-node.
// Following code will make sure the node on the path is not a 2 Node.
//even if we don't actually remove from the set, we may be altering its structure (by doing rotations
//and such). so update version to disable any enumerators/subsets working on it
_version++;
Node current = _root;
Node parent = null;
Node grandParent = null;
Node match = null;
Node parentOfMatch = null;
bool foundMatch = false;
while (current != null)
{
if (Is2Node(current))
{ // fix up 2-Node
if (parent == null)
{ // current is root. Mark it as red
current.IsRed = true;
}
else
{
Node sibling = GetSibling(current, parent);
if (sibling.IsRed)
{
// If parent is a 3-node, flip the orientation of the red link.
// We can acheive this by a single rotation
// This case is converted to one of other cased below.
Debug.Assert(!parent.IsRed, "parent must be a black node!");
if (parent.Right == sibling)
{
RotateLeft(parent);
}
else
{
RotateRight(parent);
}
parent.IsRed = true;
sibling.IsRed = false; // parent's color
// sibling becomes child of grandParent or root after rotation. Update link from grandParent or root
ReplaceChildOfNodeOrRoot(grandParent, parent, sibling);
// sibling will become grandParent of current node
grandParent = sibling;
if (parent == match)
{
parentOfMatch = sibling;
}
// update sibling, this is necessary for following processing
sibling = (parent.Left == current) ? parent.Right : parent.Left;
}
Debug.Assert(sibling != null || sibling.IsRed == false, "sibling must not be null and it must be black!");
if (Is2Node(sibling))
{
Merge2Nodes(parent, current, sibling);
}
else
{
// current is a 2-node and sibling is either a 3-node or a 4-node.
// We can change the color of current to red by some rotation.
TreeRotation rotation = RotationNeeded(parent, current, sibling);
Node newGrandParent = null;
switch (rotation)
{
case TreeRotation.RightRotation:
Debug.Assert(parent.Left == sibling, "sibling must be left child of parent!");
Debug.Assert(sibling.Left.IsRed, "Left child of sibling must be red!");
sibling.Left.IsRed = false;
newGrandParent = RotateRight(parent);
break;
case TreeRotation.LeftRotation:
Debug.Assert(parent.Right == sibling, "sibling must be left child of parent!");
Debug.Assert(sibling.Right.IsRed, "Right child of sibling must be red!");
sibling.Right.IsRed = false;
newGrandParent = RotateLeft(parent);
break;
case TreeRotation.RightLeftRotation:
Debug.Assert(parent.Right == sibling, "sibling must be left child of parent!");
Debug.Assert(sibling.Left.IsRed, "Left child of sibling must be red!");
newGrandParent = RotateRightLeft(parent);
break;
case TreeRotation.LeftRightRotation:
Debug.Assert(parent.Left == sibling, "sibling must be left child of parent!");
Debug.Assert(sibling.Right.IsRed, "Right child of sibling must be red!");
newGrandParent = RotateLeftRight(parent);
break;
}
newGrandParent.IsRed = parent.IsRed;
parent.IsRed = false;
current.IsRed = true;
ReplaceChildOfNodeOrRoot(grandParent, parent, newGrandParent);
if (parent == match)
{
parentOfMatch = newGrandParent;
}
grandParent = newGrandParent;
}
}
}
// we don't need to compare any more once we found the match
int order = foundMatch ? -1 : _comparer.Compare(item, current.Item);
if (order == 0)
{
// save the matching node
foundMatch = true;
match = current;
parentOfMatch = parent;
}
grandParent = parent;
parent = current;
if (order < 0)
{
current = current.Left;
}
else
{
current = current.Right; // continue the search in right sub tree after we find a match
}
}
// move successor to the matching node position and replace links
if (match != null)
{
ReplaceNode(match, parentOfMatch, parent, grandParent);
--_count;
}
if (_root != null)
{
_root.IsRed = false;
}
return foundMatch;
}
public virtual void Clear()
{
_root = null;
_count = 0;
++_version;
}
public virtual bool Contains(T item)
{
return FindNode(item) != null;
}
public void CopyTo(T[] array) { CopyTo(array, 0, Count); }
public void CopyTo(T[] array, int index) { CopyTo(array, index, Count); }
public void CopyTo(T[] array, int index, int count)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count", "SR.ArgumentOutOfRange_NeedNonNegNum");
}
// will array, starting at arrayIndex, be able to hold elements? Note: not
// checking arrayIndex >= array.Length (consistency with list of allowing
// count of 0; subsequent check takes care of the rest)
if (index > array.Length || count > array.Length - index)
{
throw new ArgumentException("SR.Arg_ArrayPlusOffTooSmall");
}
//upper bound
count += index;
InOrderTreeWalk(delegate (Node node)
{
if (index >= count)
{
return false;
}
else
{
array[index++] = node.Item;
return true;
}
});
}
void ICollection.CopyTo(Array array, int index)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
if (array.Rank != 1)
{
throw new ArgumentException("SR.Arg_RankMultiDimNotSupported");
}
if (array.GetLowerBound(0) != 0)
{
throw new ArgumentException("SR.Arg_NonZeroLowerBound");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("arrayIndex", "SR.ArgumentOutOfRange_NeedNonNegNum");
}
if (array.Length - index < Count)
{
throw new ArgumentException("SR.Arg_ArrayPlusOffTooSmall");
}
T[] tarray = array as T[];
if (tarray != null)
{
CopyTo(tarray, index);
}
else
{
object[] objects = array as object[];
if (objects == null)
{
throw new ArgumentException("SR.Argument_InvalidArrayType");
}
try
{
InOrderTreeWalk(delegate (Node node) { objects[index++] = node.Item; return true; });
}
catch (ArrayTypeMismatchException)
{
throw new ArgumentException("SR.Argument_InvalidArrayType");
}
}
}
#endregion
#region IEnumerable<T> members
public Enumerator GetEnumerator()
{
return new Enumerator(this);
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return new Enumerator(this);
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator(this);
}
#endregion
#region Tree Specific Operations
private static Node GetSibling(Node node, Node parent)
{
if (parent.Left == node)
{
return parent.Right;
}
return parent.Left;
}
// After calling InsertionBalance, we need to make sure current and parent up-to-date.
// It doesn't matter if we keep grandParent and greatGrantParent up-to-date
// because we won't need to split again in the next node.
// By the time we need to split again, everything will be correctly set.
//
private void InsertionBalance(Node current, ref Node parent, Node grandParent, Node greatGrandParent)
{
Debug.Assert(grandParent != null, "Grand parent cannot be null here!");
bool parentIsOnRight = (grandParent.Right == parent);
bool currentIsOnRight = (parent.Right == current);
Node newChildOfGreatGrandParent;
if (parentIsOnRight == currentIsOnRight)
{ // same orientation, single rotation
newChildOfGreatGrandParent = currentIsOnRight ? RotateLeft(grandParent) : RotateRight(grandParent);
}
else
{ // different orientaton, double rotation
newChildOfGreatGrandParent = currentIsOnRight ? RotateLeftRight(grandParent) : RotateRightLeft(grandParent);
// current node now becomes the child of greatgrandparent
parent = greatGrandParent;
}
// grand parent will become a child of either parent of current.
grandParent.IsRed = true;
newChildOfGreatGrandParent.IsRed = false;
ReplaceChildOfNodeOrRoot(greatGrandParent, grandParent, newChildOfGreatGrandParent);
}
private static bool Is2Node(Node node)
{
Debug.Assert(node != null, "node cannot be null!");
return IsBlack(node) && IsNullOrBlack(node.Left) && IsNullOrBlack(node.Right);
}
private static bool Is4Node(Node node)
{
return IsRed(node.Left) && IsRed(node.Right);
}
private static bool IsBlack(Node node)
{
return (node != null && !node.IsRed);
}
private static bool IsNullOrBlack(Node node)
{
return (node == null || !node.IsRed);
}
private static bool IsRed(Node node)
{
return (node != null && node.IsRed);
}
private static void Merge2Nodes(Node parent, Node child1, Node child2)
{
Debug.Assert(IsRed(parent), "parent must be be red");
// combing two 2-nodes into a 4-node
parent.IsRed = false;
child1.IsRed = true;
child2.IsRed = true;
}
// Replace the child of a parent node.
// If the parent node is null, replace the root.
private void ReplaceChildOfNodeOrRoot(Node parent, Node child, Node newChild)
{
if (parent != null)
{
if (parent.Left == child)
{
parent.Left = newChild;
}
else
{
parent.Right = newChild;
}
}
else
{
_root = newChild;
}
}
// Replace the matching node with its succesor.
private void ReplaceNode(Node match, Node parentOfMatch, Node succesor, Node parentOfSuccesor)
{
if (succesor == match)
{ // this node has no successor, should only happen if right child of matching node is null.
Debug.Assert(match.Right == null, "Right child must be null!");
succesor = match.Left;
}
else
{
Debug.Assert(parentOfSuccesor != null, "parent of successor cannot be null!");
Debug.Assert(succesor.Left == null, "Left child of succesor must be null!");
Debug.Assert((succesor.Right == null && succesor.IsRed) || (succesor.Right.IsRed && !succesor.IsRed), "Succesor must be in valid state");
if (succesor.Right != null)
{
succesor.Right.IsRed = false;
}
if (parentOfSuccesor != match)
{ // detach succesor from its parent and set its right child
parentOfSuccesor.Left = succesor.Right;
succesor.Right = match.Right;
}
succesor.Left = match.Left;
}
if (succesor != null)
{
succesor.IsRed = match.IsRed;
}
ReplaceChildOfNodeOrRoot(parentOfMatch, match, succesor);
}
internal virtual Node FindNode(T item)
{
Node current = _root;
while (current != null)
{
int order = _comparer.Compare(item, current.Item);
if (order == 0)
{
return current;
}
else
{
current = (order < 0) ? current.Left : current.Right;
}
}
return null;
}
internal virtual (Node, Node, Node) FindNeighbours(T item)
{
Node current = _root;
Node left = null;
Node right = null;
Node self = null;
while (current != null)
{
int order = _comparer.Compare(item, current.Item);
if (order != 0)
{
if (order > 0)
{
left = current;
current = current.Right;
}
else
{
right = current;
current = current.Left;
}
}
else
{
self = current;
if (current.Left != null)
{
left = current.Left;
while (left.Right != null)
left = left.Right;
}
if (current.Right != null)
{
right = current.Right;
while (right.Left != null)
right = right.Left;
}
break;
}
}
return (left, self, right);
}
//used for bithelpers. Note that this implementation is completely different
//from the Subset's. The two should not be mixed. This indexes as if the tree were an array.
//http://en.wikipedia.org/wiki/Binary_Tree#Methods_for_storing_binary_trees
internal virtual int InternalIndexOf(T item)
{
Node current = _root;
int count = 0;
while (current != null)
{
int order = _comparer.Compare(item, current.Item);
if (order == 0)
{
return count;
}
else
{
current = (order < 0) ? current.Left : current.Right;
count = (order < 0) ? (2 * count + 1) : (2 * count + 2);
}
}
return -1;
}
internal Node FindRange(T from, T to)
{
return FindRange(from, to, true, true);
}
internal Node FindRange(T from, T to, bool lowerBoundActive, bool upperBoundActive)
{
Node current = _root;
while (current != null)
{
if (lowerBoundActive && _comparer.Compare(from, current.Item) > 0)
{
current = current.Right;
}
else
{
if (upperBoundActive && _comparer.Compare(to, current.Item) < 0)
{
current = current.Left;
}
else
{
return current;
}
}
}
return null;
}
internal void UpdateVersion()
{
++_version;
}
private static Node RotateLeft(Node node)
{
Node x = node.Right;
node.Right = x.Left;
x.Left = node;
return x;
}
private static Node RotateLeftRight(Node node)
{
Node child = node.Left;
Node grandChild = child.Right;
node.Left = grandChild.Right;
grandChild.Right = node;
child.Right = grandChild.Left;
grandChild.Left = child;
return grandChild;
}
private static Node RotateRight(Node node)
{
Node x = node.Left;
node.Left = x.Right;
x.Right = node;
return x;
}
private static Node RotateRightLeft(Node node)
{
Node child = node.Right;
Node grandChild = child.Left;
node.Right = grandChild.Left;
grandChild.Left = node;
child.Left = grandChild.Right;
grandChild.Right = child;
return grandChild;
}
/// <summary>
/// Testing counter that can track rotations
/// </summary>
private static TreeRotation RotationNeeded(Node parent, Node current, Node sibling)
{
Debug.Assert(IsRed(sibling.Left) || IsRed(sibling.Right), "sibling must have at least one red child");
if (IsRed(sibling.Left))
{
if (parent.Left == current)
{
return TreeRotation.RightLeftRotation;
}
return TreeRotation.RightRotation;
}
else
{
if (parent.Left == current)
{
return TreeRotation.LeftRotation;
}
return TreeRotation.LeftRightRotation;
}
}
/// <summary>
/// Decides whether these sets are the same, given the comparer. If the EC's are the same, we can
/// just use SetEquals, but if they aren't then we have to manually check with the given comparer
/// </summary>
internal static bool SortedSetEquals(SortedSetExt<T> set1, SortedSetExt<T> set2, IComparer<T> comparer)
{
// handle null cases first
if (set1 == null)
{
return (set2 == null);
}
else if (set2 == null)
{
// set1 != null
return false;
}
if (AreComparersEqual(set1, set2))
{
if (set1.Count != set2.Count)
return false;
return set1.SetEquals(set2);
}
else
{
bool found = false;
foreach (T item1 in set1)
{
found = false;
foreach (T item2 in set2)
{
if (comparer.Compare(item1, item2) == 0)
{
found = true;
break;
}
}
if (!found)
return false;
}
return true;
}
}
//This is a little frustrating because we can't support more sorted structures
private static bool AreComparersEqual(SortedSetExt<T> set1, SortedSetExt<T> set2)
{
return set1.Comparer.Equals(set2.Comparer);
}
private static void Split4Node(Node node)
{
node.IsRed = true;
node.Left.IsRed = false;
node.Right.IsRed = false;
}
/// <summary>
/// Copies this to an array. Used for DebugView
/// </summary>
/// <returns></returns>
internal T[] ToArray()
{
T[] newArray = new T[Count];
CopyTo(newArray);
return newArray;
}
#endregion
#region ISet Members
/// <summary>
/// Transform this set into its union with the IEnumerable OTHER
///Attempts to insert each element and rejects it if it exists.
/// NOTE: The caller object is important as UnionWith uses the Comparator
///associated with THIS to check equality
/// Throws ArgumentNullException if OTHER is null
/// </summary>
/// <param name="other"></param>
public void UnionWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
SortedSetExt<T> s = other as SortedSetExt<T>;
TreeSubSet t = this as TreeSubSet;
if (t != null)
VersionCheck();
if (s != null && t == null && _count == 0)
{
SortedSetExt<T> dummy = new SortedSetExt<T>(s, _comparer);
_root = dummy._root;
_count = dummy._count;
_version++;
return;
}
if (s != null && t == null && AreComparersEqual(this, s) && (s.Count > this.Count / 2))
{ //this actually hurts if N is much greater than M the /2 is arbitrary
//first do a merge sort to an array.
T[] merged = new T[s.Count + this.Count];
int c = 0;
Enumerator mine = this.GetEnumerator();
Enumerator theirs = s.GetEnumerator();
bool mineEnded = !mine.MoveNext(), theirsEnded = !theirs.MoveNext();
while (!mineEnded && !theirsEnded)
{
int comp = Comparer.Compare(mine.Current, theirs.Current);
if (comp < 0)
{
merged[c++] = mine.Current;
mineEnded = !mine.MoveNext();
}
else if (comp == 0)
{
merged[c++] = theirs.Current;
mineEnded = !mine.MoveNext();
theirsEnded = !theirs.MoveNext();
}
else
{
merged[c++] = theirs.Current;
theirsEnded = !theirs.MoveNext();
}
}
if (!mineEnded || !theirsEnded)
{
Enumerator remaining = (mineEnded ? theirs : mine);
do
{
merged[c++] = remaining.Current;
} while (remaining.MoveNext());
}
//now merged has all c elements
//safe to gc the root, we have all the elements
_root = null;
_root = SortedSetExt<T>.ConstructRootFromSortedArray(merged, 0, c - 1, null);
_count = c;
_version++;
}
else
{
AddAllElements(other);
}
}
private static Node ConstructRootFromSortedArray(T[] arr, int startIndex, int endIndex, Node redNode)
{
//what does this do?
//you're given a sorted array... say 1 2 3 4 5 6
//2 cases:
// If there are odd # of elements, pick the middle element (in this case 4), and compute
// its left and right branches
// If there are even # of elements, pick the left middle element, save the right middle element
// and call the function on the rest
// 1 2 3 4 5 6 -> pick 3, save 4 and call the fn on 1,2 and 5,6
// now add 4 as a red node to the lowest element on the right branch
// 3 3
// 1 5 -> 1 5
// 2 6 2 4 6
// As we're adding to the leftmost of the right branch, nesting will not hurt the red-black properties
// Leaf nodes are red if they have no sibling (if there are 2 nodes or if a node trickles
// down to the bottom
//the iterative way to do this ends up wasting more space than it saves in stack frames (at
//least in what i tried)
//so we're doing this recursively
//base cases are described below
int size = endIndex - startIndex + 1;
if (size == 0)
{
return null;
}
Node root = null;
if (size == 1)
{
root = new Node(arr[startIndex], false);
if (redNode != null)
{
root.Left = redNode;
}
}
else if (size == 2)
{
root = new Node(arr[startIndex], false);
root.Right = new Node(arr[endIndex], false);
root.Right.IsRed = true;
if (redNode != null)
{
root.Left = redNode;
}
}
else if (size == 3)
{
root = new Node(arr[startIndex + 1], false);
root.Left = new Node(arr[startIndex], false);
root.Right = new Node(arr[endIndex], false);
if (redNode != null)
{
root.Left.Left = redNode;
}
}
else
{
int midpt = ((startIndex + endIndex) / 2);
root = new Node(arr[midpt], false);
root.Left = ConstructRootFromSortedArray(arr, startIndex, midpt - 1, redNode);
if (size % 2 == 0)
{
root.Right = ConstructRootFromSortedArray(arr, midpt + 2, endIndex, new Node(arr[midpt + 1], true));
}
else
{
root.Right = ConstructRootFromSortedArray(arr, midpt + 1, endIndex, null);
}
}
return root;
}
/// <summary>
/// Transform this set into its intersection with the IEnumerable OTHER
/// NOTE: The caller object is important as IntersectionWith uses the
/// comparator associated with THIS to check equality
/// Throws ArgumentNullException if OTHER is null
/// </summary>
/// <param name="other"></param>
public virtual void IntersectWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if (Count == 0)
return;
//HashSet<T> optimizations can't be done until equality comparers and comparers are related
//Technically, this would work as well with an ISorted<T>
SortedSetExt<T> s = other as SortedSetExt<T>;
TreeSubSet t = this as TreeSubSet;
if (t != null)
VersionCheck();
//only let this happen if i am also a SortedSet, not a SubSet
if (s != null && t == null && AreComparersEqual(this, s))
{
//first do a merge sort to an array.
T[] merged = new T[this.Count];
int c = 0;
Enumerator mine = this.GetEnumerator();
Enumerator theirs = s.GetEnumerator();
bool mineEnded = !mine.MoveNext(), theirsEnded = !theirs.MoveNext();
T max = Max;
T min = Min;
while (!mineEnded && !theirsEnded && Comparer.Compare(theirs.Current, max) <= 0)
{
int comp = Comparer.Compare(mine.Current, theirs.Current);
if (comp < 0)
{
mineEnded = !mine.MoveNext();
}
else if (comp == 0)
{
merged[c++] = theirs.Current;
mineEnded = !mine.MoveNext();
theirsEnded = !theirs.MoveNext();
}
else
{
theirsEnded = !theirs.MoveNext();
}
}
//now merged has all c elements
//safe to gc the root, we have all the elements
_root = null;
_root = SortedSetExt<T>.ConstructRootFromSortedArray(merged, 0, c - 1, null);
_count = c;
_version++;
}
else
{
IntersectWithEnumerable(other);
}
}
internal virtual void IntersectWithEnumerable(IEnumerable<T> other)
{
//TODO: Perhaps a more space-conservative way to do this
List<T> toSave = new List<T>(this.Count);
foreach (T item in other)
{
if (this.Contains(item))
{
toSave.Add(item);
this.Remove(item);
}
}
this.Clear();
AddAllElements(toSave);
}
/// <summary>
/// Transform this set into its complement with the IEnumerable OTHER
/// NOTE: The caller object is important as ExceptWith uses the
/// comparator associated with THIS to check equality
/// Throws ArgumentNullException if OTHER is null
/// </summary>
/// <param name="other"></param>
public void ExceptWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if (_count == 0)
return;
if (other == this)
{
this.Clear();
return;
}
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(this, asSorted))
{
//outside range, no point doing anything
if (!(_comparer.Compare(asSorted.Max, this.Min) < 0 || _comparer.Compare(asSorted.Min, this.Max) > 0))
{
T min = this.Min;
T max = this.Max;
foreach (T item in other)
{
if (_comparer.Compare(item, min) < 0)
continue;
if (_comparer.Compare(item, max) > 0)
break;
Remove(item);
}
}
}
else
{
RemoveAllElements(other);
}
}
/// <summary>
/// Transform this set so it contains elements in THIS or OTHER but not both
/// NOTE: The caller object is important as SymmetricExceptWith uses the
/// comparator associated with THIS to check equality
/// Throws ArgumentNullException if OTHER is null
/// </summary>
/// <param name="other"></param>
public void SymmetricExceptWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if (this.Count == 0)
{
this.UnionWith(other);
return;
}
if (other == this)
{
this.Clear();
return;
}
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(this, asSorted))
{
SymmetricExceptWithSameEC(asSorted);
}
else
{
//need perf improvement on this
T[] elements = (new List<T>(other)).ToArray();
Array.Sort(elements, this.Comparer);
SymmetricExceptWithSameEC(elements);
}
}
//OTHER must be a set
internal void SymmetricExceptWithSameEC(ISet<T> other)
{
foreach (T item in other)
{
//yes, it is classier to say
//if (!this.Remove(item))this.Add(item);
//but this ends up saving on rotations
if (this.Contains(item))
{
this.Remove(item);
}
else
{
this.Add(item);
}
}
}
//OTHER must be a sorted array
internal void SymmetricExceptWithSameEC(T[] other)
{
if (other.Length == 0)
{
return;
}
T last = other[0];
for (int i = 0; i < other.Length; i++)
{
while (i < other.Length && i != 0 && _comparer.Compare(other[i], last) == 0)
i++;
if (i >= other.Length)
break;
if (this.Contains(other[i]))
{
this.Remove(other[i]);
}
else
{
this.Add(other[i]);
}
last = other[i];
}
}
/// <summary>
/// Checks whether this Tree is a subset of the IEnumerable other
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool IsSubsetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if (Count == 0)
return true;
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(this, asSorted))
{
if (this.Count > asSorted.Count)
return false;
return IsSubsetOfSortedSetWithSameEC(asSorted);
}
else
{
//worst case: mark every element in my set and see if i've counted all
//O(MlogN)
ElementCount result = CheckUniqueAndUnfoundElements(other, false);
return (result.uniqueCount == Count && result.unfoundCount >= 0);
}
}
private bool IsSubsetOfSortedSetWithSameEC(SortedSetExt<T> asSorted)
{
SortedSetExt<T> prunedOther = asSorted.GetViewBetween(this.Min, this.Max);
foreach (T item in this)
{
if (!prunedOther.Contains(item))
return false;
}
return true;
}
/// <summary>
/// Checks whether this Tree is a proper subset of the IEnumerable other
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool IsProperSubsetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if ((other as ICollection) != null)
{
if (Count == 0)
return (other as ICollection).Count > 0;
}
//another for sorted sets with the same comparer
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(this, asSorted))
{
if (this.Count >= asSorted.Count)
return false;
return IsSubsetOfSortedSetWithSameEC(asSorted);
}
//worst case: mark every element in my set and see if i've counted all
//O(MlogN).
ElementCount result = CheckUniqueAndUnfoundElements(other, false);
return (result.uniqueCount == Count && result.unfoundCount > 0);
}
/// <summary>
/// Checks whether this Tree is a super set of the IEnumerable other
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool IsSupersetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if ((other as ICollection) != null && (other as ICollection).Count == 0)
return true;
//do it one way for HashSets
//another for sorted sets with the same comparer
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(this, asSorted))
{
if (this.Count < asSorted.Count)
return false;
SortedSetExt<T> pruned = GetViewBetween(asSorted.Min, asSorted.Max);
foreach (T item in asSorted)
{
if (!pruned.Contains(item))
return false;
}
return true;
}
//and a third for everything else
return ContainsAllElements(other);
}
/// <summary>
/// Checks whether this Tree is a proper super set of the IEnumerable other
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool IsProperSupersetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if (Count == 0)
return false;
if ((other as ICollection) != null && (other as ICollection).Count == 0)
return true;
//another way for sorted sets
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(asSorted, this))
{
if (asSorted.Count >= this.Count)
return false;
SortedSetExt<T> pruned = GetViewBetween(asSorted.Min, asSorted.Max);
foreach (T item in asSorted)
{
if (!pruned.Contains(item))
return false;
}
return true;
}
//worst case: mark every element in my set and see if i've counted all
//O(MlogN)
//slight optimization, put it into a HashSet and then check can do it in O(N+M)
//but slower in better cases + wastes space
ElementCount result = CheckUniqueAndUnfoundElements(other, true);
return (result.uniqueCount < Count && result.unfoundCount == 0);
}
/// <summary>
/// Checks whether this Tree has all elements in common with IEnumerable other
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool SetEquals(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(this, asSorted))
{
IEnumerator<T> mine = this.GetEnumerator();
IEnumerator<T> theirs = asSorted.GetEnumerator();
bool mineEnded = !mine.MoveNext();
bool theirsEnded = !theirs.MoveNext();
while (!mineEnded && !theirsEnded)
{
if (Comparer.Compare(mine.Current, theirs.Current) != 0)
{
return false;
}
mineEnded = !mine.MoveNext();
theirsEnded = !theirs.MoveNext();
}
return mineEnded && theirsEnded;
}
//worst case: mark every element in my set and see if i've counted all
//O(N) by size of other
ElementCount result = CheckUniqueAndUnfoundElements(other, true);
return (result.uniqueCount == Count && result.unfoundCount == 0);
}
/// <summary>
/// Checks whether this Tree has any elements in common with IEnumerable other
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Overlaps(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if (this.Count == 0)
return false;
if ((other as ICollection<T> != null) && (other as ICollection<T>).Count == 0)
return false;
SortedSetExt<T> asSorted = other as SortedSetExt<T>;
if (asSorted != null && AreComparersEqual(this, asSorted) && (_comparer.Compare(Min, asSorted.Max) > 0 || _comparer.Compare(Max, asSorted.Min) < 0))
{
return false;
}
foreach (T item in other)
{
if (this.Contains(item))
{
return true;
}
}
return false;
}
/// <summary>
/// This works similar to HashSet's CheckUniqueAndUnfound (description below), except that the bit
/// array maps differently than in the HashSet. We can only use this for the bulk boolean checks.
///
/// Determines counts that can be used to determine equality, subset, and superset. This
/// is only used when other is an IEnumerable and not a HashSet. If other is a HashSet
/// these properties can be checked faster without use of marking because we can assume
/// other has no duplicates.
///
/// The following count checks are performed by callers:
/// 1. Equals: checks if unfoundCount = 0 and uniqueFoundCount = Count; i.e. everything
/// in other is in this and everything in this is in other
/// 2. Subset: checks if unfoundCount >= 0 and uniqueFoundCount = Count; i.e. other may
/// have elements not in this and everything in this is in other
/// 3. Proper subset: checks if unfoundCount > 0 and uniqueFoundCount = Count; i.e
/// other must have at least one element not in this and everything in this is in other
/// 4. Proper superset: checks if unfound count = 0 and uniqueFoundCount strictly less
/// than Count; i.e. everything in other was in this and this had at least one element
/// not contained in other.
///
/// An earlier implementation used delegates to perform these checks rather than returning
/// an ElementCount struct; however this was changed due to the perf overhead of delegates.
/// </summary>
/// <param name="other"></param>
/// <param name="returnIfUnfound">Allows us to finish faster for equals and proper superset
/// because unfoundCount must be 0.</param>
/// <returns></returns>
// <SecurityKernel Critical="True" Ring="0">
// <UsesUnsafeCode Name="Local bitArrayPtr of type: Int32*" />
// <ReferencesCritical Name="Method: BitHelper..ctor(System.Int32*,System.Int32)" Ring="1" />
// <ReferencesCritical Name="Method: BitHelper.IsMarked(System.Int32):System.Boolean" Ring="1" />
// <ReferencesCritical Name="Method: BitHelper.MarkBit(System.Int32):System.Void" Ring="1" />
// </SecurityKernel>
private unsafe ElementCount CheckUniqueAndUnfoundElements(IEnumerable<T> other, bool returnIfUnfound)
{
ElementCount result;
// need special case in case this has no elements.
if (Count == 0)
{
int numElementsInOther = 0;
foreach (T item in other)
{
numElementsIn
gitextract_19g_u3m2/
├── .claude/
│ └── CLAUDE.md
├── .config/
│ └── dotnet-tools.json
├── .github/
│ └── workflows/
│ ├── build.yml
│ ├── docs-check.yml
│ └── publish.yml
├── .gitignore
├── .vscode/
│ ├── settings.json
│ └── tasks.json
├── AGENTS.md
├── LICENSE
├── PACKAGES.md
├── README.md
├── RELEASE_NOTES.md
├── ai/
│ ├── ALGORITHMS.md
│ ├── COLLECTIONS.md
│ ├── DOC_ACCURACY_AUDIT.md
│ ├── FSHARP_INTEROP.md
│ ├── INCREMENTAL.md
│ ├── PIXIMAGE.md
│ ├── PRIMITIVE_TYPES.md
│ ├── README.md
│ ├── RECIPE_AI_FRIENDLINESS.md
│ ├── SEMANTICS_GEOMETRY_CORE.md
│ ├── SEMANTICS_LINEAR_ALGEBRA.md
│ ├── SERIALIZATION.md
│ ├── SYMBOL_INDEX.md
│ ├── TENSORS.md
│ └── UTILITIES.md
├── build.cmd
├── build.sh
├── check-docs.cmd
├── check-docs.sh
├── generate.cmd
├── generate.sh
├── global.json
├── paket.dependencies
├── src/
│ ├── Aardvark.Base/
│ │ ├── Aardvark.Base.csproj
│ │ ├── AlgoDat/
│ │ │ ├── AdaBoost.cs
│ │ │ ├── ConcurrentHashSet.cs
│ │ │ ├── ExtendedCore/
│ │ │ │ ├── BitHelpers.cs
│ │ │ │ └── SortedSetExt.cs
│ │ │ ├── INode.cs
│ │ │ ├── LruCache.cs
│ │ │ ├── Meta.cs
│ │ │ ├── MinimumSpanningTree.cs
│ │ │ ├── SalesmanOfDeath.cs
│ │ │ ├── ShortestPath.cs
│ │ │ └── Span.cs
│ │ ├── Delegates/
│ │ │ ├── Delegates.cs
│ │ │ ├── Delegates_auto.cs
│ │ │ ├── Delegates_template.cs
│ │ │ └── HigherOrderFunctions.cs
│ │ ├── Extensions/
│ │ │ ├── ArrayExtensions.cs
│ │ │ ├── CastExtensions.cs
│ │ │ ├── DagExtensions.cs
│ │ │ ├── DateTimeExtensions.cs
│ │ │ ├── DictionaryExtensions.cs
│ │ │ ├── EnumHelpers.cs
│ │ │ ├── EventHandlerExtensions.cs
│ │ │ ├── FuncActionExtensions.cs
│ │ │ ├── FuncActionExtensions_auto.cs
│ │ │ ├── FuncActionExtensions_template.cs
│ │ │ ├── HigherOrderFunctions.cs
│ │ │ ├── ICollectionExtensions.cs
│ │ │ ├── IEnumerableExtensions.cs
│ │ │ ├── IListExtensions.cs
│ │ │ ├── IsExternalInit.cs
│ │ │ ├── ListExtensions.cs
│ │ │ ├── NonGenericArray.cs
│ │ │ ├── SequenceExtensions_auto.cs
│ │ │ ├── SequenceExtensions_template.cs
│ │ │ ├── StreamExtensions.cs
│ │ │ ├── StringExtensions.cs
│ │ │ ├── Structs.cs
│ │ │ ├── SubRange.cs
│ │ │ ├── SystemDrawingExtensions.cs
│ │ │ ├── TupleExtensions.cs
│ │ │ ├── TypeExtensions.cs
│ │ │ └── VariousExtensions.cs
│ │ ├── Geodesy/
│ │ │ ├── GeoConsts.cs
│ │ │ └── GeoConversion.cs
│ │ ├── Geometry/
│ │ │ ├── Algorithms_auto.cs
│ │ │ ├── Algorithms_template.cs
│ │ │ ├── BbTree.cs
│ │ │ ├── ClippingFunctions_auto.cs
│ │ │ ├── ClippingFunctions_template.cs
│ │ │ ├── Interfaces/
│ │ │ │ ├── IBoundingBox_auto.cs
│ │ │ │ ├── IBoundingBox_template.cs
│ │ │ │ ├── IBoundingCircle.cs
│ │ │ │ ├── IBoundingSphere.cs
│ │ │ │ ├── IImmutablePolygon.cs
│ │ │ │ └── IPolygon.cs
│ │ │ ├── IntersectionTests_auto.cs
│ │ │ ├── IntersectionTests_template.cs
│ │ │ ├── Relations/
│ │ │ │ ├── LinearCombination_auto.cs
│ │ │ │ ├── LinearCombination_template.cs
│ │ │ │ ├── Orthogonality_auto.cs
│ │ │ │ ├── Orthogonality_template.cs
│ │ │ │ ├── Parallelism_auto.cs
│ │ │ │ ├── Parallelism_template.cs
│ │ │ │ ├── SubPrimitives_auto.cs
│ │ │ │ └── SubPrimitives_template.cs
│ │ │ ├── SpecialPoints_auto.cs
│ │ │ ├── SpecialPoints_template.cs
│ │ │ └── Types/
│ │ │ ├── Capsule/
│ │ │ │ ├── Capsule3_auto.cs
│ │ │ │ └── Capsule3_template.cs
│ │ │ ├── Circle/
│ │ │ │ ├── Circle2_auto.cs
│ │ │ │ ├── Circle2_template.cs
│ │ │ │ ├── Circle3_auto.cs
│ │ │ │ └── Circle3_template.cs
│ │ │ ├── Cone/
│ │ │ │ ├── Cone3_auto.cs
│ │ │ │ ├── Cone3_template.cs
│ │ │ │ ├── Conic2_auto.cs
│ │ │ │ └── Conic2_template.cs
│ │ │ ├── Cylinder/
│ │ │ │ ├── Cylinder3_auto.cs
│ │ │ │ └── Cylinder3_template.cs
│ │ │ ├── Ellipse/
│ │ │ │ ├── Ellipse2_auto.cs
│ │ │ │ ├── Ellipse2_template.cs
│ │ │ │ ├── Ellipse3_auto.cs
│ │ │ │ ├── Ellipse3_template.cs
│ │ │ │ ├── Ellipse_auto.cs
│ │ │ │ └── Ellipse_template.cs
│ │ │ ├── Geometry1i.cs
│ │ │ ├── Geometry1i_auto.cs
│ │ │ ├── Geometry1i_template.cs
│ │ │ ├── Geometry_auto.cs
│ │ │ ├── Geometry_template.cs
│ │ │ ├── Hull/
│ │ │ │ ├── Hull2_auto.cs
│ │ │ │ ├── Hull2_template.cs
│ │ │ │ ├── Hull3_auto.cs
│ │ │ │ └── Hull3_template.cs
│ │ │ ├── Line/
│ │ │ │ ├── Line2_auto.cs
│ │ │ │ ├── Line2_template.cs
│ │ │ │ ├── Line3_auto.cs
│ │ │ │ └── Line3_template.cs
│ │ │ ├── Line1iPoint.cs
│ │ │ ├── Plane/
│ │ │ │ ├── Plane2_auto.cs
│ │ │ │ ├── Plane2_template.cs
│ │ │ │ ├── Plane3_auto.cs
│ │ │ │ └── Plane3_template.cs
│ │ │ ├── Polygon/
│ │ │ │ ├── IImmutablePolygonExtensions_auto.cs
│ │ │ │ ├── IImmutablePolygonExtensions_template.cs
│ │ │ │ ├── ImmutablePolygon.cs
│ │ │ │ ├── Polygon2_auto.cs
│ │ │ │ ├── Polygon2_template.cs
│ │ │ │ ├── Polygon3_auto.cs
│ │ │ │ ├── Polygon3_template.cs
│ │ │ │ ├── PolygonExtensions_auto.cs
│ │ │ │ └── PolygonExtensions_template.cs
│ │ │ ├── Quad/
│ │ │ │ ├── Quad2_auto.cs
│ │ │ │ ├── Quad2_template.cs
│ │ │ │ ├── Quad3_auto.cs
│ │ │ │ └── Quad3_template.cs
│ │ │ ├── Quadric/
│ │ │ │ ├── Quadric_auto.cs
│ │ │ │ └── Quadric_template.cs
│ │ │ ├── Ray/
│ │ │ │ ├── Ray2_auto.cs
│ │ │ │ ├── Ray2_template.cs
│ │ │ │ ├── Ray3_auto.cs
│ │ │ │ └── Ray3_template.cs
│ │ │ ├── Sphere/
│ │ │ │ ├── Sphere3_auto.cs
│ │ │ │ └── Sphere3_template.cs
│ │ │ ├── Torus/
│ │ │ │ ├── Torus3_auto.cs
│ │ │ │ └── Torus3_template.cs
│ │ │ └── Triangle/
│ │ │ ├── Triangle2_auto.cs
│ │ │ ├── Triangle2_template.cs
│ │ │ ├── Triangle3_auto.cs
│ │ │ └── Triangle3_template.cs
│ │ ├── Hashing/
│ │ │ └── HashCode.cs
│ │ ├── Introspection/
│ │ │ ├── Aardvark.cs
│ │ │ ├── CachingProperties.cs
│ │ │ ├── Introspection.cs
│ │ │ ├── IntrospectionProperties.cs
│ │ │ ├── Native.cs
│ │ │ ├── Platform/
│ │ │ │ ├── Dl.cs
│ │ │ │ ├── Kernel32.cs
│ │ │ │ └── LdConfig.cs
│ │ │ ├── Plugins.cs
│ │ │ ├── RegexPatterns.cs
│ │ │ └── Utilities.cs
│ │ ├── Json/
│ │ │ └── JsonConverters.cs
│ │ ├── Math/
│ │ │ ├── Base/
│ │ │ │ ├── Adler32.cs
│ │ │ │ ├── AliasTable_auto.cs
│ │ │ │ ├── AliasTable_template.cs
│ │ │ │ ├── Complex_auto.cs
│ │ │ │ ├── Complex_template.cs
│ │ │ │ ├── Constant.cs
│ │ │ │ ├── Conversion.cs
│ │ │ │ ├── DistributionFunction.cs
│ │ │ │ ├── Fraction.cs
│ │ │ │ ├── Fun.cs
│ │ │ │ ├── Fun_auto.cs
│ │ │ │ ├── Fun_template.cs
│ │ │ │ ├── Half.cs
│ │ │ │ ├── MedianWindow.cs
│ │ │ │ ├── PhysicsConsts.cs
│ │ │ │ ├── Quaternion_auto.cs
│ │ │ │ ├── Quaternion_template.cs
│ │ │ │ ├── SampleGrid2d.cs
│ │ │ │ ├── Statistics.cs
│ │ │ │ └── WeightedIndex.cs
│ │ │ ├── Colors/
│ │ │ │ ├── Color.cs
│ │ │ │ ├── Color_auto.cs
│ │ │ │ ├── Color_template.cs
│ │ │ │ └── Spectrum.cs
│ │ │ ├── Curves/
│ │ │ │ └── Curves.cs
│ │ │ ├── Interfaces/
│ │ │ │ ├── IMatrix.cs
│ │ │ │ ├── IOpacity.cs
│ │ │ │ ├── IRGB.cs
│ │ │ │ ├── IRange.cs
│ │ │ │ ├── ISize_auto.cs
│ │ │ │ ├── ISize_template.cs
│ │ │ │ ├── ITensor.cs
│ │ │ │ ├── IValidity.cs
│ │ │ │ ├── IVector.cs
│ │ │ │ └── IVolume.cs
│ │ │ ├── Interfaces.cs
│ │ │ ├── Interpolation/
│ │ │ │ ├── Interpolation.cs
│ │ │ │ └── Mapping.cs
│ │ │ ├── LuFactorization.cs
│ │ │ ├── Numerics/
│ │ │ │ ├── CovarianceMatrix.cs
│ │ │ │ └── Polynomial.cs
│ │ │ ├── QrFactorization.cs
│ │ │ ├── RangesBoxes/
│ │ │ │ ├── Box.cs
│ │ │ │ ├── Box_auto.cs
│ │ │ │ ├── Box_template.cs
│ │ │ │ ├── Cell.cs
│ │ │ │ ├── Cell2d.cs
│ │ │ │ ├── OrientedBox_auto.cs
│ │ │ │ └── OrientedBox_template.cs
│ │ │ ├── Trafos/
│ │ │ │ ├── Affine_auto.cs
│ │ │ │ ├── Affine_template.cs
│ │ │ │ ├── CoordTransforms.cs
│ │ │ │ ├── CoordinateSystem.cs
│ │ │ │ ├── Euclidean_auto.cs
│ │ │ │ ├── Euclidean_template.cs
│ │ │ │ ├── M33_auto.cs
│ │ │ │ ├── M33_template.cs
│ │ │ │ ├── M44_auto.cs
│ │ │ │ ├── M44_template.cs
│ │ │ │ ├── MatrixArrayExtensions.cs
│ │ │ │ ├── Matrix_auto.cs
│ │ │ │ ├── Matrix_template.cs
│ │ │ │ ├── Rot2_auto.cs
│ │ │ │ ├── Rot2_template.cs
│ │ │ │ ├── Rot3_auto.cs
│ │ │ │ ├── Rot3_template.cs
│ │ │ │ ├── Scale_auto.cs
│ │ │ │ ├── Scale_template.cs
│ │ │ │ ├── Shift_auto.cs
│ │ │ │ ├── Shift_template.cs
│ │ │ │ ├── Similarity_auto.cs
│ │ │ │ ├── Similarity_template.cs
│ │ │ │ ├── Trafo_auto.cs
│ │ │ │ └── Trafo_template.cs
│ │ │ └── Vectors/
│ │ │ ├── HashCode.cs
│ │ │ ├── V3fCoder.cs
│ │ │ ├── VectorArrayExtensions.cs
│ │ │ ├── VectorIEnumerableExtensions_auto.cs
│ │ │ ├── VectorIEnumerableExtensions_template.cs
│ │ │ ├── VectorTypeConverter_auto.cs
│ │ │ ├── VectorTypeConverter_template.cs
│ │ │ ├── Vector_auto.cs
│ │ │ └── Vector_template.cs
│ │ ├── Random/
│ │ │ ├── ForcedRandomSeries.cs
│ │ │ ├── HaltonRandomSeries.cs
│ │ │ ├── IRandomDistribution.cs
│ │ │ ├── IRandomSeries.cs
│ │ │ ├── IRandomUniform.cs
│ │ │ ├── PerlinNoise.cs
│ │ │ ├── Prime.cs
│ │ │ ├── PseudoRandomSeries.cs
│ │ │ ├── Quasi.cs
│ │ │ ├── RandomDistributions.cs
│ │ │ ├── RandomIEnumerableExtensions.cs
│ │ │ ├── RandomSample.cs
│ │ │ └── RandomSystem.cs
│ │ ├── Reporting/
│ │ │ ├── FilterLogTarget.cs
│ │ │ ├── IJobReporter.cs
│ │ │ ├── ILogTarget.cs
│ │ │ ├── IReportable.cs
│ │ │ ├── IReporter.cs
│ │ │ ├── JobReporter.cs
│ │ │ ├── LogMsg.cs
│ │ │ ├── MultiLogTarget.cs
│ │ │ ├── NullReporter.cs
│ │ │ ├── PerThreadJobReporter.cs
│ │ │ ├── PerThreadLogTarget.cs
│ │ │ ├── Report.cs
│ │ │ ├── ReportJob.cs
│ │ │ ├── Skipper.cs
│ │ │ ├── TestInfo.cs
│ │ │ └── TextLogTarget.cs
│ │ ├── Sorting/
│ │ │ ├── ArrayExtensions.cs
│ │ │ ├── IEnumerableExtensions.cs
│ │ │ ├── ListExtensions.cs
│ │ │ ├── Sorting_auto.cs
│ │ │ └── Sorting_template.cs
│ │ ├── Symbol/
│ │ │ ├── Dict_auto.cs
│ │ │ ├── Dict_template.cs
│ │ │ ├── Dicts.cs
│ │ │ ├── IDict.cs
│ │ │ ├── SymMapBase.cs
│ │ │ ├── SymMapBaseTraversal.cs
│ │ │ └── Symbol.cs
│ │ ├── Text/
│ │ │ ├── Text.cs
│ │ │ └── TextParser.cs
│ │ ├── Tup/
│ │ │ ├── Tuples_auto.cs
│ │ │ └── Tuples_template.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Essentials/
│ │ ├── Aardvark.Base.Essentials.csproj
│ │ ├── Camera/
│ │ │ ├── CameraProjectionOrtho.cs
│ │ │ ├── CameraProjectionPerspective.cs
│ │ │ ├── CameraViewRaw.cs
│ │ │ ├── CameraViewWithSky.cs
│ │ │ ├── ICameraProjection.cs
│ │ │ ├── ICameraProjectionExtensions.cs
│ │ │ ├── ICameraView.cs
│ │ │ ├── ICameraViewExtensions.cs
│ │ │ ├── IRenderView.cs
│ │ │ └── IRenderViewExtensions.cs
│ │ ├── Editing/
│ │ │ ├── BehaviorDragAbsolute.cs
│ │ │ ├── BehaviorDragRelative.cs
│ │ │ ├── IBehavior.cs
│ │ │ ├── IBehaviorDeletable.cs
│ │ │ ├── IBehaviorPosition2d.cs
│ │ │ ├── IBehaviorSplittableEdge2d.cs
│ │ │ ├── IBehaviorTransform2d.cs
│ │ │ ├── IEditableEdge2d.cs
│ │ │ ├── IEditableFace2d.cs
│ │ │ ├── IEditableSequence.cs
│ │ │ └── IEditableVertex2d.cs
│ │ ├── NormalizedDeviceCoordinates.cs
│ │ ├── PixelPosition.cs
│ │ ├── Screenshot.cs
│ │ ├── System/
│ │ │ ├── Awaitable.cs
│ │ │ ├── Clock.cs
│ │ │ ├── Disposable.cs
│ │ │ ├── EventSource.cs
│ │ │ ├── EventSourceExtensions.cs
│ │ │ ├── EventSourceInterfaces.cs
│ │ │ ├── EventSourceSpecials.cs
│ │ │ ├── FilteredEventSource.cs
│ │ │ ├── IAwaitable.cs
│ │ │ ├── Reactive.cs
│ │ │ ├── Time.cs
│ │ │ └── WithCancellationExtension.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.FSharp/
│ │ ├── Aardvark.Base.FSharp.fsproj
│ │ ├── Ag.fs
│ │ ├── Algorithms/
│ │ │ └── PolygonSimplification.fs
│ │ ├── Color/
│ │ │ ├── ColorBrewer.fs
│ │ │ ├── ColorBrewerSchemes.fs
│ │ │ └── ColorBrewerSchemes.fsx
│ │ ├── Datastructures/
│ │ │ ├── Geometry/
│ │ │ │ ├── Boundable.fs
│ │ │ │ ├── Bvh.fs
│ │ │ │ └── KdTree.fs
│ │ │ ├── Immutable/
│ │ │ │ ├── FingerTree.fs
│ │ │ │ ├── Graph.fs
│ │ │ │ ├── MapExt.fs
│ │ │ │ ├── RangeSet_auto.fs
│ │ │ │ ├── RangeSet_template.fs
│ │ │ │ └── SetDelta.fs
│ │ │ └── Mutable/
│ │ │ ├── AVL.fs
│ │ │ ├── ConcurrentHashQueue.fs
│ │ │ ├── FixedSizeArray.fs
│ │ │ ├── OrderMaintenance.fs
│ │ │ ├── OrderMaintenanceTrie.fs
│ │ │ ├── ReferenceCountingSet.fs
│ │ │ ├── SkipList.fs
│ │ │ └── StableSet.fs
│ │ ├── Math/
│ │ │ ├── AverageWindow.fs
│ │ │ ├── Converters.fs
│ │ │ ├── Math.fs
│ │ │ ├── Matrix.fs
│ │ │ ├── SVDM33f.fs
│ │ │ └── Vectors.fs
│ │ ├── Native/
│ │ │ ├── BlobStore.fs
│ │ │ ├── FileTable.fs
│ │ │ ├── Manager.fs
│ │ │ ├── Memory.fs
│ │ │ ├── Pointer.fs
│ │ │ └── Store.fs
│ │ ├── Reflection/
│ │ │ ├── Formatf.fs
│ │ │ ├── FunctionReflection.fs
│ │ │ ├── IL.fs
│ │ │ ├── Multimethod.fs
│ │ │ ├── Quotations.fs
│ │ │ ├── ReflectionExtensions.fs
│ │ │ ├── TypeBuilder.fs
│ │ │ ├── TypeInfo.fs
│ │ │ ├── TypeMeta_auto.fs
│ │ │ ├── TypeMeta_template.fs
│ │ │ └── UnmanagedFunctions.fs
│ │ ├── Runtime/
│ │ │ ├── Assembler.fs
│ │ │ ├── Caches.fs
│ │ │ ├── CustomSchedulers.fs
│ │ │ ├── DynamicLinker.fs
│ │ │ ├── Fragments.fs
│ │ │ ├── NativeMemory.fs
│ │ │ └── WeakTable.fs
│ │ ├── Utilities/
│ │ │ ├── IO.fs
│ │ │ ├── Interop/
│ │ │ │ ├── ArraySegment.fs
│ │ │ │ ├── CSharpList.fs
│ │ │ │ ├── Dictionary.fs
│ │ │ │ ├── FSLibExtensions.fs
│ │ │ │ ├── HashSet.fs
│ │ │ │ ├── SortedSet.fs
│ │ │ │ ├── String.fs
│ │ │ │ └── Symbol.fs
│ │ │ ├── Lens.fs
│ │ │ ├── Logging.fs
│ │ │ ├── Measures.fs
│ │ │ ├── Monads.fs
│ │ │ ├── Monoid.fs
│ │ │ ├── Native.fs
│ │ │ ├── Pickler/
│ │ │ │ ├── AdaptivePicklers.fs
│ │ │ │ └── FsPicklerExtensions.fs
│ │ │ ├── PrimitiveValueConverter.fs
│ │ │ ├── Threading.fs
│ │ │ └── Weak.fs
│ │ ├── __project.fsx
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Fonts/
│ │ ├── Aardvark.Base.Fonts.fsproj
│ │ ├── BvhInternal.fs
│ │ ├── Font.fs
│ │ ├── FontResolver.fs
│ │ ├── Path.fs
│ │ ├── PathSegment.fs
│ │ ├── PathTessellator.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.IO/
│ │ ├── Aardvark.Base.IO.csproj
│ │ ├── Annotations.cs
│ │ ├── BaseCoder.cs
│ │ ├── BinaryReadingCoder.cs
│ │ ├── BinaryReadingCoder_auto.cs
│ │ ├── BinaryReadingCoder_template.cs
│ │ ├── BinaryWritingCoder.cs
│ │ ├── BinaryWritingCoder_auto.cs
│ │ ├── BinaryWritingCoder_template.cs
│ │ ├── ChunkedMemoryStream.cs
│ │ ├── CodingExtensions.cs
│ │ ├── Converter.cs
│ │ ├── FastObjectFactory.cs
│ │ ├── FieldCoderExtensions.cs
│ │ ├── GzipUtils.cs
│ │ ├── IAwakeable.cs
│ │ ├── ICoder.cs
│ │ ├── ICoder_auto.cs
│ │ ├── ICoder_template.cs
│ │ ├── IFieldCodeable.cs
│ │ ├── ITypedMap.cs
│ │ ├── NetworkOrderBinaryReader.cs
│ │ ├── NetworkOrderBinaryWriter.cs
│ │ ├── RegisterTypeInfoAttribute.cs
│ │ ├── StreamCodeReader.cs
│ │ ├── StreamCodeReader_auto.cs
│ │ ├── StreamCodeReader_template.cs
│ │ ├── StreamCodeWriter.cs
│ │ ├── StreamCodeWriter_auto.cs
│ │ ├── StreamCodeWriter_template.cs
│ │ ├── StreamWriter2.cs
│ │ ├── SymMap.cs
│ │ ├── TypeCoder.cs
│ │ ├── TypeCoder_auto.cs
│ │ ├── TypeCoder_template.cs
│ │ ├── TypeExtensions.cs
│ │ ├── TypeInfo.cs
│ │ ├── TypeInfoVersion.cs
│ │ ├── UberStream.cs
│ │ ├── WorkDir.cs
│ │ ├── XmlParser.cs
│ │ ├── XmlReadingCoder.cs
│ │ ├── XmlReadingCoder_auto.cs
│ │ ├── XmlReadingCoder_template.cs
│ │ ├── XmlWritingCoder.cs
│ │ ├── XmlWritingCoder_auto.cs
│ │ ├── XmlWritingCoder_template.cs
│ │ ├── ZipFileContainer.cs
│ │ ├── ZipFileHeader.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Incremental/
│ │ ├── Aardvark.Base.Incremental.fsproj
│ │ ├── AdaptiveFunc/
│ │ │ └── AdaptiveFunc.fs
│ │ ├── AdaptiveStream/
│ │ │ ├── AdaptiveStream.fs
│ │ │ └── AdaptiveStreamCore.fs
│ │ ├── AgInterop.fs
│ │ ├── Builders.fs
│ │ ├── ChangeTracker.fs
│ │ ├── IncrementalBvh.fs
│ │ ├── Proc/
│ │ │ ├── Proc.fs
│ │ │ ├── ProcList.fs
│ │ │ └── ThreadPool.fs
│ │ ├── Scripts/
│ │ │ ├── load-project.fsx
│ │ │ └── load-references.fsx
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Runtime/
│ │ ├── Aardvark.Base.Runtime.fsproj
│ │ ├── Coder/
│ │ │ ├── Code.fs
│ │ │ ├── Core.fs
│ │ │ ├── State.fs
│ │ │ ├── Utilities.fs
│ │ │ └── ValueCoders.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Telemetry/
│ │ ├── Aardvark.Base.Telemetry.csproj
│ │ ├── Debug.cs
│ │ ├── Environment.cs
│ │ ├── HardwareThread.cs
│ │ ├── IProbe.cs
│ │ ├── Probes.cs
│ │ ├── Registry.cs
│ │ ├── TelemetryExtensions.cs
│ │ ├── TimingStats.cs
│ │ ├── Views.cs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Tensors/
│ │ ├── Aardvark.Base.Tensors.fsproj
│ │ ├── Algorithms/
│ │ │ ├── Generator.fsx
│ │ │ ├── QR.fs
│ │ │ ├── SVD.fs
│ │ │ └── Solver.fs
│ │ ├── Extensions/
│ │ │ ├── TensorMath.fs
│ │ │ ├── TensorSlicing.fs
│ │ │ ├── TensorUtilitiesGenerated.fs
│ │ │ └── TensorUtilitiesGenerator.fsx
│ │ ├── Native/
│ │ │ ├── NativeTensorExtensions.fs
│ │ │ ├── NativeTensorGenerated.fs
│ │ │ └── NativeTensorGenerator.fsx
│ │ ├── PixImage/
│ │ │ ├── ImageTrafo.fs
│ │ │ ├── PixCube.fs
│ │ │ └── PixImageErrorMetric.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.Base.Tensors.CSharp/
│ │ ├── Aardvark.Base.Tensors.CSharp.csproj
│ │ ├── Algorithms/
│ │ │ ├── LuFactorization.cs
│ │ │ └── QrFactorization.cs
│ │ ├── PixImage/
│ │ │ ├── EdgeFilter.cs
│ │ │ ├── IPix.cs
│ │ │ ├── ImageLoadException.cs
│ │ │ ├── PixCube.cs
│ │ │ ├── PixImage.cs
│ │ │ ├── PixImageCreators.cs
│ │ │ ├── PixImageExtensions.cs
│ │ │ ├── PixImageMipMap.cs
│ │ │ ├── PixLoader.cs
│ │ │ ├── PixProcessor.cs
│ │ │ └── PixVolume.cs
│ │ ├── Tensor.cs
│ │ ├── TensorExtensions.cs
│ │ ├── TensorExtensions_auto.cs
│ │ ├── TensorExtensions_template.cs
│ │ ├── TensorMathExt_auto.cs
│ │ ├── TensorMathExt_template.cs
│ │ ├── Tensor_auto.cs
│ │ ├── Tensor_template.cs
│ │ ├── Tensors/
│ │ │ ├── Accessors.cs
│ │ │ ├── Accessors_auto.cs
│ │ │ ├── Accessors_template.cs
│ │ │ ├── ArrayExtensions.cs
│ │ │ ├── FilterKernel.cs
│ │ │ ├── ImageBorder.cs
│ │ │ ├── ImageTensors.cs
│ │ │ ├── Interfaces.cs
│ │ │ ├── Parallel.cs
│ │ │ └── Tools.cs
│ │ ├── Utilities/
│ │ │ ├── Polygon2dExtensions.cs
│ │ │ └── SpectrumExtensions.cs
│ │ └── paket.references
│ ├── Aardvark.Geometry/
│ │ ├── Aardvark.Geometry.fsproj
│ │ ├── Bvh.fs
│ │ ├── EllipsoidRegression.fs
│ │ ├── LinearRegression.fs
│ │ ├── PolyRegion2d.fs
│ │ ├── Region3d.fs
│ │ ├── TexturePacking.fs
│ │ ├── paket.references
│ │ └── paket.template
│ ├── Aardvark.sln
│ ├── CodeGenerator/
│ │ ├── CodeGenerator.csproj
│ │ ├── CompilerServices.cs
│ │ ├── InternalsVisibleTo.cs
│ │ ├── Program.cs
│ │ ├── README.md
│ │ ├── TemplateProcessor.cs
│ │ ├── app.config
│ │ └── paket.references
│ ├── Demo/
│ │ ├── CoreTest/
│ │ │ ├── CoreTest.fsproj
│ │ │ ├── Program.fs
│ │ │ └── paket.references
│ │ ├── ExamplesCSharp/
│ │ │ ├── ExamplesCSharp.csproj
│ │ │ ├── Program.cs
│ │ │ └── paket.references
│ │ ├── IncrementalDemo.CSharp/
│ │ │ ├── IncrementalDemo.CSharp.csproj
│ │ │ ├── Program.cs
│ │ │ └── paket.references
│ │ ├── PixImageDemo/
│ │ │ ├── PixImageDemo.csproj
│ │ │ ├── Program.cs
│ │ │ └── paket.references
│ │ ├── RandomSampleDemo/
│ │ │ ├── Program.cs
│ │ │ ├── RandomSampleDemo.csproj
│ │ │ └── paket.references
│ │ ├── Scratch/
│ │ │ ├── Program.fs
│ │ │ ├── Scratch.fsproj
│ │ │ ├── Store.fs
│ │ │ └── paket.references
│ │ └── Sketch/
│ │ ├── App.config
│ │ ├── FingerTree.fsx
│ │ ├── FutureList.fsx
│ │ ├── Lazy.fsx
│ │ ├── Observable.fsx
│ │ ├── Program.fs
│ │ ├── Rampa.fsx
│ │ ├── Sketch.fsproj
│ │ ├── Sketch.sln
│ │ ├── UndoRedo.fsx
│ │ ├── Yampa.fsx
│ │ ├── adventure.txt
│ │ └── paket_.references
│ └── Tests/
│ ├── Aardvark.Base.Benchmarks/
│ │ ├── Aardvark.Base.Benchmarks.csproj
│ │ ├── CodeGenTest.cs
│ │ ├── ColorConversion.cs
│ │ ├── ConstantsBenchmark.cs
│ │ ├── Enumerators.cs
│ │ ├── Geometry/
│ │ │ ├── PolygonTransform.cs
│ │ │ ├── RayHitTest.cs
│ │ │ └── SolidAngle.cs
│ │ ├── HashCodeCombine.cs
│ │ ├── Hashes.cs
│ │ ├── Indexers_auto.cs
│ │ ├── Indexers_template.cs
│ │ ├── Lazy.cs
│ │ ├── Math/
│ │ │ ├── AngleBetween_auto.cs
│ │ │ ├── AngleBetween_template.cs
│ │ │ ├── DistanceRot3_auto.cs
│ │ │ ├── DistanceRot3_template.cs
│ │ │ ├── DistanceToLine.cs
│ │ │ ├── FractTest.cs
│ │ │ ├── IntegerPower_auto.cs
│ │ │ ├── IntegerPower_template.cs
│ │ │ ├── Log2Int.cs
│ │ │ ├── PowerOfTwo_auto.cs
│ │ │ ├── PowerOfTwo_template.cs
│ │ │ ├── Rot3GetEuler_auto.cs
│ │ │ ├── Rot3GetEuler_template.cs
│ │ │ ├── Rot3dTransform.cs
│ │ │ ├── RotateInto_auto.cs
│ │ │ ├── RotateInto_template.cs
│ │ │ ├── Tensors/
│ │ │ │ ├── MatrixMinor.cs
│ │ │ │ ├── MatrixMultiply.cs
│ │ │ │ ├── MatrixOrthogonalize_auto.cs
│ │ │ │ ├── MatrixOrthogonalize_template.cs
│ │ │ │ ├── MatrixSampling.cs
│ │ │ │ └── TensorMathBenchmark.cs
│ │ │ ├── Transform.cs
│ │ │ └── VectorLength.cs
│ │ ├── Program.cs
│ │ ├── StaticConstants.cs
│ │ ├── StreamWriterReader.cs
│ │ ├── TelemetryProbesBenchmark.cs
│ │ └── paket.references
│ ├── Aardvark.Base.FSharp.Benchmarks/
│ │ ├── Aardvark.Base.FSharp.Benchmarks.fsproj
│ │ ├── ActivePatterns.fs
│ │ ├── ArrayChooseBench.fs
│ │ ├── BvhIntersectBench.fs
│ │ ├── DynamicDispatchBench.fs
│ │ ├── NullCheckBench.fs
│ │ ├── Program.fs
│ │ ├── ReferenceCountingSetBench.fs
│ │ ├── TensorMathBench.fs
│ │ ├── TensorUtilitiesBench.fs
│ │ ├── Tuples_auto.fs
│ │ ├── Tuples_template.fs
│ │ ├── TypePatternsBench.fs
│ │ └── paket.references
│ ├── Aardvark.Base.FSharp.Tests/
│ │ ├── Aardvark.Base.FSharp.Tests.fsproj
│ │ ├── CachesTest.fs
│ │ ├── ControlTests.fs
│ │ ├── Datastructures/
│ │ │ ├── FSharpExtensionTests.fs
│ │ │ ├── MapExt.fs
│ │ │ ├── OrderMaintenanceTrie.fs
│ │ │ ├── RangeSetTests.fs
│ │ │ └── SortedSetExt.fs
│ │ ├── EnumTests.fs
│ │ ├── GeometryValueOptionTests.fs
│ │ ├── HMap.fs
│ │ ├── Math/
│ │ │ ├── MathTests.fs
│ │ │ ├── SVDTests.fs
│ │ │ └── TrafoTests.fs
│ │ ├── NativeMemory.fs
│ │ ├── NullCoalesceTests.fs
│ │ ├── PinnedValueTests.fs
│ │ ├── Program.fs
│ │ ├── PureAgTests.fs
│ │ ├── SizeOfTests.fs
│ │ ├── Tensors/
│ │ │ ├── PixTests.fs
│ │ │ ├── TensorMathTests.fs
│ │ │ └── TensorTests.fs
│ │ ├── TypeMetaTests.fs
│ │ └── paket.references
│ ├── Aardvark.Base.Fonts.Tests/
│ │ ├── Aardvark.Base.Fonts.Tests.fsproj
│ │ ├── Common.fs
│ │ ├── Loading.fs
│ │ ├── PathSegment.fs
│ │ ├── Program.fs
│ │ ├── paket.references
│ │ └── test.runsettings
│ ├── Aardvark.Base.Incremental.Tests/
│ │ ├── AListTests.fs
│ │ ├── AListTestsNew.fs
│ │ ├── AMapTests.fs
│ │ ├── ASetFoldTest.csv
│ │ ├── ASetPerformance.fs
│ │ ├── ASetPerformanceTests.fs
│ │ ├── ASetTests.fs
│ │ ├── Aardvark.Base.Incremental.Tests.fsproj
│ │ ├── AgTests.fs
│ │ ├── ModTests.fs
│ │ ├── Mutables.fs
│ │ ├── Performance.fs
│ │ ├── SizeOfVariousAdaptiveObjects.fs
│ │ ├── UndoRedo.fs
│ │ └── paket.references
│ ├── Aardvark.Base.Runtime.Tests/
│ │ ├── Aardvark.Base.Runtime.Tests.fsproj
│ │ ├── CoderTests.fs
│ │ ├── ReflectionTests.fs
│ │ └── paket.references
│ ├── Aardvark.Base.Tests/
│ │ ├── Aardvark.Base.Tests.csproj
│ │ ├── AlgoDat/
│ │ │ ├── DictTests.cs
│ │ │ ├── HigherOrderFunctionsTests.cs
│ │ │ └── SortingTests.cs
│ │ ├── CodeGenerator/
│ │ │ └── CodeGeneratorTests.cs
│ │ ├── Extensions/
│ │ │ ├── Arrays.cs
│ │ │ ├── DateTime.cs
│ │ │ ├── Enumerable.cs
│ │ │ ├── Hashes.cs
│ │ │ ├── ListHeapTests.cs
│ │ │ ├── Lists.cs
│ │ │ ├── StreamTests.cs
│ │ │ ├── Strings.cs
│ │ │ └── TaskWithCancellationTests.cs
│ │ ├── Geometry/
│ │ │ ├── Circle2dTests.cs
│ │ │ ├── Hull2dTests.cs
│ │ │ ├── Hull3dTests.cs
│ │ │ ├── IntersectionTestsTests.cs
│ │ │ ├── LineDistance.cs
│ │ │ ├── Plane3dTests.cs
│ │ │ └── PolygonClipping.cs
│ │ ├── IO/
│ │ │ └── UberStreamTests.cs
│ │ ├── Images/
│ │ │ ├── PixImageTests.cs
│ │ │ ├── PixSaveParamsTests.cs
│ │ │ ├── PixVolumeTests.cs
│ │ │ └── SystemDrawingTests.cs
│ │ ├── Json/
│ │ │ └── SystemTextJsonTests.cs
│ │ ├── Math/
│ │ │ ├── AliasTable.cs
│ │ │ ├── ColorTests.cs
│ │ │ ├── ComplexTests.cs
│ │ │ ├── Distributions.cs
│ │ │ ├── FunTests.cs
│ │ │ ├── HalfTests.cs
│ │ │ ├── PolynomialTests.cs
│ │ │ └── QuaternionTests.cs
│ │ ├── Plane/
│ │ │ └── PlaneTest.cs
│ │ ├── Program.cs
│ │ ├── Random/
│ │ │ ├── RandomIEnumerableExtensionsTests.cs
│ │ │ └── RandomSystemTests.cs
│ │ ├── RangesBoxes/
│ │ │ ├── BoxTests.cs
│ │ │ ├── Cell2dTests.cs
│ │ │ └── CellTests.cs
│ │ ├── Reporting/
│ │ │ └── ReportingTests.cs
│ │ ├── System/
│ │ │ └── EventSourceSlimTests.cs
│ │ ├── Telemetry/
│ │ │ └── TelemetryTests.cs
│ │ ├── Tensors/
│ │ │ └── TensorMatrixTests.cs
│ │ ├── TestSuite/
│ │ │ └── TestSuite.cs
│ │ ├── Trafos/
│ │ │ ├── AffineTests.cs
│ │ │ ├── EuclideanTests.cs
│ │ │ ├── MatrixTests.cs
│ │ │ ├── Rot2dTests.cs
│ │ │ ├── Rot3dTests.cs
│ │ │ ├── Scale3dTests.cs
│ │ │ ├── Shift3dTests.cs
│ │ │ ├── SimilarityTests.cs
│ │ │ ├── TrafoTesting.cs
│ │ │ └── TrafoTests.cs
│ │ ├── Vectors/
│ │ │ ├── V3fCoderTests.cs
│ │ │ └── VectorTests.cs
│ │ └── paket.references
│ └── Aardvark.Geometry.Tests/
│ ├── Aardvark.Geometry.Tests.fsproj
│ ├── PolyRegion2dTests.fs
│ ├── Program.fs
│ ├── Regression.fs
│ ├── TexturePacking.fs
│ └── paket.references
├── test.cmd
├── test.sh
└── tools/
├── DocsChecker/
│ ├── DocsAnalyzer.cs
│ ├── DocsChecker.csproj
│ ├── DocsRules.cs
│ ├── Program.cs
│ └── Properties/
│ └── AssemblyInfo.cs
└── DocsChecker.Tests/
├── DocsAnalyzerTests.cs
└── DocsChecker.Tests.csproj
Copy disabled (too large)
Download .txt
Showing preview only (11,953K chars total). Download the full file to get everything.
SYMBOL INDEX (54120 symbols across 502 files)
FILE: src/Aardvark.Base.Essentials/Camera/CameraProjectionOrtho.cs
class CameraProjectionOrtho (line 6) | public class CameraProjectionOrtho : ICameraProjection
method CameraProjectionOrtho (line 12) | public CameraProjectionOrtho(double left, double right, double bottom,...
method Unproject (line 21) | public Ray3d Unproject(V2d xyOnNearPlane)
method SetClippingParams (line 24) | public void SetClippingParams(double left, double right, double bottom...
method Zoom (line 95) | public void Zoom(V2d center, double factor)
method UpdateProjectionTrafo (line 105) | private void UpdateProjectionTrafo()
FILE: src/Aardvark.Base.Essentials/Camera/CameraProjectionPerspective.cs
class CameraProjectionPerspective (line 7) | public class CameraProjectionPerspective : ICameraProjectionPerspective
method CameraProjectionPerspective (line 13) | public CameraProjectionPerspective(double horizontalFovInDegrees, doub...
method CameraProjectionPerspective (line 18) | public CameraProjectionPerspective(double left, double right, double b...
method Unproject (line 27) | public Ray3d Unproject(V2d xyOnNearPlane)
method SetClippingParams (line 30) | public void SetClippingParams(double left, double right, double bottom...
method SetClippingParams (line 42) | public void SetClippingParams(double horizontalFovInDegrees, double ne...
method UpdateProjectionTrafo (line 120) | private void UpdateProjectionTrafo()
FILE: src/Aardvark.Base.Essentials/Camera/CameraViewRaw.cs
class CameraViewRaw (line 5) | public class CameraViewRaw : ICameraView
method CameraViewRaw (line 10) | public CameraViewRaw()
method Set (line 72) | public void Set(V3d location, V3d right, V3d up, V3d forward)
FILE: src/Aardvark.Base.Essentials/Camera/CameraViewWithSky.cs
class CameraViewWithSky (line 6) | public class CameraViewWithSky : ICameraView
method Set (line 117) | public void Set(V3d location, V3d right, V3d up, V3d forward)
FILE: src/Aardvark.Base.Essentials/Camera/ICameraProjection.cs
type ICameraProjection (line 5) | public interface ICameraProjection
method SetClippingParams (line 26) | void SetClippingParams(double left, double right, double bottom, doubl...
type ICameraProjectionPerspective (line 52) | public interface ICameraProjectionPerspective : ICameraProjection
FILE: src/Aardvark.Base.Essentials/Camera/ICameraProjectionExtensions.cs
class ICameraProjectionExtensions (line 6) | public static class ICameraProjectionExtensions
method Unproject (line 11) | public static Line3d Unproject(this ICameraProjection self, Ndc2d p)
method Unproject (line 20) | public static V3d Unproject(this ICameraProjection self, Ndc3d p)
method UnprojectPointOnNearPlane (line 26) | public static V3d UnprojectPointOnNearPlane(this ICameraProjection sel...
method UnprojectPointOnFarPlane (line 32) | public static V3d UnprojectPointOnFarPlane(this ICameraProjection self...
method TransformPos (line 38) | public static Ndc3d TransformPos(this ICameraProjection self, V3d posI...
method Zoom (line 44) | public static void Zoom(this ICameraProjection self, V2d center, doubl...
FILE: src/Aardvark.Base.Essentials/Camera/ICameraView.cs
type ICameraView (line 5) | public interface ICameraView
method Set (line 44) | void Set(V3d location, V3d right, V3d up, V3d forward);
FILE: src/Aardvark.Base.Essentials/Camera/ICameraViewExtensions.cs
class ICameraViewExtensions (line 8) | public static class ICameraViewExtensions
method LookAt (line 13) | public static void LookAt(this ICameraView self, V3d p)
FILE: src/Aardvark.Base.Essentials/Camera/IRenderView.cs
type IViewProjection (line 9) | public interface IViewProjection
type IRenderView (line 22) | public interface IRenderView: IViewProjection
FILE: src/Aardvark.Base.Essentials/Camera/IRenderViewExtensions.cs
class IRenderViewExtensions (line 9) | public static class IRenderViewExtensions
method Project (line 14) | public static Ndc3d Project(this IRenderView rv, V3d point)
method ProjectPixel (line 23) | public static PixelPosition ProjectPixel(this IRenderView rv, V3d point)
method PixelsPerUnitOnNearPlane (line 33) | public static V2d PixelsPerUnitOnNearPlane(this IRenderView rv)
method ViewProjTrafo (line 50) | public static Trafo3d ViewProjTrafo(this IViewProjection vp)
method GetVisualHull (line 58) | public static Hull3d GetVisualHull(this IViewProjection vp)
method CentralDirection (line 64) | public static V3d CentralDirection(this IViewProjection vp)
FILE: src/Aardvark.Base.Essentials/Editing/BehaviorDragAbsolute.cs
class BehaviorDragAbsolute (line 10) | public static class BehaviorDragAbsolute
method DragAbsolute (line 15) | public static async Task<IBehavior> DragAbsolute(this IBehavior self,
FILE: src/Aardvark.Base.Essentials/Editing/BehaviorDragRelative.cs
class BehaviorDragRelative (line 10) | public static class BehaviorDragRelative
method DragRelative (line 15) | public static async Task<IBehavior> DragRelative(this IBehavior self,
FILE: src/Aardvark.Base.Essentials/Editing/IBehavior.cs
type IBehavior (line 12) | public interface IBehavior
FILE: src/Aardvark.Base.Essentials/Editing/IBehaviorDeletable.cs
type IBehaviorDeletable (line 6) | public interface IBehaviorDeletable : IBehavior
method Delete (line 11) | void Delete();
FILE: src/Aardvark.Base.Essentials/Editing/IBehaviorPosition2d.cs
type IBehaviorPosition2d (line 6) | public interface IBehaviorPosition2d : IBehavior
FILE: src/Aardvark.Base.Essentials/Editing/IBehaviorSplittableEdge2d.cs
type IBehaviorSplittableEdge2d (line 6) | public interface IBehaviorSplittableEdge2d : IBehavior
method Split (line 11) | void Split(V2d splitPosition);
FILE: src/Aardvark.Base.Essentials/Editing/IBehaviorTransform2d.cs
type IBehaviorTransform2d (line 6) | public interface IBehaviorTransform2d : IBehavior
method Transform (line 11) | void Transform(M33d trafo);
FILE: src/Aardvark.Base.Essentials/Editing/IEditableEdge2d.cs
type IEditableEdge2d (line 6) | public interface IEditableEdge2d :
FILE: src/Aardvark.Base.Essentials/Editing/IEditableFace2d.cs
type IEditableFace2d (line 6) | public interface IEditableFace2d :
method GetEditableVertex (line 14) | IEditableVertex2d GetEditableVertex(int index);
method GetEditableEdge (line 19) | IEditableEdge2d GetEditableEdge(int index);
FILE: src/Aardvark.Base.Essentials/Editing/IEditableSequence.cs
type IEditableSequence (line 6) | public interface IEditableSequence<T>
FILE: src/Aardvark.Base.Essentials/Editing/IEditableVertex2d.cs
type IEditableVertex2d (line 6) | public interface IEditableVertex2d :
FILE: src/Aardvark.Base.Essentials/NormalizedDeviceCoordinates.cs
type Ndc2d (line 9) | public readonly struct Ndc2d
method Ndc2d (line 19) | public Ndc2d(V2d position)
method Ndc2d (line 27) | public Ndc2d(double x, double y)
method Ndc2d (line 35) | public Ndc2d(PixelPosition p)
type Ndc3d (line 60) | public readonly struct Ndc3d
method Ndc3d (line 70) | public Ndc3d(V3d position)
method Ndc3d (line 78) | public Ndc3d(double x, double y, double z)
FILE: src/Aardvark.Base.Essentials/PixelPosition.cs
type PixelPosition (line 14) | public readonly struct PixelPosition
method PixelPosition (line 33) | public PixelPosition(V2i position, Box2i bounds)
method PixelPosition (line 43) | public PixelPosition(V2i position, int width, int height)
method PixelPosition (line 53) | public PixelPosition(int x, int y, int width, int height)
method PixelPosition (line 62) | public PixelPosition(Ndc2d ndc, V2i renderTargetSize)
method PixelPosition (line 70) | public PixelPosition(Ndc2d ndc, Box2i renderTargetRegion)
method PixelPosition (line 79) | public PixelPosition(Ndc3d ndc, V2i renderTargetSize)
method PixelPosition (line 87) | public PixelPosition(Ndc3d ndc, Box2i renderTargetRegion)
FILE: src/Aardvark.Base.Essentials/Screenshot.cs
class HttpServer2Route (line 17) | public class HttpServer2Route
type Mode (line 19) | private enum Mode
method Matches (line 35) | public bool Matches(string s, Dictionary<string, string> variables)
method HttpServer2Route (line 73) | public HttpServer2Route(string route, Http.Verb verb, Action<HttpServe...
class HttpServer2Dispatcher (line 105) | public class HttpServer2Dispatcher
method AddRoutes (line 109) | public void AddRoutes(params HttpServer2Route[] routes)
method AddRoutes (line 113) | public void AddRoutes(IEnumerable<HttpServer2Route> routes)
method AddRoute (line 117) | public void AddRoute(HttpServer2Route route)
method HttpServer2Dispatcher (line 122) | public HttpServer2Dispatcher() { }
method HttpServer2Dispatcher (line 123) | public HttpServer2Dispatcher(params HttpServer2Route[] routes)
method HttpServer2Dispatcher (line 127) | public HttpServer2Dispatcher(IEnumerable<HttpServer2Route> routes)
method Dispatch (line 132) | public HttpServer2Route Dispatch(string uri, Http.Verb verb, Dictionar...
class HttpServerRequestInfo (line 141) | public class HttpServerRequestInfo
method Get (line 174) | public string Get(string paramName, string defaultValue)
method Get (line 178) | public int Get(string paramName, int defaultValue)
method Get (line 189) | public double Get(string paramName, double defaultValue)
class HttpServerDispatcher (line 202) | public class HttpServerDispatcher
method Register (line 209) | public void Register(Func<HttpServerRequestInfo, bool> handler)
method Register (line 213) | public void Register(string prefix, Func<HttpServerRequestInfo, bool> ...
method Register (line 223) | public void Register(Http.Verb verb, Func<HttpServerRequestInfo, bool>...
method Register (line 227) | public void Register(string prefix, Http.Verb verb, Func<HttpServerReq...
method Register (line 234) | public void Register(HttpServerDispatcher dispatcher)
method Register (line 238) | public void Register(string prefix, HttpServerDispatcher dispatcher)
method Dispatch (line 262) | internal bool Dispatch(HttpServerRequestInfo info)
method HttpServerDispatcher (line 329) | public HttpServerDispatcher()
method DefaultHelpHandler (line 334) | private bool DefaultHelpHandler(HttpServerRequestInfo info)
class Http (line 352) | public static class Http
type Verb (line 354) | public enum Verb
method Get (line 362) | public static WebResponse Get(string uri, Dictionary<string, object> q...
method Get (line 367) | public static WebResponse Get(string uri)
method Post (line 372) | public static WebResponse Post(
method Post (line 379) | public static WebResponse Post(
method Post (line 386) | public static WebResponse Post(
method Post (line 392) | public static WebResponse Post(
method Delete (line 398) | public static WebResponse Delete(string uri)
method Put (line 403) | public static WebResponse Put(string uri)
method Send (line 421) | public static WebResponse Send(
class HttpServer (line 450) | public class HttpServer
method SwitchToNewStyle (line 461) | public void SwitchToNewStyle()
method Stop (line 494) | public void Stop()
method Start (line 502) | public void Start()
method ReportRequestProperties (line 669) | private void ReportRequestProperties(HttpListenerRequest request)
class WebReponseExtensions (line 719) | public static class WebReponseExtensions
method GetResponseAsString (line 721) | public static string GetResponseAsString(this WebResponse response)
method GetResponseAsBytes (line 726) | public static byte[] GetResponseAsBytes(this WebResponse response)
class HttpListenerContextExtensions (line 734) | public static class HttpListenerContextExtensions
method SendReply (line 736) | public static void SendReply(this HttpListenerContext context)
method SendReply (line 741) | public static void SendReply(this HttpListenerContext context, string ...
method SendReply (line 746) | public static void SendReply(this HttpListenerContext context,
method SendReply (line 760) | public static void SendReply(this HttpListenerContext context, byte[] ...
method SendReply (line 765) | public static void SendReply(this HttpListenerContext context,
class Screenshot (line 777) | public static class Screenshot
method CreateImageDesktopFilename (line 779) | public static string CreateImageDesktopFilename()
method CreateScreenShotFilePath (line 791) | public static string CreateScreenShotFilePath(string path)
method SaveToDesktop (line 806) | public static void SaveToDesktop(PixImage image)
method SaveToFileInPath (line 811) | public static void SaveToFileInPath(PixImage image, string path)
method SaveToFile (line 819) | public static void SaveToFile(PixImage image, string fileName)
method UploadImageDataToServer (line 825) | public static string UploadImageDataToServer(MemoryStream stream, stri...
method UploadImageToServer (line 861) | public static string UploadImageToServer(PixImage image, string tags =...
method UploadMetaInfoToServer (line 887) | public static void UploadMetaInfoToServer(XElement metaInfo)
method BuildCompleteMetaInfo (line 909) | private static XElement BuildCompleteMetaInfo(XElement metaDataFromFor...
method SaveAndUpload (line 942) | public static void SaveAndUpload(PixImage image, bool uploadToServer, ...
FILE: src/Aardvark.Base.Essentials/System/Awaitable.cs
class Awaitable (line 15) | public class Awaitable : IAwaitable, IEventEmitter<Unit>
method Awaitable (line 30) | public Awaitable(CancellationToken? ct = null)
method Emit (line 65) | public void Emit()
method Emit (line 100) | public void Emit(Unit value)
method Subscribe (line 107) | public void Subscribe(Action continuation)
method GetAwaiter (line 135) | public IAwaiter GetAwaiter()
type Awaiter (line 142) | private readonly struct Awaiter : IAwaiter
method Awaiter (line 148) | public Awaiter(Awaitable source)
method GetResult (line 162) | public void GetResult()
method OnCompleted (line 169) | public void OnCompleted(Action continuation)
method Awaiter (line 386) | public Awaiter(Awaitable<T> source)
method GetResult (line 400) | public T GetResult()
method OnCompleted (line 409) | public void OnCompleted(Action continuation)
method GetResult (line 414) | void IAwaiter.GetResult()
method Awaitable (line 203) | public Awaitable(CancellationToken? ct = null)
method Emit (line 261) | public void Emit(T value)
method Subscribe (line 305) | public void Subscribe(Action continuation)
method Subscribe (line 329) | public void Subscribe(Action<T> continuation)
method GetAwaiter (line 357) | public IAwaiter<T> GetAwaiter()
method GetAwaiter (line 362) | IAwaiter IAwaitable.GetAwaiter()
method Emit (line 373) | public void Emit()
type Awaiter (line 380) | private readonly struct Awaiter : IAwaiter<T>
method Awaiter (line 148) | public Awaiter(Awaitable source)
method GetResult (line 162) | public void GetResult()
method OnCompleted (line 169) | public void OnCompleted(Action continuation)
method Awaiter (line 386) | public Awaiter(Awaitable<T> source)
method GetResult (line 400) | public T GetResult()
method OnCompleted (line 409) | public void OnCompleted(Action continuation)
method GetResult (line 414) | void IAwaiter.GetResult()
class Awaitable (line 185) | public class Awaitable<T> : IAwaitable<T>, IEventEmitter<T>
method Awaitable (line 30) | public Awaitable(CancellationToken? ct = null)
method Emit (line 65) | public void Emit()
method Emit (line 100) | public void Emit(Unit value)
method Subscribe (line 107) | public void Subscribe(Action continuation)
method GetAwaiter (line 135) | public IAwaiter GetAwaiter()
type Awaiter (line 142) | private readonly struct Awaiter : IAwaiter
method Awaiter (line 148) | public Awaiter(Awaitable source)
method GetResult (line 162) | public void GetResult()
method OnCompleted (line 169) | public void OnCompleted(Action continuation)
method Awaiter (line 386) | public Awaiter(Awaitable<T> source)
method GetResult (line 400) | public T GetResult()
method OnCompleted (line 409) | public void OnCompleted(Action continuation)
method GetResult (line 414) | void IAwaiter.GetResult()
method Awaitable (line 203) | public Awaitable(CancellationToken? ct = null)
method Emit (line 261) | public void Emit(T value)
method Subscribe (line 305) | public void Subscribe(Action continuation)
method Subscribe (line 329) | public void Subscribe(Action<T> continuation)
method GetAwaiter (line 357) | public IAwaiter<T> GetAwaiter()
method GetAwaiter (line 362) | IAwaiter IAwaitable.GetAwaiter()
method Emit (line 373) | public void Emit()
type Awaiter (line 380) | private readonly struct Awaiter : IAwaiter<T>
method Awaiter (line 148) | public Awaiter(Awaitable source)
method GetResult (line 162) | public void GetResult()
method OnCompleted (line 169) | public void OnCompleted(Action continuation)
method Awaiter (line 386) | public Awaiter(Awaitable<T> source)
method GetResult (line 400) | public T GetResult()
method OnCompleted (line 409) | public void OnCompleted(Action continuation)
method GetResult (line 414) | void IAwaiter.GetResult()
class Await (line 427) | public static class Await
method WithCancellation (line 439) | public static IAwaitable<T> WithCancellation<T>(this IAwaitable<T> inp...
method WithCancellation (line 450) | public static IAwaitable WithCancellation(this IAwaitable input, Cance...
method WhenAny (line 464) | public static IAwaitable<IAwaitable> WhenAny(params IAwaitable[] inputs)
method WhenAny (line 482) | public static IAwaitable<IAwaitable<T>> WhenAny<T>(params IAwaitable<T...
method WhenAll (line 504) | public static IAwaitable<T[]> WhenAll<T>(params IAwaitable<T>[] inputs)
method WhenAll (line 533) | public static IAwaitable WhenAll(params IAwaitable[] inputs)
method Select (line 560) | public static IAwaitable<TResult> Select<TInput, TResult>(this IAwaita...
method Select (line 570) | public static IAwaitable<TResult> Select<TResult>(this IAwaitable inpu...
method ContinueWith (line 584) | public static IAwaitable<TResult> ContinueWith<T, TResult>(this IAwait...
method ContinueWith (line 599) | public static IAwaitable ContinueWith<T>(this IAwaitable<T> awaitable,...
method ContinueWith (line 615) | public static IAwaitable<TResult> ContinueWith<TResult>(this IAwaitabl...
method ContinueWith (line 630) | public static IAwaitable ContinueWith<TResult>(this IAwaitable awaitab...
method Delay (line 650) | public static IAwaitable<TimeValue> Delay(uint milliseconds, Cancellat...
method Delay (line 658) | public static IAwaitable<TimeValue> Delay(uint milliseconds)
method Delay (line 666) | public static IAwaitable<TimeValue> Delay(TimeSpan delay, Cancellation...
method Delay (line 674) | public static IAwaitable<TimeValue> Delay(TimeSpan delay)
class AwaitableTest (line 692) | public static class AwaitableTest
method Run (line 694) | static async void Run(Awaitable<int> a, Awaitable<int> b, Cancellation...
method Run (line 709) | public static void Run()
class TaskAwaiter (line 730) | public class TaskAwaiter<T> : IAwaiter<T>
method TaskAwaiter (line 736) | public TaskAwaiter(System.Runtime.CompilerServices.TaskAwaiter<T> awai...
method OnCompleted (line 743) | public void OnCompleted(Action continuation)
method GetResult (line 757) | public T GetResult()
method GetResult (line 764) | void IAwaiter.GetResult()
method TaskAwaiter (line 778) | public TaskAwaiter(System.Runtime.CompilerServices.TaskAwaiter awaiter)
method OnCompleted (line 785) | public void OnCompleted(Action continuation)
method GetResult (line 797) | void IAwaiter.GetResult()
class TaskAwaiter (line 772) | public class TaskAwaiter : IAwaiter
method TaskAwaiter (line 736) | public TaskAwaiter(System.Runtime.CompilerServices.TaskAwaiter<T> awai...
method OnCompleted (line 743) | public void OnCompleted(Action continuation)
method GetResult (line 757) | public T GetResult()
method GetResult (line 764) | void IAwaiter.GetResult()
method TaskAwaiter (line 778) | public TaskAwaiter(System.Runtime.CompilerServices.TaskAwaiter awaiter)
method OnCompleted (line 785) | public void OnCompleted(Action continuation)
method GetResult (line 797) | void IAwaiter.GetResult()
class TaskAwaitable (line 805) | public class TaskAwaitable<T> : IAwaitable<T>
method TaskAwaitable (line 811) | public TaskAwaitable(Task<T> task) { m_task = task; }
method GetAwaiter (line 815) | public IAwaiter<T> GetAwaiter()
method GetAwaiter (line 829) | IAwaiter IAwaitable.GetAwaiter()
method TaskAwaitable (line 850) | public TaskAwaitable(Task task) { m_task = task; }
method GetAwaiter (line 854) | public IAwaiter GetAwaiter()
class TaskAwaitable (line 844) | public class TaskAwaitable : IAwaitable
method TaskAwaitable (line 811) | public TaskAwaitable(Task<T> task) { m_task = task; }
method GetAwaiter (line 815) | public IAwaiter<T> GetAwaiter()
method GetAwaiter (line 829) | IAwaiter IAwaitable.GetAwaiter()
method TaskAwaitable (line 850) | public TaskAwaitable(Task task) { m_task = task; }
method GetAwaiter (line 854) | public IAwaiter GetAwaiter()
class TaskAwaitableExtensions (line 867) | public static class TaskAwaitableExtensions
method AsAwaitable (line 871) | public static TaskAwaitable AsAwaitable(this Task task)
method AsAwaitable (line 878) | public static TaskAwaitable<T> AsAwaitable<T>(this Task<T> task)
FILE: src/Aardvark.Base.Essentials/System/Clock.cs
class Clock (line 11) | public class Clock : IDisposable
method Clock (line 26) | public Clock(int maxUpdateFrequency = 0)
method GetTimeSpanForContinuation (line 70) | public TimeSpan GetTimeSpanForContinuation(Action continuation, out Da...
method Enqueue (line 92) | public void Enqueue(Action a)
method Run (line 101) | private void Run()
method Dispose (line 154) | public void Dispose()
class ClockExtensions (line 177) | public static class ClockExtensions
type FutureAwaiter (line 185) | private struct FutureAwaiter : IAwaiter<TimeValue>
method FutureAwaiter (line 190) | public FutureAwaiter(FutureAwaitable f)
method MakeSane (line 201) | private void MakeSane(ref TimeSpan span)
method GetResult (line 215) | public TimeValue GetResult()
method OnCompleted (line 226) | public void OnCompleted(Action continuation)
method GetResult (line 247) | void IAwaiter.GetResult()
class FutureAwaitable (line 254) | private class FutureAwaitable : IAwaitable<TimeValue>
method FutureAwaitable (line 259) | public FutureAwaitable(Clock time, int timeout = 0)
method GetAwaiter (line 275) | public IAwaiter<TimeValue> GetAwaiter()
method GetAwaiter (line 280) | IAwaiter IAwaitable.GetAwaiter()
method Future (line 304) | public static IAwaitable<TimeValue> Future(this Clock clock, int timeo...
method Tick (line 311) | public static IAwaitable<TimeValue> Tick(this Clock clock)
method TickEvent (line 318) | public static IEvent<double> TickEvent(this Clock clock)
FILE: src/Aardvark.Base.Essentials/System/Disposable.cs
class IDisposableExtensions (line 8) | public static class IDisposableExtensions
method TryDispose (line 14) | public static bool TryDispose(this IDisposable self)
method TryDispose (line 25) | public static bool TryDispose(this object obj)
method DisposeAll (line 36) | public static void DisposeAll(this IEnumerable<IDisposable> disposables)
method DisposeAll (line 44) | public static void DisposeAll(this List<IDisposable> disposables)
method DisposeAll (line 52) | public static void DisposeAll(this IDisposable[] disposables)
method TryDisposeAll (line 60) | public static void TryDisposeAll(this IEnumerable<IDisposable> disposa...
method DisposeAllAndClear (line 68) | public static void DisposeAllAndClear(this ICollection<IDisposable> di...
method DisposeAllAndClear (line 78) | public static void DisposeAllAndClear(this List<IDisposable> disposables)
class Try (line 88) | public static class Try
method Dispose (line 94) | public static void Dispose<T>(ref T x) where T : IDisposable
FILE: src/Aardvark.Base.Essentials/System/EventSource.cs
class EventSourceSlim (line 6) | public class EventSourceSlim<T> : IEvent<T>
method EventSourceSlim (line 12) | public EventSourceSlim(T defaultValue)
method Emit (line 19) | public void Emit(T v)
class EventSource (line 80) | public static class EventSource
method Create (line 90) | public static EventSource<T> Create<T>(T initialValue)
method Create (line 98) | public static EventSource<Tuple<T0, T1>> Create<T0, T1>(T0 initialValu...
method Create (line 106) | public static EventSource<Tuple<T0, T1, T2>> Create<T0, T1, T2>(T0 ini...
method Create (line 114) | public static EventSource<Tuple<T0, T1, T2, T3>> Create<T0, T1, T2, T3...
method Create (line 122) | public static EventSource<Tuple<T0, T1, T2, T3, T4>> Create<T0, T1, T2...
method EventSource (line 141) | public EventSource()
method EventSource (line 149) | public EventSource(T initialValue)
method EventSource (line 158) | public EventSource(IObservable<T> fromObservable)
method EventSource (line 167) | public EventSource(T initialValue, IObservable<T> fromObservable)
method Emit (line 245) | public virtual void Emit(T value)
method Emit (line 301) | public void Emit()
class EventSource (line 130) | public class EventSource<T> : IEvent<T>, IEventEmitter<T>
method Create (line 90) | public static EventSource<T> Create<T>(T initialValue)
method Create (line 98) | public static EventSource<Tuple<T0, T1>> Create<T0, T1>(T0 initialValu...
method Create (line 106) | public static EventSource<Tuple<T0, T1, T2>> Create<T0, T1, T2>(T0 ini...
method Create (line 114) | public static EventSource<Tuple<T0, T1, T2, T3>> Create<T0, T1, T2, T3...
method Create (line 122) | public static EventSource<Tuple<T0, T1, T2, T3, T4>> Create<T0, T1, T2...
method EventSource (line 141) | public EventSource()
method EventSource (line 149) | public EventSource(T initialValue)
method EventSource (line 158) | public EventSource(IObservable<T> fromObservable)
method EventSource (line 167) | public EventSource(T initialValue, IObservable<T> fromObservable)
method Emit (line 245) | public virtual void Emit(T value)
method Emit (line 301) | public void Emit()
class EventSourceTelemetry (line 309) | internal static class EventSourceTelemetry
FILE: src/Aardvark.Base.Essentials/System/EventSourceExtensions.cs
class EventSourceExtensions (line 8) | public static class EventSourceExtensions
method ToEventSource (line 13) | public static EventSource<T> ToEventSource<T>(this IObservable<T> self)
method ExecuteOnNextValue (line 21) | public static void ExecuteOnNextValue<T>(this IEvent<T> self, Action<T...
method ExecuteOnNextValue (line 29) | public static void ExecuteOnNextValue<T>(this IEvent<T> self, Action a...
method RepeatUntilNext (line 38) | public static async Task RepeatUntilNext<T>(this IEvent<T> self, Func<...
method RepeatUntilNext (line 54) | public static async Task RepeatUntilNext<T>(this Task<T> self, Func<Ta...
method RepeatUntilNext (line 69) | public static async Task RepeatUntilNext<T>(this IEvent<T> self, Func<...
method RepeatUntilNext (line 85) | public static async Task RepeatUntilNext<T>(this Task<T> self, Func<Ta...
method RepeatUntilCompleted (line 100) | public static async Task RepeatUntilCompleted<T>(this IAwaitable<T> se...
method RepeatUntilCompleted (line 115) | public static async Task RepeatUntilCompleted<T>(this Task<T> self, Fu...
method RepeatUntilCompleted (line 130) | public static async Task RepeatUntilCompleted<T>(this IAwaitable<T> se...
method RepeatUntilCompleted (line 145) | public static async Task RepeatUntilCompleted<T>(this Task<T> self, Fu...
method RepeatUntilCompleted (line 159) | public static async Task RepeatUntilCompleted(this IAwaitable self, Fu...
method RepeatUntilCompleted (line 173) | public static async Task RepeatUntilCompleted(this Task self, Func<Tas...
method RepeatUntilCompleted (line 187) | public static async Task RepeatUntilCompleted(this IAwaitable self, Fu...
method RepeatUntilCompleted (line 201) | public static async Task RepeatUntilCompleted(this Task self, Func<Tas...
FILE: src/Aardvark.Base.Essentials/System/EventSourceInterfaces.cs
type IEvent (line 8) | public interface IEvent<T> : IEvent
type IEventEmitter (line 30) | public interface IEventEmitter<T> : IEventEmitter
method Emit (line 35) | void Emit(T value);
method Emit (line 62) | void Emit();
type IEvent (line 41) | public interface IEvent
type IEventEmitter (line 57) | public interface IEventEmitter
method Emit (line 35) | void Emit(T value);
method Emit (line 62) | void Emit();
FILE: src/Aardvark.Base.Essentials/System/EventSourceSpecials.cs
class ConstEventSource (line 7) | public class ConstEventSource
method Create (line 12) | public static ConstEventSource<T> Create<T>(T value)
method Create (line 20) | public static ConstEventSource<Tuple<T0, T1>> Create<T0, T1>(T0 initia...
method Create (line 28) | public static ConstEventSource<Tuple<T0, T1, T2>> Create<T0, T1, T2>(T...
method Create (line 36) | public static ConstEventSource<Tuple<T0, T1, T2, T3>> Create<T0, T1, T...
method Create (line 44) | public static ConstEventSource<Tuple<T0, T1, T2, T3, T4>> Create<T0, T...
method ConstEventSource (line 61) | public ConstEventSource(T constValue)
class ConstEventSource (line 53) | public class ConstEventSource<T> : IEvent<T>
method Create (line 12) | public static ConstEventSource<T> Create<T>(T value)
method Create (line 20) | public static ConstEventSource<Tuple<T0, T1>> Create<T0, T1>(T0 initia...
method Create (line 28) | public static ConstEventSource<Tuple<T0, T1, T2>> Create<T0, T1, T2>(T...
method Create (line 36) | public static ConstEventSource<Tuple<T0, T1, T2, T3>> Create<T0, T1, T...
method Create (line 44) | public static ConstEventSource<Tuple<T0, T1, T2, T3, T4>> Create<T0, T...
method ConstEventSource (line 61) | public ConstEventSource(T constValue)
FILE: src/Aardvark.Base.Essentials/System/FilteredEventSource.cs
class FilteredEventSource (line 7) | public class FilteredEventSource<T> : EventSource<T>
method FilteredEventSource (line 13) | public FilteredEventSource(Func<T, bool> predicate)
method Emit (line 21) | public override void Emit(T value)
FILE: src/Aardvark.Base.Essentials/System/IAwaitable.cs
type IAwaitable (line 39) | public interface IAwaitable
method GetAwaiter (line 43) | IAwaiter GetAwaiter();
method GetAwaiter (line 75) | new IAwaiter<T> GetAwaiter();
type IAwaiter (line 52) | public interface IAwaiter : INotifyCompletion
method GetResult (line 63) | void GetResult();
method GetResult (line 90) | new T GetResult();
type IAwaitable (line 71) | public interface IAwaitable<T> : IAwaitable
method GetAwaiter (line 43) | IAwaiter GetAwaiter();
method GetAwaiter (line 75) | new IAwaiter<T> GetAwaiter();
type IAwaiter (line 84) | public interface IAwaiter<T> : INotifyCompletion, IAwaiter
method GetResult (line 63) | void GetResult();
method GetResult (line 90) | new T GetResult();
class IAwaitableExtensions (line 95) | public static class IAwaitableExtensions
method Subscribe (line 99) | public static void Subscribe<T>(this IAwaitable<T> awaitable, Action<T...
method Subscribe (line 107) | public static void Subscribe(this IAwaitable awaitable, Action action)
FILE: src/Aardvark.Base.Essentials/System/Reactive.cs
class Unit (line 7) | public sealed class Unit
method Unit (line 9) | private Unit() { }
class SubjectDisposable (line 14) | internal class SubjectDisposable<T> : IDisposable
method SubjectDisposable (line 19) | public SubjectDisposable(Dictionary<IObserver<T>, int> store, IObserve...
method Dispose (line 25) | public void Dispose()
class Subject (line 45) | internal class Subject<T> : IObservable<T>, IObserver<T>
method Subject (line 49) | public Subject()
method OnCompleted (line 54) | public void OnCompleted()
method OnNext (line 67) | public void OnNext(T value)
method OnError (line 80) | public void OnError(Exception e)
method Subscribe (line 93) | public IDisposable Subscribe(IObserver<T> obs)
class LambdaObserver (line 112) | internal class LambdaObserver<T> : IObserver<T>
method LambdaObserver (line 116) | public LambdaObserver(Action<T> action)
method OnNext (line 121) | public void OnNext(T value)
method OnCompleted (line 126) | public void OnCompleted()
method OnError (line 129) | public void OnError(Exception e)
class MapObserver (line 133) | internal class MapObserver<T1, T2> : IObserver<T1>
method MapObserver (line 138) | public MapObserver(IObserver<T2> target, Func<T1, T2> mapping)
method OnNext (line 144) | public void OnNext(T1 value)
method OnCompleted (line 148) | public void OnCompleted()
method OnError (line 152) | public void OnError(Exception error)
class MapObservable (line 158) | internal class MapObservable<T1, T2> : IObservable<T2>
method MapObservable (line 163) | public MapObservable(IObservable<T1> input, Func<T1, T2> mapping)
method Subscribe (line 169) | public IDisposable Subscribe(IObserver<T2> obs)
class NoDisposable (line 176) | internal class NoDisposable : IDisposable
method NoDisposable (line 178) | public NoDisposable() { }
method Dispose (line 179) | public void Dispose()
class NeverObservable (line 182) | internal class NeverObservable<T> : IObservable<T>
method NeverObservable (line 184) | public NeverObservable()
method Subscribe (line 188) | public IDisposable Subscribe(IObserver<T> observer)
FILE: src/Aardvark.Base.Essentials/System/Time.cs
type TimeValue (line 7) | public readonly struct TimeValue
method TimeValue (line 21) | public TimeValue(DateTime t, double delta)
FILE: src/Aardvark.Base.Essentials/System/WithCancellationExtension.cs
class TaskWithCancellationExtensions (line 12) | public static class TaskWithCancellationExtensions
method WithCancellation (line 18) | public static Task<T> WithCancellation<T>(this Task<T> task, Cancellat...
method WithCancellation (line 32) | public static Task<T> WithCancellation<T>(this Task<T> task, Cancellat...
method WithCancellationInternal (line 46) | private static async Task<T> WithCancellationInternal<T>(this Task<T> ...
FILE: src/Aardvark.Base.IO/Annotations.cs
class AnnotatedExtensions (line 6) | internal static class AnnotatedExtensions
method Annotate (line 8) | public static Annotated<T> Annotate<T>(this T self)
method Annotate (line 12) | public static Annotated<T> Annotate<T>(this T self, string key, object...
method Annotate (line 16) | public static Annotated<T> Annotate<T>(this T self, IEnumerable<Annota...
method Annotate (line 20) | public static Annotated<T> Annotate<T>(this Annotated<T> self, string ...
method Annotate (line 24) | public static Annotated<T> Annotate<T>(this Annotated<T> self, IEnumer...
type Annotation (line 30) | internal struct Annotation
method ToString (line 34) | public override readonly string ToString() { return string.Format("{0}...
method Annotation (line 36) | public Annotation(string key, object value)
type Annotated (line 44) | internal readonly struct Annotated<T>
method Annotated (line 50) | public Annotated(T value)
method Annotated (line 55) | public Annotated(T value, string tagKey, object tagValue)
method Annotated (line 60) | public Annotated(T value, IEnumerable<Annotation> tags)
method Annotated (line 65) | public Annotated(Annotated<T> a)
method Annotated (line 70) | public Annotated(Annotated<T> a, string tagKey, object tagValue)
method Annotated (line 75) | public Annotated(Annotated<T> a, IEnumerable<Annotation> tags)
FILE: src/Aardvark.Base.IO/BaseCoder.cs
type CoderDebugMode (line 8) | [Flags]
class BaseCoder (line 22) | public class BaseCoder
method BaseCoder (line 37) | public BaseCoder()
method InitTypeInfos (line 51) | private static void InitTypeInfos()
class BaseReadingCoder (line 112) | public class BaseReadingCoder : BaseCoder
method BaseReadingCoder (line 120) | public BaseReadingCoder() : base()
method Add (line 139) | public void Add(TypeInfo[] tia)
method Del (line 155) | public void Del(TypeInfo[] tia)
class BaseWritingCoder (line 178) | public class BaseWritingCoder : BaseCoder
method BaseWritingCoder (line 186) | public BaseWritingCoder() : base()
method TryGetTypeInfo (line 205) | internal bool TryGetTypeInfo(Type type, out TypeInfo ti)
method Add (line 211) | public void Add(TypeInfo[] tia)
method Del (line 227) | public void Del(TypeInfo[] tia)
FILE: src/Aardvark.Base.IO/BinaryReadingCoder.cs
class BinaryReadingCoder (line 13) | public partial class BinaryReadingCoder
method BinaryReadingCoder (line 23) | public BinaryReadingCoder(Stream stream) : base()
method BinaryReadingCoder (line 42) | public BinaryReadingCoder(string fileName)
method ReadFirstObject (line 53) | public static object ReadFirstObject(string fileName)
method ReadFirstObject (line 61) | public static object ReadFirstObject(Stream stream)
method ReadFirst (line 69) | public static T ReadFirst<T>(string fileName)
method ReadFirst (line 77) | public static T ReadFirst<T>(Stream stream)
method TryGetTypeInfo (line 101) | internal bool TryGetTypeInfo(string name, out TypeInfo ti)
method AddRef (line 108) | private int AddRef(object obj)
method UseRef (line 119) | private object UseRef(int refNum)
method UseRef (line 129) | private object UseRef(Guid guid)
method Code (line 137) | public void Code(ref object obj)
method CodeFields (line 307) | public void CodeFields(Type type, int version, IFieldCodeable obj)
method CodeFields (line 326) | public void CodeFields(Type type, ITypedMap obj)
method CodeT (line 353) | public void CodeT<T>(ref T obj)
method ReferenceObject (line 364) | public object ReferenceObject(int refNum)
method CodeNull (line 369) | private bool CodeNull<T>(ref T value) where T: class
method CodeCount (line 377) | public int CodeCount<T>(ref T value, Func<int, T> creator) where T : c...
method CodeLong (line 405) | private long CodeLong(long intValue)
method CodeCountLong (line 413) | public long CodeCountLong<T>(ref T value, Func<long, T> creator) where...
method CodeCountArray (line 445) | public long[] CodeCountArray<T>(ref T value, Func<long[], T> creator) ...
method CodeCountLong (line 487) | private long CodeCountLong<T>(ref T[] array)
method CodeCountLong (line 492) | private long[] CodeCountLong<T>(ref T[,] array)
method CodeCountLong (line 497) | private long[] CodeCountLong<T>(ref T[,,] array)
method CodeCountLong (line 502) | private long CodeCountLong<T>(ref T[][] array)
method CodeCountLong (line 507) | private long CodeCountLong<T>(ref T[][][] array)
method CodeCount (line 512) | private int CodeCount<T>(ref List<T> list)
method CodeTArray (line 517) | public void CodeTArray<T>(ref T[] value)
method CodeList_of_T_ (line 524) | public void CodeList_of_T_<T>(ref List<T> value)
method CodeHashSet_of_T_ (line 534) | public void CodeHashSet_of_T_<T>(ref HashSet<T> value)
method Code (line 544) | public void Code(Type t, ref object o)
method CreateArray (line 549) | private static Array CreateArray(Type t, long[] countArray)
method Code (line 561) | public void Code(Type t, ref Array array)
method CodeOld (line 597) | public void CodeOld(Type t, ref Array array)
method Code (line 610) | public void Code(Type t, ref IList list)
method Code (line 623) | public void Code(Type t, ref IDictionary dict)
method Code (line 641) | public void Code(Type t, ref ICountableDict dict)
method Code (line 660) | public void Code(Type t, ref ICountableDictSet dictSet)
method Code (line 676) | public void Code(Type t, ref IArrayVector value)
method Code (line 685) | public void Code(Type t, ref IArrayMatrix value)
method Code (line 694) | public void Code(Type t, ref IArrayVolume value)
method Code (line 703) | public void Code(Type t, ref IArrayTensor4 value)
method Code (line 712) | public void Code(Type t, ref IArrayTensorN value)
method CodeHashSet (line 721) | public void CodeHashSet(Type t, ref object obj)
method CodeEnum (line 726) | public void CodeEnum(Type type, ref object value)
method CodeBool (line 738) | public void CodeBool(ref bool value)
method CodeByte (line 743) | public void CodeByte(ref byte value)
method CodeSByte (line 748) | public void CodeSByte(ref sbyte value)
method CodeShort (line 753) | public void CodeShort(ref short value)
method CodeUShort (line 758) | public void CodeUShort(ref ushort value)
method CodeInt (line 763) | public void CodeInt(ref int value)
method CodeUInt (line 768) | public void CodeUInt(ref uint value)
method CodeLong (line 773) | public void CodeLong(ref long value)
method CodeULong (line 778) | public void CodeULong(ref ulong value)
method CodeFloat (line 783) | public void CodeFloat(ref float value)
method CodeDouble (line 788) | public void CodeDouble(ref double value)
method CodeChar (line 793) | public void CodeChar(ref char value)
method CodeString (line 798) | public void CodeString(ref string value)
method CodeType (line 809) | public void CodeType(ref Type value)
method CodeGuid (line 820) | public void CodeGuid(ref Guid value) { value = m_reader.ReadGuid(); }
method CodeSymbol (line 822) | public void CodeSymbol(ref Symbol value) { value = m_reader.ReadSymbol...
method CodeGuidSymbol (line 824) | public void CodeGuidSymbol(ref Symbol value) { value = m_reader.ReadGu...
method CodePositiveSymbol (line 826) | public void CodePositiveSymbol(ref Symbol value) { value = m_reader.Re...
method CodeIntSet (line 828) | public void CodeIntSet(ref IntSet set)
method CodeSymbolSet (line 835) | public void CodeSymbolSet(ref SymbolSet set)
method CodeFraction (line 842) | public void CodeFraction(ref Fraction value)
method CodeStructArray (line 853) | public void CodeStructArray<T>(ref T[] value)
method CodeBoolArray (line 861) | public void CodeBoolArray(ref bool[] value)
method CodeByteArray (line 868) | public void CodeByteArray(ref byte[] value)
method CodeSByteArray (line 875) | public void CodeSByteArray(ref sbyte[] value)
method CodeShortArray (line 882) | public void CodeShortArray(ref short[] value)
method CodeUShortArray (line 889) | public void CodeUShortArray(ref ushort[] value)
method CodeIntArray (line 896) | public void CodeIntArray(ref int[] value)
method CodeUIntArray (line 903) | public void CodeUIntArray(ref uint[] value)
method CodeLongArray (line 910) | public void CodeLongArray(ref long[] value)
method CodeULongArray (line 917) | public void CodeULongArray(ref ulong[] value)
method CodeFloatArray (line 924) | public void CodeFloatArray(ref float[] value)
method CodeDoubleArray (line 931) | public void CodeDoubleArray(ref double[] value)
method CodeCharArray (line 938) | public void CodeCharArray(ref char[] value)
method CodeStringArray (line 945) | public void CodeStringArray(ref string[] value)
method CodeTypeArray (line 952) | public void CodeTypeArray(ref Type[] value)
method CodeGuidArray (line 969) | public void CodeGuidArray(ref Guid[] value)
method CodeSymbolArray (line 976) | public void CodeSymbolArray(ref Symbol[] value)
method CodeFractionArray (line 983) | public void CodeFractionArray(ref Fraction[] value)
method CodeStructList (line 994) | public void CodeStructList<T>(ref List<T> value)
method CodeList_of_Bool_ (line 1002) | public void CodeList_of_Bool_(ref List<bool> value)
method CodeList_of_Byte_ (line 1009) | public void CodeList_of_Byte_(ref List<byte> value)
method CodeList_of_SByte_ (line 1016) | public void CodeList_of_SByte_(ref List<sbyte> value)
method CodeList_of_Short_ (line 1023) | public void CodeList_of_Short_(ref List<short> value)
method CodeList_of_UShort_ (line 1030) | public void CodeList_of_UShort_(ref List<ushort> value)
method CodeList_of_Int_ (line 1037) | public void CodeList_of_Int_(ref List<int> value)
method CodeList_of_UInt_ (line 1044) | public void CodeList_of_UInt_(ref List<uint> value)
method CodeList_of_Long_ (line 1051) | public void CodeList_of_Long_(ref List<long> value)
method CodeList_of_ULong_ (line 1058) | public void CodeList_of_ULong_(ref List<ulong> value)
method CodeList_of_Float_ (line 1065) | public void CodeList_of_Float_(ref List<float> value)
method CodeList_of_Double_ (line 1072) | public void CodeList_of_Double_(ref List<double> value)
method CodeList_of_Char_ (line 1079) | public void CodeList_of_Char_(ref List<char> value)
method CodeList_of_String_ (line 1086) | public void CodeList_of_String_(ref List<string> value)
method CodeList_of_Type_ (line 1094) | public void CodeList_of_Type_(ref List<Type> value)
method CodeList_of_Guid_ (line 1111) | public void CodeList_of_Guid_(ref List<Guid> value)
method CodeList_of_Symbol_ (line 1125) | public void CodeList_of_Symbol_(ref List<Symbol> value)
method CodeList_of_Fraction_ (line 1137) | public void CodeList_of_Fraction_(ref List<Fraction> value)
method Dispose (line 1148) | public void Dispose()
FILE: src/Aardvark.Base.IO/BinaryReadingCoder_auto.cs
class BinaryReadingCoder (line 9) | public partial class BinaryReadingCoder
method CodeV2i (line 13) | public void CodeV2i(ref V2i value)
method CodeV2ui (line 19) | public void CodeV2ui(ref V2ui value)
method CodeV2l (line 25) | public void CodeV2l(ref V2l value)
method CodeV2f (line 31) | public void CodeV2f(ref V2f value)
method CodeV2d (line 37) | public void CodeV2d(ref V2d value)
method CodeV3i (line 43) | public void CodeV3i(ref V3i value)
method CodeV3ui (line 50) | public void CodeV3ui(ref V3ui value)
method CodeV3l (line 57) | public void CodeV3l(ref V3l value)
method CodeV3f (line 64) | public void CodeV3f(ref V3f value)
method CodeV3d (line 71) | public void CodeV3d(ref V3d value)
method CodeV4i (line 78) | public void CodeV4i(ref V4i value)
method CodeV4ui (line 86) | public void CodeV4ui(ref V4ui value)
method CodeV4l (line 94) | public void CodeV4l(ref V4l value)
method CodeV4f (line 102) | public void CodeV4f(ref V4f value)
method CodeV4d (line 110) | public void CodeV4d(ref V4d value)
method CodeM22i (line 122) | public void CodeM22i(ref M22i value) { value = m_reader.ReadM22i(); }
method CodeM22l (line 123) | public void CodeM22l(ref M22l value) { value = m_reader.ReadM22l(); }
method CodeM22f (line 124) | public void CodeM22f(ref M22f value) { value = m_reader.ReadM22f(); }
method CodeM22d (line 125) | public void CodeM22d(ref M22d value) { value = m_reader.ReadM22d(); }
method CodeM23i (line 126) | public void CodeM23i(ref M23i value) { value = m_reader.ReadM23i(); }
method CodeM23l (line 127) | public void CodeM23l(ref M23l value) { value = m_reader.ReadM23l(); }
method CodeM23f (line 128) | public void CodeM23f(ref M23f value) { value = m_reader.ReadM23f(); }
method CodeM23d (line 129) | public void CodeM23d(ref M23d value) { value = m_reader.ReadM23d(); }
method CodeM33i (line 130) | public void CodeM33i(ref M33i value) { value = m_reader.ReadM33i(); }
method CodeM33l (line 131) | public void CodeM33l(ref M33l value) { value = m_reader.ReadM33l(); }
method CodeM33f (line 132) | public void CodeM33f(ref M33f value) { value = m_reader.ReadM33f(); }
method CodeM33d (line 133) | public void CodeM33d(ref M33d value) { value = m_reader.ReadM33d(); }
method CodeM34i (line 134) | public void CodeM34i(ref M34i value) { value = m_reader.ReadM34i(); }
method CodeM34l (line 135) | public void CodeM34l(ref M34l value) { value = m_reader.ReadM34l(); }
method CodeM34f (line 136) | public void CodeM34f(ref M34f value) { value = m_reader.ReadM34f(); }
method CodeM34d (line 137) | public void CodeM34d(ref M34d value) { value = m_reader.ReadM34d(); }
method CodeM44i (line 138) | public void CodeM44i(ref M44i value) { value = m_reader.ReadM44i(); }
method CodeM44l (line 139) | public void CodeM44l(ref M44l value) { value = m_reader.ReadM44l(); }
method CodeM44f (line 140) | public void CodeM44f(ref M44f value) { value = m_reader.ReadM44f(); }
method CodeM44d (line 141) | public void CodeM44d(ref M44d value) { value = m_reader.ReadM44d(); }
method CodeRange1b (line 147) | public void CodeRange1b(ref Range1b value)
method CodeRange1sb (line 153) | public void CodeRange1sb(ref Range1sb value)
method CodeRange1s (line 159) | public void CodeRange1s(ref Range1s value)
method CodeRange1us (line 165) | public void CodeRange1us(ref Range1us value)
method CodeRange1i (line 171) | public void CodeRange1i(ref Range1i value)
method CodeRange1ui (line 177) | public void CodeRange1ui(ref Range1ui value)
method CodeRange1l (line 183) | public void CodeRange1l(ref Range1l value)
method CodeRange1ul (line 189) | public void CodeRange1ul(ref Range1ul value)
method CodeRange1f (line 195) | public void CodeRange1f(ref Range1f value)
method CodeRange1d (line 201) | public void CodeRange1d(ref Range1d value)
method CodeBox2i (line 207) | public void CodeBox2i(ref Box2i value)
method CodeBox2l (line 213) | public void CodeBox2l(ref Box2l value)
method CodeBox2f (line 219) | public void CodeBox2f(ref Box2f value)
method CodeBox2d (line 225) | public void CodeBox2d(ref Box2d value)
method CodeBox3i (line 231) | public void CodeBox3i(ref Box3i value)
method CodeBox3l (line 237) | public void CodeBox3l(ref Box3l value)
method CodeBox3f (line 243) | public void CodeBox3f(ref Box3f value)
method CodeBox3d (line 249) | public void CodeBox3d(ref Box3d value)
method CodeCircle2f (line 259) | public void CodeCircle2f(ref Circle2f v)
method CodeLine2f (line 264) | public void CodeLine2f(ref Line2f v)
method CodeLine3f (line 269) | public void CodeLine3f(ref Line3f v)
method CodePlane2f (line 274) | public void CodePlane2f(ref Plane2f v)
method CodePlane3f (line 279) | public void CodePlane3f(ref Plane3f v)
method CodePlaneWithPoint3f (line 284) | public void CodePlaneWithPoint3f(ref PlaneWithPoint3f v)
method CodeQuad2f (line 289) | public void CodeQuad2f(ref Quad2f v)
method CodeQuad3f (line 294) | public void CodeQuad3f(ref Quad3f v)
method CodeRay2f (line 299) | public void CodeRay2f(ref Ray2f v)
method CodeRay3f (line 304) | public void CodeRay3f(ref Ray3f v)
method CodeSphere3f (line 309) | public void CodeSphere3f(ref Sphere3f v)
method CodeTriangle2f (line 314) | public void CodeTriangle2f(ref Triangle2f v)
method CodeTriangle3f (line 319) | public void CodeTriangle3f(ref Triangle3f v)
method CodeCircle2d (line 324) | public void CodeCircle2d(ref Circle2d v)
method CodeLine2d (line 329) | public void CodeLine2d(ref Line2d v)
method CodeLine3d (line 334) | public void CodeLine3d(ref Line3d v)
method CodePlane2d (line 339) | public void CodePlane2d(ref Plane2d v)
method CodePlane3d (line 344) | public void CodePlane3d(ref Plane3d v)
method CodePlaneWithPoint3d (line 349) | public void CodePlaneWithPoint3d(ref PlaneWithPoint3d v)
method CodeQuad2d (line 354) | public void CodeQuad2d(ref Quad2d v)
method CodeQuad3d (line 359) | public void CodeQuad3d(ref Quad3d v)
method CodeRay2d (line 364) | public void CodeRay2d(ref Ray2d v)
method CodeRay3d (line 369) | public void CodeRay3d(ref Ray3d v)
method CodeSphere3d (line 374) | public void CodeSphere3d(ref Sphere3d v)
method CodeTriangle2d (line 379) | public void CodeTriangle2d(ref Triangle2d v)
method CodeTriangle3d (line 384) | public void CodeTriangle3d(ref Triangle3d v)
method CodeC3b (line 393) | public void CodeC3b(ref C3b value)
method CodeC3us (line 400) | public void CodeC3us(ref C3us value)
method CodeC3ui (line 407) | public void CodeC3ui(ref C3ui value)
method CodeC3f (line 414) | public void CodeC3f(ref C3f value)
method CodeC3d (line 421) | public void CodeC3d(ref C3d value)
method CodeC4b (line 428) | public void CodeC4b(ref C4b value)
method CodeC4us (line 436) | public void CodeC4us(ref C4us value)
method CodeC4ui (line 444) | public void CodeC4ui(ref C4ui value)
method CodeC4f (line 452) | public void CodeC4f(ref C4f value)
method CodeC4d (line 460) | public void CodeC4d(ref C4d value)
method CodeEuclidean3f (line 472) | public void CodeEuclidean3f(ref Euclidean3f value) { value = m_reader....
method CodeEuclidean3d (line 473) | public void CodeEuclidean3d(ref Euclidean3d value) { value = m_reader....
method CodeRot2f (line 474) | public void CodeRot2f(ref Rot2f value) { value = m_reader.ReadRot2f(); }
method CodeRot2d (line 475) | public void CodeRot2d(ref Rot2d value) { value = m_reader.ReadRot2d(); }
method CodeRot3f (line 476) | public void CodeRot3f(ref Rot3f value) { value = m_reader.ReadRot3f(); }
method CodeRot3d (line 477) | public void CodeRot3d(ref Rot3d value) { value = m_reader.ReadRot3d(); }
method CodeScale3f (line 478) | public void CodeScale3f(ref Scale3f value) { value = m_reader.ReadScal...
method CodeScale3d (line 479) | public void CodeScale3d(ref Scale3d value) { value = m_reader.ReadScal...
method CodeShift3f (line 480) | public void CodeShift3f(ref Shift3f value) { value = m_reader.ReadShif...
method CodeShift3d (line 481) | public void CodeShift3d(ref Shift3d value) { value = m_reader.ReadShif...
method CodeTrafo2f (line 482) | public void CodeTrafo2f(ref Trafo2f value) { value = m_reader.ReadTraf...
method CodeTrafo2d (line 483) | public void CodeTrafo2d(ref Trafo2d value) { value = m_reader.ReadTraf...
method CodeTrafo3f (line 484) | public void CodeTrafo3f(ref Trafo3f value) { value = m_reader.ReadTraf...
method CodeTrafo3d (line 485) | public void CodeTrafo3d(ref Trafo3d value) { value = m_reader.ReadTraf...
method CodeVector_of_Byte_ (line 491) | public void CodeVector_of_Byte_(ref Vector<byte> value)
method CodeVector_of_SByte_ (line 500) | public void CodeVector_of_SByte_(ref Vector<sbyte> value)
method CodeVector_of_Short_ (line 509) | public void CodeVector_of_Short_(ref Vector<short> value)
method CodeVector_of_UShort_ (line 518) | public void CodeVector_of_UShort_(ref Vector<ushort> value)
method CodeVector_of_Int_ (line 527) | public void CodeVector_of_Int_(ref Vector<int> value)
method CodeVector_of_UInt_ (line 536) | public void CodeVector_of_UInt_(ref Vector<uint> value)
method CodeVector_of_Long_ (line 545) | public void CodeVector_of_Long_(ref Vector<long> value)
method CodeVector_of_ULong_ (line 554) | public void CodeVector_of_ULong_(ref Vector<ulong> value)
method CodeVector_of_Float_ (line 563) | public void CodeVector_of_Float_(ref Vector<float> value)
method CodeVector_of_Double_ (line 572) | public void CodeVector_of_Double_(ref Vector<double> value)
method CodeVector_of_Fraction_ (line 581) | public void CodeVector_of_Fraction_(ref Vector<Fraction> value)
method CodeVector_of_V2i_ (line 590) | public void CodeVector_of_V2i_(ref Vector<V2i> value)
method CodeVector_of_V2l_ (line 599) | public void CodeVector_of_V2l_(ref Vector<V2l> value)
method CodeVector_of_V2f_ (line 608) | public void CodeVector_of_V2f_(ref Vector<V2f> value)
method CodeVector_of_V2d_ (line 617) | public void CodeVector_of_V2d_(ref Vector<V2d> value)
method CodeVector_of_V3i_ (line 626) | public void CodeVector_of_V3i_(ref Vector<V3i> value)
method CodeVector_of_V3l_ (line 635) | public void CodeVector_of_V3l_(ref Vector<V3l> value)
method CodeVector_of_V3f_ (line 644) | public void CodeVector_of_V3f_(ref Vector<V3f> value)
method CodeVector_of_V3d_ (line 653) | public void CodeVector_of_V3d_(ref Vector<V3d> value)
method CodeVector_of_V4i_ (line 662) | public void CodeVector_of_V4i_(ref Vector<V4i> value)
method CodeVector_of_V4l_ (line 671) | public void CodeVector_of_V4l_(ref Vector<V4l> value)
method CodeVector_of_V4f_ (line 680) | public void CodeVector_of_V4f_(ref Vector<V4f> value)
method CodeVector_of_V4d_ (line 689) | public void CodeVector_of_V4d_(ref Vector<V4d> value)
method CodeVector_of_M22i_ (line 698) | public void CodeVector_of_M22i_(ref Vector<M22i> value)
method CodeVector_of_M22l_ (line 707) | public void CodeVector_of_M22l_(ref Vector<M22l> value)
method CodeVector_of_M22f_ (line 716) | public void CodeVector_of_M22f_(ref Vector<M22f> value)
method CodeVector_of_M22d_ (line 725) | public void CodeVector_of_M22d_(ref Vector<M22d> value)
method CodeVector_of_M23i_ (line 734) | public void CodeVector_of_M23i_(ref Vector<M23i> value)
method CodeVector_of_M23l_ (line 743) | public void CodeVector_of_M23l_(ref Vector<M23l> value)
method CodeVector_of_M23f_ (line 752) | public void CodeVector_of_M23f_(ref Vector<M23f> value)
method CodeVector_of_M23d_ (line 761) | public void CodeVector_of_M23d_(ref Vector<M23d> value)
method CodeVector_of_M33i_ (line 770) | public void CodeVector_of_M33i_(ref Vector<M33i> value)
method CodeVector_of_M33l_ (line 779) | public void CodeVector_of_M33l_(ref Vector<M33l> value)
method CodeVector_of_M33f_ (line 788) | public void CodeVector_of_M33f_(ref Vector<M33f> value)
method CodeVector_of_M33d_ (line 797) | public void CodeVector_of_M33d_(ref Vector<M33d> value)
method CodeVector_of_M34i_ (line 806) | public void CodeVector_of_M34i_(ref Vector<M34i> value)
method CodeVector_of_M34l_ (line 815) | public void CodeVector_of_M34l_(ref Vector<M34l> value)
method CodeVector_of_M34f_ (line 824) | public void CodeVector_of_M34f_(ref Vector<M34f> value)
method CodeVector_of_M34d_ (line 833) | public void CodeVector_of_M34d_(ref Vector<M34d> value)
method CodeVector_of_M44i_ (line 842) | public void CodeVector_of_M44i_(ref Vector<M44i> value)
method CodeVector_of_M44l_ (line 851) | public void CodeVector_of_M44l_(ref Vector<M44l> value)
method CodeVector_of_M44f_ (line 860) | public void CodeVector_of_M44f_(ref Vector<M44f> value)
method CodeVector_of_M44d_ (line 869) | public void CodeVector_of_M44d_(ref Vector<M44d> value)
method CodeVector_of_C3b_ (line 878) | public void CodeVector_of_C3b_(ref Vector<C3b> value)
method CodeVector_of_C3us_ (line 887) | public void CodeVector_of_C3us_(ref Vector<C3us> value)
method CodeVector_of_C3ui_ (line 896) | public void CodeVector_of_C3ui_(ref Vector<C3ui> value)
method CodeVector_of_C3f_ (line 905) | public void CodeVector_of_C3f_(ref Vector<C3f> value)
method CodeVector_of_C3d_ (line 914) | public void CodeVector_of_C3d_(ref Vector<C3d> value)
method CodeVector_of_C4b_ (line 923) | public void CodeVector_of_C4b_(ref Vector<C4b> value)
method CodeVector_of_C4us_ (line 932) | public void CodeVector_of_C4us_(ref Vector<C4us> value)
method CodeVector_of_C4ui_ (line 941) | public void CodeVector_of_C4ui_(ref Vector<C4ui> value)
method CodeVector_of_C4f_ (line 950) | public void CodeVector_of_C4f_(ref Vector<C4f> value)
method CodeVector_of_C4d_ (line 959) | public void CodeVector_of_C4d_(ref Vector<C4d> value)
method CodeVector_of_Range1b_ (line 968) | public void CodeVector_of_Range1b_(ref Vector<Range1b> value)
method CodeVector_of_Range1sb_ (line 977) | public void CodeVector_of_Range1sb_(ref Vector<Range1sb> value)
method CodeVector_of_Range1s_ (line 986) | public void CodeVector_of_Range1s_(ref Vector<Range1s> value)
method CodeVector_of_Range1us_ (line 995) | public void CodeVector_of_Range1us_(ref Vector<Range1us> value)
method CodeVector_of_Range1i_ (line 1004) | public void CodeVector_of_Range1i_(ref Vector<Range1i> value)
method CodeVector_of_Range1ui_ (line 1013) | public void CodeVector_of_Range1ui_(ref Vector<Range1ui> value)
method CodeVector_of_Range1l_ (line 1022) | public void CodeVector_of_Range1l_(ref Vector<Range1l> value)
method CodeVector_of_Range1ul_ (line 1031) | public void CodeVector_of_Range1ul_(ref Vector<Range1ul> value)
method CodeVector_of_Range1f_ (line 1040) | public void CodeVector_of_Range1f_(ref Vector<Range1f> value)
method CodeVector_of_Range1d_ (line 1049) | public void CodeVector_of_Range1d_(ref Vector<Range1d> value)
method CodeVector_of_Box2i_ (line 1058) | public void CodeVector_of_Box2i_(ref Vector<Box2i> value)
method CodeVector_of_Box2l_ (line 1067) | public void CodeVector_of_Box2l_(ref Vector<Box2l> value)
method CodeVector_of_Box2f_ (line 1076) | public void CodeVector_of_Box2f_(ref Vector<Box2f> value)
method CodeVector_of_Box2d_ (line 1085) | public void CodeVector_of_Box2d_(ref Vector<Box2d> value)
method CodeVector_of_Box3i_ (line 1094) | public void CodeVector_of_Box3i_(ref Vector<Box3i> value)
method CodeVector_of_Box3l_ (line 1103) | public void CodeVector_of_Box3l_(ref Vector<Box3l> value)
method CodeVector_of_Box3f_ (line 1112) | public void CodeVector_of_Box3f_(ref Vector<Box3f> value)
method CodeVector_of_Box3d_ (line 1121) | public void CodeVector_of_Box3d_(ref Vector<Box3d> value)
method CodeVector_of_Euclidean3f_ (line 1130) | public void CodeVector_of_Euclidean3f_(ref Vector<Euclidean3f> value)
method CodeVector_of_Euclidean3d_ (line 1139) | public void CodeVector_of_Euclidean3d_(ref Vector<Euclidean3d> value)
method CodeVector_of_Rot2f_ (line 1148) | public void CodeVector_of_Rot2f_(ref Vector<Rot2f> value)
method CodeVector_of_Rot2d_ (line 1157) | public void CodeVector_of_Rot2d_(ref Vector<Rot2d> value)
method CodeVector_of_Rot3f_ (line 1166) | public void CodeVector_of_Rot3f_(ref Vector<Rot3f> value)
method CodeVector_of_Rot3d_ (line 1175) | public void CodeVector_of_Rot3d_(ref Vector<Rot3d> value)
method CodeVector_of_Scale3f_ (line 1184) | public void CodeVector_of_Scale3f_(ref Vector<Scale3f> value)
method CodeVector_of_Scale3d_ (line 1193) | public void CodeVector_of_Scale3d_(ref Vector<Scale3d> value)
method CodeVector_of_Shift3f_ (line 1202) | public void CodeVector_of_Shift3f_(ref Vector<Shift3f> value)
method CodeVector_of_Shift3d_ (line 1211) | public void CodeVector_of_Shift3d_(ref Vector<Shift3d> value)
method CodeVector_of_Trafo2f_ (line 1220) | public void CodeVector_of_Trafo2f_(ref Vector<Trafo2f> value)
method CodeVector_of_Trafo2d_ (line 1229) | public void CodeVector_of_Trafo2d_(ref Vector<Trafo2d> value)
method CodeVector_of_Trafo3f_ (line 1238) | public void CodeVector_of_Trafo3f_(ref Vector<Trafo3f> value)
method CodeVector_of_Trafo3d_ (line 1247) | public void CodeVector_of_Trafo3d_(ref Vector<Trafo3d> value)
method CodeVector_of_Bool_ (line 1256) | public void CodeVector_of_Bool_(ref Vector<bool> value)
method CodeVector_of_Char_ (line 1265) | public void CodeVector_of_Char_(ref Vector<char> value)
method CodeVector_of_String_ (line 1274) | public void CodeVector_of_String_(ref Vector<string> value)
method CodeVector_of_Type_ (line 1283) | public void CodeVector_of_Type_(ref Vector<Type> value)
method CodeVector_of_Guid_ (line 1292) | public void CodeVector_of_Guid_(ref Vector<Guid> value)
method CodeVector_of_Symbol_ (line 1301) | public void CodeVector_of_Symbol_(ref Vector<Symbol> value)
method CodeVector_of_Circle2d_ (line 1310) | public void CodeVector_of_Circle2d_(ref Vector<Circle2d> value)
method CodeVector_of_Line2d_ (line 1319) | public void CodeVector_of_Line2d_(ref Vector<Line2d> value)
method CodeVector_of_Line3d_ (line 1328) | public void CodeVector_of_Line3d_(ref Vector<Line3d> value)
method CodeVector_of_Plane2d_ (line 1337) | public void CodeVector_of_Plane2d_(ref Vector<Plane2d> value)
method CodeVector_of_Plane3d_ (line 1346) | public void CodeVector_of_Plane3d_(ref Vector<Plane3d> value)
method CodeVector_of_PlaneWithPoint3d_ (line 1355) | public void CodeVector_of_PlaneWithPoint3d_(ref Vector<PlaneWithPoint3...
method CodeVector_of_Quad2d_ (line 1364) | public void CodeVector_of_Quad2d_(ref Vector<Quad2d> value)
method CodeVector_of_Quad3d_ (line 1373) | public void CodeVector_of_Quad3d_(ref Vector<Quad3d> value)
method CodeVector_of_Ray2d_ (line 1382) | public void CodeVector_of_Ray2d_(ref Vector<Ray2d> value)
method CodeVector_of_Ray3d_ (line 1391) | public void CodeVector_of_Ray3d_(ref Vector<Ray3d> value)
method CodeVector_of_Sphere3d_ (line 1400) | public void CodeVector_of_Sphere3d_(ref Vector<Sphere3d> value)
method CodeVector_of_Triangle2d_ (line 1409) | public void CodeVector_of_Triangle2d_(ref Vector<Triangle2d> value)
method CodeVector_of_Triangle3d_ (line 1418) | public void CodeVector_of_Triangle3d_(ref Vector<Triangle3d> value)
method CodeVector_of_Circle2f_ (line 1427) | public void CodeVector_of_Circle2f_(ref Vector<Circle2f> value)
method CodeVector_of_Line2f_ (line 1436) | public void CodeVector_of_Line2f_(ref Vector<Line2f> value)
method CodeVector_of_Line3f_ (line 1445) | public void CodeVector_of_Line3f_(ref Vector<Line3f> value)
method CodeVector_of_Plane2f_ (line 1454) | public void CodeVector_of_Plane2f_(ref Vector<Plane2f> value)
method CodeVector_of_Plane3f_ (line 1463) | public void CodeVector_of_Plane3f_(ref Vector<Plane3f> value)
method CodeVector_of_PlaneWithPoint3f_ (line 1472) | public void CodeVector_of_PlaneWithPoint3f_(ref Vector<PlaneWithPoint3...
method CodeVector_of_Quad2f_ (line 1481) | public void CodeVector_of_Quad2f_(ref Vector<Quad2f> value)
method CodeVector_of_Quad3f_ (line 1490) | public void CodeVector_of_Quad3f_(ref Vector<Quad3f> value)
method CodeVector_of_Ray2f_ (line 1499) | public void CodeVector_of_Ray2f_(ref Vector<Ray2f> value)
method CodeVector_of_Ray3f_ (line 1508) | public void CodeVector_of_Ray3f_(ref Vector<Ray3f> value)
method CodeVector_of_Sphere3f_ (line 1517) | public void CodeVector_of_Sphere3f_(ref Vector<Sphere3f> value)
method CodeVector_of_Triangle2f_ (line 1526) | public void CodeVector_of_Triangle2f_(ref Vector<Triangle2f> value)
method CodeVector_of_Triangle3f_ (line 1535) | public void CodeVector_of_Triangle3f_(ref Vector<Triangle3f> value)
method CodeMatrix_of_Byte_ (line 1544) | public void CodeMatrix_of_Byte_(ref Matrix<byte> value)
method CodeMatrix_of_SByte_ (line 1553) | public void CodeMatrix_of_SByte_(ref Matrix<sbyte> value)
method CodeMatrix_of_Short_ (line 1562) | public void CodeMatrix_of_Short_(ref Matrix<short> value)
method CodeMatrix_of_UShort_ (line 1571) | public void CodeMatrix_of_UShort_(ref Matrix<ushort> value)
method CodeMatrix_of_Int_ (line 1580) | public void CodeMatrix_of_Int_(ref Matrix<int> value)
method CodeMatrix_of_UInt_ (line 1589) | public void CodeMatrix_of_UInt_(ref Matrix<uint> value)
method CodeMatrix_of_Long_ (line 1598) | public void CodeMatrix_of_Long_(ref Matrix<long> value)
method CodeMatrix_of_ULong_ (line 1607) | public void CodeMatrix_of_ULong_(ref Matrix<ulong> value)
method CodeMatrix_of_Float_ (line 1616) | public void CodeMatrix_of_Float_(ref Matrix<float> value)
method CodeMatrix_of_Double_ (line 1625) | public void CodeMatrix_of_Double_(ref Matrix<double> value)
method CodeMatrix_of_Fraction_ (line 1634) | public void CodeMatrix_of_Fraction_(ref Matrix<Fraction> value)
method CodeMatrix_of_V2i_ (line 1643) | public void CodeMatrix_of_V2i_(ref Matrix<V2i> value)
method CodeMatrix_of_V2l_ (line 1652) | public void CodeMatrix_of_V2l_(ref Matrix<V2l> value)
method CodeMatrix_of_V2f_ (line 1661) | public void CodeMatrix_of_V2f_(ref Matrix<V2f> value)
method CodeMatrix_of_V2d_ (line 1670) | public void CodeMatrix_of_V2d_(ref Matrix<V2d> value)
method CodeMatrix_of_V3i_ (line 1679) | public void CodeMatrix_of_V3i_(ref Matrix<V3i> value)
method CodeMatrix_of_V3l_ (line 1688) | public void CodeMatrix_of_V3l_(ref Matrix<V3l> value)
method CodeMatrix_of_V3f_ (line 1697) | public void CodeMatrix_of_V3f_(ref Matrix<V3f> value)
method CodeMatrix_of_V3d_ (line 1706) | public void CodeMatrix_of_V3d_(ref Matrix<V3d> value)
method CodeMatrix_of_V4i_ (line 1715) | public void CodeMatrix_of_V4i_(ref Matrix<V4i> value)
method CodeMatrix_of_V4l_ (line 1724) | public void CodeMatrix_of_V4l_(ref Matrix<V4l> value)
method CodeMatrix_of_V4f_ (line 1733) | public void CodeMatrix_of_V4f_(ref Matrix<V4f> value)
method CodeMatrix_of_V4d_ (line 1742) | public void CodeMatrix_of_V4d_(ref Matrix<V4d> value)
method CodeMatrix_of_M22i_ (line 1751) | public void CodeMatrix_of_M22i_(ref Matrix<M22i> value)
method CodeMatrix_of_M22l_ (line 1760) | public void CodeMatrix_of_M22l_(ref Matrix<M22l> value)
method CodeMatrix_of_M22f_ (line 1769) | public void CodeMatrix_of_M22f_(ref Matrix<M22f> value)
method CodeMatrix_of_M22d_ (line 1778) | public void CodeMatrix_of_M22d_(ref Matrix<M22d> value)
method CodeMatrix_of_M23i_ (line 1787) | public void CodeMatrix_of_M23i_(ref Matrix<M23i> value)
method CodeMatrix_of_M23l_ (line 1796) | public void CodeMatrix_of_M23l_(ref Matrix<M23l> value)
method CodeMatrix_of_M23f_ (line 1805) | public void CodeMatrix_of_M23f_(ref Matrix<M23f> value)
method CodeMatrix_of_M23d_ (line 1814) | public void CodeMatrix_of_M23d_(ref Matrix<M23d> value)
method CodeMatrix_of_M33i_ (line 1823) | public void CodeMatrix_of_M33i_(ref Matrix<M33i> value)
method CodeMatrix_of_M33l_ (line 1832) | public void CodeMatrix_of_M33l_(ref Matrix<M33l> value)
method CodeMatrix_of_M33f_ (line 1841) | public void CodeMatrix_of_M33f_(ref Matrix<M33f> value)
method CodeMatrix_of_M33d_ (line 1850) | public void CodeMatrix_of_M33d_(ref Matrix<M33d> value)
method CodeMatrix_of_M34i_ (line 1859) | public void CodeMatrix_of_M34i_(ref Matrix<M34i> value)
method CodeMatrix_of_M34l_ (line 1868) | public void CodeMatrix_of_M34l_(ref Matrix<M34l> value)
method CodeMatrix_of_M34f_ (line 1877) | public void CodeMatrix_of_M34f_(ref Matrix<M34f> value)
method CodeMatrix_of_M34d_ (line 1886) | public void CodeMatrix_of_M34d_(ref Matrix<M34d> value)
method CodeMatrix_of_M44i_ (line 1895) | public void CodeMatrix_of_M44i_(ref Matrix<M44i> value)
method CodeMatrix_of_M44l_ (line 1904) | public void CodeMatrix_of_M44l_(ref Matrix<M44l> value)
method CodeMatrix_of_M44f_ (line 1913) | public void CodeMatrix_of_M44f_(ref Matrix<M44f> value)
method CodeMatrix_of_M44d_ (line 1922) | public void CodeMatrix_of_M44d_(ref Matrix<M44d> value)
method CodeMatrix_of_C3b_ (line 1931) | public void CodeMatrix_of_C3b_(ref Matrix<C3b> value)
method CodeMatrix_of_C3us_ (line 1940) | public void CodeMatrix_of_C3us_(ref Matrix<C3us> value)
method CodeMatrix_of_C3ui_ (line 1949) | public void CodeMatrix_of_C3ui_(ref Matrix<C3ui> value)
method CodeMatrix_of_C3f_ (line 1958) | public void CodeMatrix_of_C3f_(ref Matrix<C3f> value)
method CodeMatrix_of_C3d_ (line 1967) | public void CodeMatrix_of_C3d_(ref Matrix<C3d> value)
method CodeMatrix_of_C4b_ (line 1976) | public void CodeMatrix_of_C4b_(ref Matrix<C4b> value)
method CodeMatrix_of_C4us_ (line 1985) | public void CodeMatrix_of_C4us_(ref Matrix<C4us> value)
method CodeMatrix_of_C4ui_ (line 1994) | public void CodeMatrix_of_C4ui_(ref Matrix<C4ui> value)
method CodeMatrix_of_C4f_ (line 2003) | public void CodeMatrix_of_C4f_(ref Matrix<C4f> value)
method CodeMatrix_of_C4d_ (line 2012) | public void CodeMatrix_of_C4d_(ref Matrix<C4d> value)
method CodeMatrix_of_Range1b_ (line 2021) | public void CodeMatrix_of_Range1b_(ref Matrix<Range1b> value)
method CodeMatrix_of_Range1sb_ (line 2030) | public void CodeMatrix_of_Range1sb_(ref Matrix<Range1sb> value)
method CodeMatrix_of_Range1s_ (line 2039) | public void CodeMatrix_of_Range1s_(ref Matrix<Range1s> value)
method CodeMatrix_of_Range1us_ (line 2048) | public void CodeMatrix_of_Range1us_(ref Matrix<Range1us> value)
method CodeMatrix_of_Range1i_ (line 2057) | public void CodeMatrix_of_Range1i_(ref Matrix<Range1i> value)
method CodeMatrix_of_Range1ui_ (line 2066) | public void CodeMatrix_of_Range1ui_(ref Matrix<Range1ui> value)
method CodeMatrix_of_Range1l_ (line 2075) | public void CodeMatrix_of_Range1l_(ref Matrix<Range1l> value)
method CodeMatrix_of_Range1ul_ (line 2084) | public void CodeMatrix_of_Range1ul_(ref Matrix<Range1ul> value)
method CodeMatrix_of_Range1f_ (line 2093) | public void CodeMatrix_of_Range1f_(ref Matrix<Range1f> value)
method CodeMatrix_of_Range1d_ (line 2102) | public void CodeMatrix_of_Range1d_(ref Matrix<Range1d> value)
method CodeMatrix_of_Box2i_ (line 2111) | public void CodeMatrix_of_Box2i_(ref Matrix<Box2i> value)
method CodeMatrix_of_Box2l_ (line 2120) | public void CodeMatrix_of_Box2l_(ref Matrix<Box2l> value)
method CodeMatrix_of_Box2f_ (line 2129) | public void CodeMatrix_of_Box2f_(ref Matrix<Box2f> value)
method CodeMatrix_of_Box2d_ (line 2138) | public void CodeMatrix_of_Box2d_(ref Matrix<Box2d> value)
method CodeMatrix_of_Box3i_ (line 2147) | public void CodeMatrix_of_Box3i_(ref Matrix<Box3i> value)
method CodeMatrix_of_Box3l_ (line 2156) | public void CodeMatrix_of_Box3l_(ref Matrix<Box3l> value)
method CodeMatrix_of_Box3f_ (line 2165) | public void CodeMatrix_of_Box3f_(ref Matrix<Box3f> value)
method CodeMatrix_of_Box3d_ (line 2174) | public void CodeMatrix_of_Box3d_(ref Matrix<Box3d> value)
method CodeMatrix_of_Euclidean3f_ (line 2183) | public void CodeMatrix_of_Euclidean3f_(ref Matrix<Euclidean3f> value)
method CodeMatrix_of_Euclidean3d_ (line 2192) | public void CodeMatrix_of_Euclidean3d_(ref Matrix<Euclidean3d> value)
method CodeMatrix_of_Rot2f_ (line 2201) | public void CodeMatrix_of_Rot2f_(ref Matrix<Rot2f> value)
method CodeMatrix_of_Rot2d_ (line 2210) | public void CodeMatrix_of_Rot2d_(ref Matrix<Rot2d> value)
method CodeMatrix_of_Rot3f_ (line 2219) | public void CodeMatrix_of_Rot3f_(ref Matrix<Rot3f> value)
method CodeMatrix_of_Rot3d_ (line 2228) | public void CodeMatrix_of_Rot3d_(ref Matrix<Rot3d> value)
method CodeMatrix_of_Scale3f_ (line 2237) | public void CodeMatrix_of_Scale3f_(ref Matrix<Scale3f> value)
method CodeMatrix_of_Scale3d_ (line 2246) | public void CodeMatrix_of_Scale3d_(ref Matrix<Scale3d> value)
method CodeMatrix_of_Shift3f_ (line 2255) | public void CodeMatrix_of_Shift3f_(ref Matrix<Shift3f> value)
method CodeMatrix_of_Shift3d_ (line 2264) | public void CodeMatrix_of_Shift3d_(ref Matrix<Shift3d> value)
method CodeMatrix_of_Trafo2f_ (line 2273) | public void CodeMatrix_of_Trafo2f_(ref Matrix<Trafo2f> value)
method CodeMatrix_of_Trafo2d_ (line 2282) | public void CodeMatrix_of_Trafo2d_(ref Matrix<Trafo2d> value)
method CodeMatrix_of_Trafo3f_ (line 2291) | public void CodeMatrix_of_Trafo3f_(ref Matrix<Trafo3f> value)
method CodeMatrix_of_Trafo3d_ (line 2300) | public void CodeMatrix_of_Trafo3d_(ref Matrix<Trafo3d> value)
method CodeMatrix_of_Bool_ (line 2309) | public void CodeMatrix_of_Bool_(ref Matrix<bool> value)
method CodeMatrix_of_Char_ (line 2318) | public void CodeMatrix_of_Char_(ref Matrix<char> value)
method CodeMatrix_of_String_ (line 2327) | public void CodeMatrix_of_String_(ref Matrix<string> value)
method CodeMatrix_of_Type_ (line 2336) | public void CodeMatrix_of_Type_(ref Matrix<Type> value)
method CodeMatrix_of_Guid_ (line 2345) | public void CodeMatrix_of_Guid_(ref Matrix<Guid> value)
method CodeMatrix_of_Symbol_ (line 2354) | public void CodeMatrix_of_Symbol_(ref Matrix<Symbol> value)
method CodeMatrix_of_Circle2d_ (line 2363) | public void CodeMatrix_of_Circle2d_(ref Matrix<Circle2d> value)
method CodeMatrix_of_Line2d_ (line 2372) | public void CodeMatrix_of_Line2d_(ref Matrix<Line2d> value)
method CodeMatrix_of_Line3d_ (line 2381) | public void CodeMatrix_of_Line3d_(ref Matrix<Line3d> value)
method CodeMatrix_of_Plane2d_ (line 2390) | public void CodeMatrix_of_Plane2d_(ref Matrix<Plane2d> value)
method CodeMatrix_of_Plane3d_ (line 2399) | public void CodeMatrix_of_Plane3d_(ref Matrix<Plane3d> value)
method CodeMatrix_of_PlaneWithPoint3d_ (line 2408) | public void CodeMatrix_of_PlaneWithPoint3d_(ref Matrix<PlaneWithPoint3...
method CodeMatrix_of_Quad2d_ (line 2417) | public void CodeMatrix_of_Quad2d_(ref Matrix<Quad2d> value)
method CodeMatrix_of_Quad3d_ (line 2426) | public void CodeMatrix_of_Quad3d_(ref Matrix<Quad3d> value)
method CodeMatrix_of_Ray2d_ (line 2435) | public void CodeMatrix_of_Ray2d_(ref Matrix<Ray2d> value)
method CodeMatrix_of_Ray3d_ (line 2444) | public void CodeMatrix_of_Ray3d_(ref Matrix<Ray3d> value)
method CodeMatrix_of_Sphere3d_ (line 2453) | public void CodeMatrix_of_Sphere3d_(ref Matrix<Sphere3d> value)
method CodeMatrix_of_Triangle2d_ (line 2462) | public void CodeMatrix_of_Triangle2d_(ref Matrix<Triangle2d> value)
method CodeMatrix_of_Triangle3d_ (line 2471) | public void CodeMatrix_of_Triangle3d_(ref Matrix<Triangle3d> value)
method CodeMatrix_of_Circle2f_ (line 2480) | public void CodeMatrix_of_Circle2f_(ref Matrix<Circle2f> value)
method CodeMatrix_of_Line2f_ (line 2489) | public void CodeMatrix_of_Line2f_(ref Matrix<Line2f> value)
method CodeMatrix_of_Line3f_ (line 2498) | public void CodeMatrix_of_Line3f_(ref Matrix<Line3f> value)
method CodeMatrix_of_Plane2f_ (line 2507) | public void CodeMatrix_of_Plane2f_(ref Matrix<Plane2f> value)
method CodeMatrix_of_Plane3f_ (line 2516) | public void CodeMatrix_of_Plane3f_(ref Matrix<Plane3f> value)
method CodeMatrix_of_PlaneWithPoint3f_ (line 2525) | public void CodeMatrix_of_PlaneWithPoint3f_(ref Matrix<PlaneWithPoint3...
method CodeMatrix_of_Quad2f_ (line 2534) | public void CodeMatrix_of_Quad2f_(ref Matrix<Quad2f> value)
method CodeMatrix_of_Quad3f_ (line 2543) | public void CodeMatrix_of_Quad3f_(ref Matrix<Quad3f> value)
method CodeMatrix_of_Ray2f_ (line 2552) | public void CodeMatrix_of_Ray2f_(ref Matrix<Ray2f> value)
method CodeMatrix_of_Ray3f_ (line 2561) | public void CodeMatrix_of_Ray3f_(ref Matrix<Ray3f> value)
method CodeMatrix_of_Sphere3f_ (line 2570) | public void CodeMatrix_of_Sphere3f_(ref Matrix<Sphere3f> value)
method CodeMatrix_of_Triangle2f_ (line 2579) | public void CodeMatrix_of_Triangle2f_(ref Matrix<Triangle2f> value)
method CodeMatrix_of_Triangle3f_ (line 2588) | public void CodeMatrix_of_Triangle3f_(ref Matrix<Triangle3f> value)
method CodeVolume_of_Byte_ (line 2597) | public void CodeVolume_of_Byte_(ref Volume<byte> value)
method CodeVolume_of_SByte_ (line 2606) | public void CodeVolume_of_SByte_(ref Volume<sbyte> value)
method CodeVolume_of_Short_ (line 2615) | public void CodeVolume_of_Short_(ref Volume<short> value)
method CodeVolume_of_UShort_ (line 2624) | public void CodeVolume_of_UShort_(ref Volume<ushort> value)
method CodeVolume_of_Int_ (line 2633) | public void CodeVolume_of_Int_(ref Volume<int> value)
method CodeVolume_of_UInt_ (line 2642) | public void CodeVolume_of_UInt_(ref Volume<uint> value)
method CodeVolume_of_Long_ (line 2651) | public void CodeVolume_of_Long_(ref Volume<long> value)
method CodeVolume_of_ULong_ (line 2660) | public void CodeVolume_of_ULong_(ref Volume<ulong> value)
method CodeVolume_of_Float_ (line 2669) | public void CodeVolume_of_Float_(ref Volume<float> value)
method CodeVolume_of_Double_ (line 2678) | public void CodeVolume_of_Double_(ref Volume<double> value)
method CodeVolume_of_Fraction_ (line 2687) | public void CodeVolume_of_Fraction_(ref Volume<Fraction> value)
method CodeVolume_of_V2i_ (line 2696) | public void CodeVolume_of_V2i_(ref Volume<V2i> value)
method CodeVolume_of_V2l_ (line 2705) | public void CodeVolume_of_V2l_(ref Volume<V2l> value)
method CodeVolume_of_V2f_ (line 2714) | public void CodeVolume_of_V2f_(ref Volume<V2f> value)
method CodeVolume_of_V2d_ (line 2723) | public void CodeVolume_of_V2d_(ref Volume<V2d> value)
method CodeVolume_of_V3i_ (line 2732) | public void CodeVolume_of_V3i_(ref Volume<V3i> value)
method CodeVolume_of_V3l_ (line 2741) | public void CodeVolume_of_V3l_(ref Volume<V3l> value)
method CodeVolume_of_V3f_ (line 2750) | public void CodeVolume_of_V3f_(ref Volume<V3f> value)
method CodeVolume_of_V3d_ (line 2759) | public void CodeVolume_of_V3d_(ref Volume<V3d> value)
method CodeVolume_of_V4i_ (line 2768) | public void CodeVolume_of_V4i_(ref Volume<V4i> value)
method CodeVolume_of_V4l_ (line 2777) | public void CodeVolume_of_V4l_(ref Volume<V4l> value)
method CodeVolume_of_V4f_ (line 2786) | public void CodeVolume_of_V4f_(ref Volume<V4f> value)
method CodeVolume_of_V4d_ (line 2795) | public void CodeVolume_of_V4d_(ref Volume<V4d> value)
method CodeVolume_of_M22i_ (line 2804) | public void CodeVolume_of_M22i_(ref Volume<M22i> value)
method CodeVolume_of_M22l_ (line 2813) | public void CodeVolume_of_M22l_(ref Volume<M22l> value)
method CodeVolume_of_M22f_ (line 2822) | public void CodeVolume_of_M22f_(ref Volume<M22f> value)
method CodeVolume_of_M22d_ (line 2831) | public void CodeVolume_of_M22d_(ref Volume<M22d> value)
method CodeVolume_of_M23i_ (line 2840) | public void CodeVolume_of_M23i_(ref Volume<M23i> value)
method CodeVolume_of_M23l_ (line 2849) | public void CodeVolume_of_M23l_(ref Volume<M23l> value)
method CodeVolume_of_M23f_ (line 2858) | public void CodeVolume_of_M23f_(ref Volume<M23f> value)
method CodeVolume_of_M23d_ (line 2867) | public void CodeVolume_of_M23d_(ref Volume<M23d> value)
method CodeVolume_of_M33i_ (line 2876) | public void CodeVolume_of_M33i_(ref Volume<M33i> value)
method CodeVolume_of_M33l_ (line 2885) | public void CodeVolume_of_M33l_(ref Volume<M33l> value)
method CodeVolume_of_M33f_ (line 2894) | public void CodeVolume_of_M33f_(ref Volume<M33f> value)
method CodeVolume_of_M33d_ (line 2903) | public void CodeVolume_of_M33d_(ref Volume<M33d> value)
method CodeVolume_of_M34i_ (line 2912) | public void CodeVolume_of_M34i_(ref Volume<M34i> value)
method CodeVolume_of_M34l_ (line 2921) | public void CodeVolume_of_M34l_(ref Volume<M34l> value)
method CodeVolume_of_M34f_ (line 2930) | public void CodeVolume_of_M34f_(ref Volume<M34f> value)
method CodeVolume_of_M34d_ (line 2939) | public void CodeVolume_of_M34d_(ref Volume<M34d> value)
method CodeVolume_of_M44i_ (line 2948) | public void CodeVolume_of_M44i_(ref Volume<M44i> value)
method CodeVolume_of_M44l_ (line 2957) | public void CodeVolume_of_M44l_(ref Volume<M44l> value)
method CodeVolume_of_M44f_ (line 2966) | public void CodeVolume_of_M44f_(ref Volume<M44f> value)
method CodeVolume_of_M44d_ (line 2975) | public void CodeVolume_of_M44d_(ref Volume<M44d> value)
method CodeVolume_of_C3b_ (line 2984) | public void CodeVolume_of_C3b_(ref Volume<C3b> value)
method CodeVolume_of_C3us_ (line 2993) | public void CodeVolume_of_C3us_(ref Volume<C3us> value)
method CodeVolume_of_C3ui_ (line 3002) | public void CodeVolume_of_C3ui_(ref Volume<C3ui> value)
method CodeVolume_of_C3f_ (line 3011) | public void CodeVolume_of_C3f_(ref Volume<C3f> value)
method CodeVolume_of_C3d_ (line 3020) | public void CodeVolume_of_C3d_(ref Volume<C3d> value)
method CodeVolume_of_C4b_ (line 3029) | public void CodeVolume_of_C4b_(ref Volume<C4b> value)
method CodeVolume_of_C4us_ (line 3038) | public void CodeVolume_of_C4us_(ref Volume<C4us> value)
method CodeVolume_of_C4ui_ (line 3047) | public void CodeVolume_of_C4ui_(ref Volume<C4ui> value)
method CodeVolume_of_C4f_ (line 3056) | public void CodeVolume_of_C4f_(ref Volume<C4f> value)
method CodeVolume_of_C4d_ (line 3065) | public void CodeVolume_of_C4d_(ref Volume<C4d> value)
method CodeVolume_of_Range1b_ (line 3074) | public void CodeVolume_of_Range1b_(ref Volume<Range1b> value)
method CodeVolume_of_Range1sb_ (line 3083) | public void CodeVolume_of_Range1sb_(ref Volume<Range1sb> value)
method CodeVolume_of_Range1s_ (line 3092) | public void CodeVolume_of_Range1s_(ref Volume<Range1s> value)
method CodeVolume_of_Range1us_ (line 3101) | public void CodeVolume_of_Range1us_(ref Volume<Range1us> value)
method CodeVolume_of_Range1i_ (line 3110) | public void CodeVolume_of_Range1i_(ref Volume<Range1i> value)
method CodeVolume_of_Range1ui_ (line 3119) | public void CodeVolume_of_Range1ui_(ref Volume<Range1ui> value)
method CodeVolume_of_Range1l_ (line 3128) | public void CodeVolume_of_Range1l_(ref Volume<Range1l> value)
method CodeVolume_of_Range1ul_ (line 3137) | public void CodeVolume_of_Range1ul_(ref Volume<Range1ul> value)
method CodeVolume_of_Range1f_ (line 3146) | public void CodeVolume_of_Range1f_(ref Volume<Range1f> value)
method CodeVolume_of_Range1d_ (line 3155) | public void CodeVolume_of_Range1d_(ref Volume<Range1d> value)
method CodeVolume_of_Box2i_ (line 3164) | public void CodeVolume_of_Box2i_(ref Volume<Box2i> value)
method CodeVolume_of_Box2l_ (line 3173) | public void CodeVolume_of_Box2l_(ref Volume<Box2l> value)
method CodeVolume_of_Box2f_ (line 3182) | public void CodeVolume_of_Box2f_(ref Volume<Box2f> value)
method CodeVolume_of_Box2d_ (line 3191) | public void CodeVolume_of_Box2d_(ref Volume<Box2d> value)
method CodeVolume_of_Box3i_ (line 3200) | public void CodeVolume_of_Box3i_(ref Volume<Box3i> value)
method CodeVolume_of_Box3l_ (line 3209) | public void CodeVolume_of_Box3l_(ref Volume<Box3l> value)
method CodeVolume_of_Box3f_ (line 3218) | public void CodeVolume_of_Box3f_(ref Volume<Box3f> value)
method CodeVolume_of_Box3d_ (line 3227) | public void CodeVolume_of_Box3d_(ref Volume<Box3d> value)
method CodeVolume_of_Euclidean3f_ (line 3236) | public void CodeVolume_of_Euclidean3f_(ref Volume<Euclidean3f> value)
method CodeVolume_of_Euclidean3d_ (line 3245) | public void CodeVolume_of_Euclidean3d_(ref Volume<Euclidean3d> value)
method CodeVolume_of_Rot2f_ (line 3254) | public void CodeVolume_of_Rot2f_(ref Volume<Rot2f> value)
method CodeVolume_of_Rot2d_ (line 3263) | public void CodeVolume_of_Rot2d_(ref Volume<Rot2d> value)
method CodeVolume_of_Rot3f_ (line 3272) | public void CodeVolume_of_Rot3f_(ref Volume<Rot3f> value)
method CodeVolume_of_Rot3d_ (line 3281) | public void CodeVolume_of_Rot3d_(ref Volume<Rot3d> value)
method CodeVolume_of_Scale3f_ (line 3290) | public void CodeVolume_of_Scale3f_(ref Volume<Scale3f> value)
method CodeVolume_of_Scale3d_ (line 3299) | public void CodeVolume_of_Scale3d_(ref Volume<Scale3d> value)
method CodeVolume_of_Shift3f_ (line 3308) | public void CodeVolume_of_Shift3f_(ref Volume<Shift3f> value)
method CodeVolume_of_Shift3d_ (line 3317) | public void CodeVolume_of_Shift3d_(ref Volume<Shift3d> value)
method CodeVolume_of_Trafo2f_ (line 3326) | public void CodeVolume_of_Trafo2f_(ref Volume<Trafo2f> value)
method CodeVolume_of_Trafo2d_ (line 3335) | public void CodeVolume_of_Trafo2d_(ref Volume<Trafo2d> value)
method CodeVolume_of_Trafo3f_ (line 3344) | public void CodeVolume_of_Trafo3f_(ref Volume<Trafo3f> value)
method CodeVolume_of_Trafo3d_ (line 3353) | public void CodeVolume_of_Trafo3d_(ref Volume<Trafo3d> value)
method CodeVolume_of_Bool_ (line 3362) | public void CodeVolume_of_Bool_(ref Volume<bool> value)
method CodeVolume_of_Char_ (line 3371) | public void CodeVolume_of_Char_(ref Volume<char> value)
method CodeVolume_of_String_ (line 3380) | public void CodeVolume_of_String_(ref Volume<string> value)
method CodeVolume_of_Type_ (line 3389) | public void CodeVolume_of_Type_(ref Volume<Type> value)
method CodeVolume_of_Guid_ (line 3398) | public void CodeVolume_of_Guid_(ref Volume<Guid> value)
method CodeVolume_of_Symbol_ (line 3407) | public void CodeVolume_of_Symbol_(ref Volume<Symbol> value)
method CodeVolume_of_Circle2d_ (line 3416) | public void CodeVolume_of_Circle2d_(ref Volume<Circle2d> value)
method CodeVolume_of_Line2d_ (line 3425) | public void CodeVolume_of_Line2d_(ref Volume<Line2d> value)
method CodeVolume_of_Line3d_ (line 3434) | public void CodeVolume_of_Line3d_(ref Volume<Line3d> value)
method CodeVolume_of_Plane2d_ (line 3443) | public void CodeVolume_of_Plane2d_(ref Volume<Plane2d> value)
method CodeVolume_of_Plane3d_ (line 3452) | public void CodeVolume_of_Plane3d_(ref Volume<Plane3d> value)
method CodeVolume_of_PlaneWithPoint3d_ (line 3461) | public void CodeVolume_of_PlaneWithPoint3d_(ref Volume<PlaneWithPoint3...
method CodeVolume_of_Quad2d_ (line 3470) | public void CodeVolume_of_Quad2d_(ref Volume<Quad2d> value)
method CodeVolume_of_Quad3d_ (line 3479) | public void CodeVolume_of_Quad3d_(ref Volume<Quad3d> value)
method CodeVolume_of_Ray2d_ (line 3488) | public void CodeVolume_of_Ray2d_(ref Volume<Ray2d> value)
method CodeVolume_of_Ray3d_ (line 3497) | public void CodeVolume_of_Ray3d_(ref Volume<Ray3d> value)
method CodeVolume_of_Sphere3d_ (line 3506) | public void CodeVolume_of_Sphere3d_(ref Volume<Sphere3d> value)
method CodeVolume_of_Triangle2d_ (line 3515) | public void CodeVolume_of_Triangle2d_(ref Volume<Triangle2d> value)
method CodeVolume_of_Triangle3d_ (line 3524) | public void CodeVolume_of_Triangle3d_(ref Volume<Triangle3d> value)
method CodeVolume_of_Circle2f_ (line 3533) | public void CodeVolume_of_Circle2f_(ref Volume<Circle2f> value)
method CodeVolume_of_Line2f_ (line 3542) | public void CodeVolume_of_Line2f_(ref Volume<Line2f> value)
method CodeVolume_of_Line3f_ (line 3551) | public void CodeVolume_of_Line3f_(ref Volume<Line3f> value)
method CodeVolume_of_Plane2f_ (line 3560) | public void CodeVolume_of_Plane2f_(ref Volume<Plane2f> value)
method CodeVolume_of_Plane3f_ (line 3569) | public void CodeVolume_of_Plane3f_(ref Volume<Plane3f> value)
method CodeVolume_of_PlaneWithPoint3f_ (line 3578) | public void CodeVolume_of_PlaneWithPoint3f_(ref Volume<PlaneWithPoint3...
method CodeVolume_of_Quad2f_ (line 3587) | public void CodeVolume_of_Quad2f_(ref Volume<Quad2f> value)
method CodeVolume_of_Quad3f_ (line 3596) | public void CodeVolume_of_Quad3f_(ref Volume<Quad3f> value)
method CodeVolume_of_Ray2f_ (line 3605) | public void CodeVolume_of_Ray2f_(ref Volume<Ray2f> value)
method CodeVolume_of_Ray3f_ (line 3614) | public void CodeVolume_of_Ray3f_(ref Volume<Ray3f> value)
method CodeVolume_of_Sphere3f_ (line 3623) | public void CodeVolume_of_Sphere3f_(ref Volume<Sphere3f> value)
method CodeVolume_of_Triangle2f_ (line 3632) | public void CodeVolume_of_Triangle2f_(ref Volume<Triangle2f> value)
method CodeVolume_of_Triangle3f_ (line 3641) | public void CodeVolume_of_Triangle3f_(ref Volume<Triangle3f> value)
method CodeTensor_of_Byte_ (line 3650) | public void CodeTensor_of_Byte_(ref Tensor<byte> value)
method CodeTensor_of_SByte_ (line 3659) | public void CodeTensor_of_SByte_(ref Tensor<sbyte> value)
method CodeTensor_of_Short_ (line 3668) | public void CodeTensor_of_Short_(ref Tensor<short> value)
method CodeTensor_of_UShort_ (line 3677) | public void CodeTensor_of_UShort_(ref Tensor<ushort> value)
method CodeTensor_of_Int_ (line 3686) | public void CodeTensor_of_Int_(ref Tensor<int> value)
method CodeTensor_of_UInt_ (line 3695) | public void CodeTensor_of_UInt_(ref Tensor<uint> value)
method CodeTensor_of_Long_ (line 3704) | public void CodeTensor_of_Long_(ref Tensor<long> value)
method CodeTensor_of_ULong_ (line 3713) | public void CodeTensor_of_ULong_(ref Tensor<ulong> value)
method CodeTensor_of_Float_ (line 3722) | public void CodeTensor_of_Float_(ref Tensor<float> value)
method CodeTensor_of_Double_ (line 3731) | public void CodeTensor_of_Double_(ref Tensor<double> value)
method CodeTensor_of_Fraction_ (line 3740) | public void CodeTensor_of_Fraction_(ref Tensor<Fraction> value)
method CodeTensor_of_V2i_ (line 3749) | public void CodeTensor_of_V2i_(ref Tensor<V2i> value)
method CodeTensor_of_V2l_ (line 3758) | public void CodeTensor_of_V2l_(ref Tensor<V2l> value)
method CodeTensor_of_V2f_ (line 3767) | public void CodeTensor_of_V2f_(ref Tensor<V2f> value)
method CodeTensor_of_V2d_ (line 3776) | public void CodeTensor_of_V2d_(ref Tensor<V2d> value)
method CodeTensor_of_V3i_ (line 3785) | public void CodeTensor_of_V3i_(ref Tensor<V3i> value)
method CodeTensor_of_V3l_ (line 3794) | public void CodeTensor_of_V3l_(ref Tensor<V3l> value)
method CodeTensor_of_V3f_ (line 3803) | public void CodeTensor_of_V3f_(ref Tensor<V3f> value)
method CodeTensor_of_V3d_ (line 3812) | public void CodeTensor_of_V3d_(ref Tensor<V3d> value)
method CodeTensor_of_V4i_ (line 3821) | public void CodeTensor_of_V4i_(ref Tensor<V4i> value)
method CodeTensor_of_V4l_ (line 3830) | public void CodeTensor_of_V4l_(ref Tensor<V4l> value)
method CodeTensor_of_V4f_ (line 3839) | public void CodeTensor_of_V4f_(ref Tensor<V4f> value)
method CodeTensor_of_V4d_ (line 3848) | public void CodeTensor_of_V4d_(ref Tensor<V4d> value)
method CodeTensor_of_M22i_ (line 3857) | public void CodeTensor_of_M22i_(ref Tensor<M22i> value)
method CodeTensor_of_M22l_ (line 3866) | public void CodeTensor_of_M22l_(ref Tensor<M22l> value)
method CodeTensor_of_M22f_ (line 3875) | public void CodeTensor_of_M22f_(ref Tensor<M22f> value)
method CodeTensor_of_M22d_ (line 3884) | public void CodeTensor_of_M22d_(ref Tensor<M22d> value)
method CodeTensor_of_M23i_ (line 3893) | public void CodeTensor_of_M23i_(ref Tensor<M23i> value)
method CodeTensor_of_M23l_ (line 3902) | public void CodeTensor_of_M23l_(ref Tensor<M23l> value)
method CodeTensor_of_M23f_ (line 3911) | public void CodeTensor_of_M23f_(ref Tensor<M23f> value)
method CodeTensor_of_M23d_ (line 3920) | public void CodeTensor_of_M23d_(ref Tensor<M23d> value)
method CodeTensor_of_M33i_ (line 3929) | public void CodeTensor_of_M33i_(ref Tensor<M33i> value)
method CodeTensor_of_M33l_ (line 3938) | public void CodeTensor_of_M33l_(ref Tensor<M33l> value)
method CodeTensor_of_M33f_ (line 3947) | public void CodeTensor_of_M33f_(ref Tensor<M33f> value)
method CodeTensor_of_M33d_ (line 3956) | public void CodeTensor_of_M33d_(ref Tensor<M33d> value)
method CodeTensor_of_M34i_ (line 3965) | public void CodeTensor_of_M34i_(ref Tensor<M34i> value)
method CodeTensor_of_M34l_ (line 3974) | public void CodeTensor_of_M34l_(ref Tensor<M34l> value)
method CodeTensor_of_M34f_ (line 3983) | public void CodeTensor_of_M34f_(ref Tensor<M34f> value)
method CodeTensor_of_M34d_ (line 3992) | public void CodeTensor_of_M34d_(ref Tensor<M34d> value)
method CodeTensor_of_M44i_ (line 4001) | public void CodeTensor_of_M44i_(ref Tensor<M44i> value)
method CodeTensor_of_M44l_ (line 4010) | public void CodeTensor_of_M44l_(ref Tensor<M44l> value)
method CodeTensor_of_M44f_ (line 4019) | public void CodeTensor_of_M44f_(ref Tensor<M44f> value)
method CodeTensor_of_M44d_ (line 4028) | public void CodeTensor_of_M44d_(ref Tensor<M44d> value)
method CodeTensor_of_C3b_ (line 4037) | public void CodeTensor_of_C3b_(ref Tensor<C3b> value)
method CodeTensor_of_C3us_ (line 4046) | public void CodeTensor_of_C3us_(ref Tensor<C3us> value)
method CodeTensor_of_C3ui_ (line 4055) | public void CodeTensor_of_C3ui_(ref Tensor<C3ui> value)
method CodeTensor_of_C3f_ (line 4064) | public void CodeTensor_of_C3f_(ref Tensor<C3f> value)
method CodeTensor_of_C3d_ (line 4073) | public void CodeTensor_of_C3d_(ref Tensor<C3d> value)
method CodeTensor_of_C4b_ (line 4082) | public void CodeTensor_of_C4b_(ref Tensor<C4b> value)
method CodeTensor_of_C4us_ (line 4091) | public void CodeTensor_of_C4us_(ref Tensor<C4us> value)
method CodeTensor_of_C4ui_ (line 4100) | public void CodeTensor_of_C4ui_(ref Tensor<C4ui> value)
method CodeTensor_of_C4f_ (line 4109) | public void CodeTensor_of_C4f_(ref Tensor<C4f> value)
method CodeTensor_of_C4d_ (line 4118) | public void CodeTensor_of_C4d_(ref Tensor<C4d> value)
method CodeTensor_of_Range1b_ (line 4127) | public void CodeTensor_of_Range1b_(ref Tensor<Range1b> value)
method CodeTensor_of_Range1sb_ (line 4136) | public void CodeTensor_of_Range1sb_(ref Tensor<Range1sb> value)
method CodeTensor_of_Range1s_ (line 4145) | public void CodeTensor_of_Range1s_(ref Tensor<Range1s> value)
method CodeTensor_of_Range1us_ (line 4154) | public void CodeTensor_of_Range1us_(ref Tensor<Range1us> value)
method CodeTensor_of_Range1i_ (line 4163) | public void CodeTensor_of_Range1i_(ref Tensor<Range1i> value)
method CodeTensor_of_Range1ui_ (line 4172) | public void CodeTensor_of_Range1ui_(ref Tensor<Range1ui> value)
method CodeTensor_of_Range1l_ (line 4181) | public void CodeTensor_of_Range1l_(ref Tensor<Range1l> value)
method CodeTensor_of_Range1ul_ (line 4190) | public void CodeTensor_of_Range1ul_(ref Tensor<Range1ul> value)
method CodeTensor_of_Range1f_ (line 4199) | public void CodeTensor_of_Range1f_(ref Tensor<Range1f> value)
method CodeTensor_of_Range1d_ (line 4208) | public void CodeTensor_of_Range1d_(ref Tensor<Range1d> value)
method CodeTensor_of_Box2i_ (line 4217) | public void CodeTensor_of_Box2i_(ref Tensor<Box2i> value)
method CodeTensor_of_Box2l_ (line 4226) | public void CodeTensor_of_Box2l_(ref Tensor<Box2l> value)
method CodeTensor_of_Box2f_ (line 4235) | public void CodeTensor_of_Box2f_(ref Tensor<Box2f> value)
method CodeTensor_of_Box2d_ (line 4244) | public void CodeTensor_of_Box2d_(ref Tensor<Box2d> value)
method CodeTensor_of_Box3i_ (line 4253) | public void CodeTensor_of_Box3i_(ref Tensor<Box3i> value)
method CodeTensor_of_Box3l_ (line 4262) | public void CodeTensor_of_Box3l_(ref Tensor<Box3l> value)
method CodeTensor_of_Box3f_ (line 4271) | public void CodeTensor_of_Box3f_(ref Tensor<Box3f> value)
method CodeTensor_of_Box3d_ (line 4280) | public void CodeTensor_of_Box3d_(ref Tensor<Box3d> value)
method CodeTensor_of_Euclidean3f_ (line 4289) | public void CodeTensor_of_Euclidean3f_(ref Tensor<Euclidean3f> value)
method CodeTensor_of_Euclidean3d_ (line 4298) | public void CodeTensor_of_Euclidean3d_(ref Tensor<Euclidean3d> value)
method CodeTensor_of_Rot2f_ (line 4307) | public void CodeTensor_of_Rot2f_(ref Tensor<Rot2f> value)
method CodeTensor_of_Rot2d_ (line 4316) | public void CodeTensor_of_Rot2d_(ref Tensor<Rot2d> value)
method CodeTensor_of_Rot3f_ (line 4325) | public void CodeTensor_of_Rot3f_(ref Tensor<Rot3f> value)
method CodeTensor_of_Rot3d_ (line 4334) | public void CodeTensor_of_Rot3d_(ref Tensor<Rot3d> value)
method CodeTensor_of_Scale3f_ (line 4343) | public void CodeTensor_of_Scale3f_(ref Tensor<Scale3f> value)
method CodeTensor_of_Scale3d_ (line 4352) | public void CodeTensor_of_Scale3d_(ref Tensor<Scale3d> value)
method CodeTensor_of_Shift3f_ (line 4361) | public void CodeTensor_of_Shift3f_(ref Tensor<Shift3f> value)
method CodeTensor_of_Shift3d_ (line 4370) | public void CodeTensor_of_Shift3d_(ref Tensor<Shift3d> value)
method CodeTensor_of_Trafo2f_ (line 4379) | public void CodeTensor_of_Trafo2f_(ref Tensor<Trafo2f> value)
method CodeTensor_of_Trafo2d_ (line 4388) | public void CodeTensor_of_Trafo2d_(ref Tensor<Trafo2d> value)
method CodeTensor_of_Trafo3f_ (line 4397) | public void CodeTensor_of_Trafo3f_(ref Tensor<Trafo3f> value)
method CodeTensor_of_Trafo3d_ (line 4406) | public void CodeTensor_of_Trafo3d_(ref Tensor<Trafo3d> value)
method CodeTensor_of_Bool_ (line 4415) | public void CodeTensor_of_Bool_(ref Tensor<bool> value)
method CodeTensor_of_Char_ (line 4424) | public void CodeTensor_of_Char_(ref Tensor<char> value)
method CodeTensor_of_String_ (line 4433) | public void CodeTensor_of_String_(ref Tensor<string> value)
method CodeTensor_of_Type_ (line 4442) | public void CodeTensor_of_Type_(ref Tensor<Type> value)
method CodeTensor_of_Guid_ (line 4451) | public void CodeTensor_of_Guid_(ref Tensor<Guid> value)
method CodeTensor_of_Symbol_ (line 4460) | public void CodeTensor_of_Symbol_(ref Tensor<Symbol> value)
method CodeTensor_of_Circle2d_ (line 4469) | public void CodeTensor_of_Circle2d_(ref Tensor<Circle2d> value)
method CodeTensor_of_Line2d_ (line 4478) | public void CodeTensor_of_Line2d_(ref Tensor<Line2d> value)
method CodeTensor_of_Line3d_ (line 4487) | public void CodeTensor_of_Line3d_(ref Tensor<Line3d> value)
method CodeTensor_of_Plane2d_ (line 4496) | public void CodeTensor_of_Plane2d_(ref Tensor<Plane2d> value)
method CodeTensor_of_Plane3d_ (line 4505) | public void CodeTensor_of_Plane3d_(ref Tensor<Plane3d> value)
method CodeTensor_of_PlaneWithPoint3d_ (line 4514) | public void CodeTensor_of_PlaneWithPoint3d_(ref Tensor<PlaneWithPoint3...
method CodeTensor_of_Quad2d_ (line 4523) | public void CodeTensor_of_Quad2d_(ref Tensor<Quad2d> value)
method CodeTensor_of_Quad3d_ (line 4532) | public void CodeTensor_of_Quad3d_(ref Tensor<Quad3d> value)
method CodeTensor_of_Ray2d_ (line 4541) | public void CodeTensor_of_Ray2d_(ref Tensor<Ray2d> value)
method CodeTensor_of_Ray3d_ (line 4550) | public void CodeTensor_of_Ray3d_(ref Tensor<Ray3d> value)
method CodeTensor_of_Sphere3d_ (line 4559) | public void CodeTensor_of_Sphere3d_(ref Tensor<Sphere3d> value)
method CodeTensor_of_Triangle2d_ (line 4568) | public void CodeTensor_of_Triangle2d_(ref Tensor<Triangle2d> value)
method CodeTensor_of_Triangle3d_ (line 4577) | public void CodeTensor_of_Triangle3d_(ref Tensor<Triangle3d> value)
method CodeTensor_of_Circle2f_ (line 4586) | public void CodeTensor_of_Circle2f_(ref Tensor<Circle2f> value)
method CodeTensor_of_Line2f_ (line 4595) | public void CodeTensor_of_Line2f_(ref Tensor<Line2f> value)
method CodeTensor_of_Line3f_ (line 4604) | public void CodeTensor_of_Line3f_(ref Tensor<Line3f> value)
method CodeTensor_of_Plane2f_ (line 4613) | public void CodeTensor_of_Plane2f_(ref Tensor<Plane2f> value)
method CodeTensor_of_Plane3f_ (line 4622) | public void CodeTensor_of_Plane3f_(ref Tensor<Plane3f> value)
method CodeTensor_of_PlaneWithPoint3f_ (line 4631) | public void CodeTensor_of_PlaneWithPoint3f_(ref Tensor<PlaneWithPoint3...
method CodeTensor_of_Quad2f_ (line 4640) | public void CodeTensor_of_Quad2f_(ref Tensor<Quad2f> value)
method CodeTensor_of_Quad3f_ (line 4649) | public void CodeTensor_of_Quad3f_(ref Tensor<Quad3f> value)
method CodeTensor_of_Ray2f_ (line 4658) | public void CodeTensor_of_Ray2f_(ref Tensor<Ray2f> value)
method CodeTensor_of_Ray3f_ (line 4667) | public void CodeTensor_of_Ray3f_(ref Tensor<Ray3f> value)
method CodeTensor_of_Sphere3f_ (line 4676) | public void CodeTensor_of_Sphere3f_(ref Tensor<Sphere3f> value)
method CodeTensor_of_Triangle2f_ (line 4685) | public void CodeTensor_of_Triangle2f_(ref Tensor<Triangle2f> value)
method CodeTensor_of_Triangle3f_ (line 4694) | public void CodeTensor_of_Triangle3f_(ref Tensor<Triangle3f> value)
method CodeV2iArray (line 4707) | public void CodeV2iArray(ref V2i[] value)
method CodeV2uiArray (line 4714) | public void CodeV2uiArray(ref V2ui[] value)
method CodeV2lArray (line 4721) | public void CodeV2lArray(ref V2l[] value)
method CodeV2fArray (line 4728) | public void CodeV2fArray(ref V2f[] value)
method CodeV2dArray (line 4735) | public void CodeV2dArray(ref V2d[] value)
method CodeV3iArray (line 4742) | public void CodeV3iArray(ref V3i[] value)
method CodeV3uiArray (line 4749) | public void CodeV3uiArray(ref V3ui[] value)
method CodeV3lArray (line 4756) | public void CodeV3lArray(ref V3l[] value)
method CodeV3fArray (line 4763) | public void CodeV3fArray(ref V3f[] value)
method CodeV3dArray (line 4770) | public void CodeV3dArray(ref V3d[] value)
method CodeV4iArray (line 4777) | public void CodeV4iArray(ref V4i[] value)
method CodeV4uiArray (line 4784) | public void CodeV4uiArray(ref V4ui[] value)
method CodeV4lArray (line 4791) | public void CodeV4lArray(ref V4l[] value)
method CodeV4fArray (line 4798) | public void CodeV4fArray(ref V4f[] value)
method CodeV4dArray (line 4805) | public void CodeV4dArray(ref V4d[] value)
method CodeM22iArray (line 4812) | public void CodeM22iArray(ref M22i[] value)
method CodeM22lArray (line 4819) | public void CodeM22lArray(ref M22l[] value)
method CodeM22fArray (line 4826) | public void CodeM22fArray(ref M22f[] value)
method CodeM22dArray (line 4833) | public void CodeM22dArray(ref M22d[] value)
method CodeM23iArray (line 4840) | public void CodeM23iArray(ref M23i[] value)
method CodeM23lArray (line 4847) | public void CodeM23lArray(ref M23l[] value)
method CodeM23fArray (line 4854) | public void CodeM23fArray(ref M23f[] value)
method CodeM23dArray (line 4861) | public void CodeM23dArray(ref M23d[] value)
method CodeM33iArray (line 4868) | public void CodeM33iArray(ref M33i[] value)
method CodeM33lArray (line 4875) | public void CodeM33lArray(ref M33l[] value)
method CodeM33fArray (line 4882) | public void CodeM33fArray(ref M33f[] value)
method CodeM33dArray (line 4889) | public void CodeM33dArray(ref M33d[] value)
method CodeM34iArray (line 4896) | public void CodeM34iArray(ref M34i[] value)
method CodeM34lArray (line 4903) | public void CodeM34lArray(ref M34l[] value)
method CodeM34fArray (line 4910) | public void CodeM34fArray(ref M34f[] value)
method CodeM34dArray (line 4917) | public void CodeM34dArray(ref M34d[] value)
method CodeM44iArray (line 4924) | public void CodeM44iArray(ref M44i[] value)
method CodeM44lArray (line 4931) | public void CodeM44lArray(ref M44l[] value)
method CodeM44fArray (line 4938) | public void CodeM44fArray(ref M44f[] value)
method CodeM44dArray (line 4945) | public void CodeM44dArray(ref M44d[] value)
method CodeRange1bArray (line 4952) | public void CodeRange1bArray(ref Range1b[] value)
method CodeRange1sbArray (line 4959) | public void CodeRange1sbArray(ref Range1sb[] value)
method CodeRange1sArray (line 4966) | public void CodeRange1sArray(ref Range1s[] value)
method CodeRange1usArray (line 4973) | public void CodeRange1usArray(ref Range1us[] value)
method CodeRange1iArray (line 4980) | public void CodeRange1iArray(ref Range1i[] value)
method CodeRange1uiArray (line 4987) | public void CodeRange1uiArray(ref Range1ui[] value)
method CodeRange1lArray (line 4994) | public void CodeRange1lArray(ref Range1l[] value)
method CodeRange1ulArray (line 5001) | public void CodeRange1ulArray(ref Range1ul[] value)
method CodeRange1fArray (line 5008) | public void CodeRange1fArray(ref Range1f[] value)
method CodeRange1dArray (line 5015) | public void CodeRange1dArray(ref Range1d[] value)
method CodeBox2iArray (line 5022) | public void CodeBox2iArray(ref Box2i[] value)
method CodeBox2lArray (line 5029) | public void CodeBox2lArray(ref Box2l[] value)
method CodeBox2fArray (line 5036) | public void CodeBox2fArray(ref Box2f[] value)
method CodeBox2dArray (line 5043) | public void CodeBox2dArray(ref Box2d[] value)
method CodeBox3iArray (line 5050) | public void CodeBox3iArray(ref Box3i[] value)
method CodeBox3lArray (line 5057) | public void CodeBox3lArray(ref Box3l[] value)
method CodeBox3fArray (line 5064) | public void CodeBox3fArray(ref Box3f[] value)
method CodeBox3dArray (line 5071) | public void CodeBox3dArray(ref Box3d[] value)
method CodeC3bArray (line 5078) | public void CodeC3bArray(ref C3b[] value)
method CodeC3usArray (line 5085) | public void CodeC3usArray(ref C3us[] value)
method CodeC3uiArray (line 5092) | public void CodeC3uiArray(ref C3ui[] value)
method CodeC3fArray (line 5099) | public void CodeC3fArray(ref C3f[] value)
method CodeC3dArray (line 5106) | public void CodeC3dArray(ref C3d[] value)
method CodeC4bArray (line 5113) | public void CodeC4bArray(ref C4b[] value)
method CodeC4usArray (line 5120) | public void CodeC4usArray(ref C4us[] value)
method CodeC4uiArray (line 5127) | public void CodeC4uiArray(ref C4ui[] value)
method CodeC4fArray (line 5134) | public void CodeC4fArray(ref C4f[] value)
method CodeC4dArray (line 5141) | public void CodeC4dArray(ref C4d[] value)
method CodeEuclidean3fArray (line 5148) | public void CodeEuclidean3fArray(ref Euclidean3f[] value)
method CodeEuclidean3dArray (line 5155) | public void CodeEuclidean3dArray(ref Euclidean3d[] value)
method CodeRot2fArray (line 5162) | public void CodeRot2fArray(ref Rot2f[] value)
method CodeRot2dArray (line 5169) | public void CodeRot2dArray(ref Rot2d[] value)
method CodeRot3fArray (line 5176) | public void CodeRot3fArray(ref Rot3f[] value)
method CodeRot3dArray (line 5183) | public void CodeRot3dArray(ref Rot3d[] value)
method CodeScale3fArray (line 5190) | public void CodeScale3fArray(ref Scale3f[] value)
method CodeScale3dArray (line 5197) | public void CodeScale3dArray(ref Scale3d[] value)
method CodeShift3fArray (line 5204) | public void CodeShift3fArray(ref Shift3f[] value)
method CodeShift3dArray (line 5211) | public void CodeShift3dArray(ref Shift3d[] value)
method CodeTrafo2fArray (line 5218) | public void CodeTrafo2fArray(ref Trafo2f[] value)
method CodeTrafo2dArray (line 5225) | public void CodeTrafo2dArray(ref Trafo2d[] value)
method CodeTrafo3fArray (line 5232) | public void CodeTrafo3fArray(ref Trafo3f[] value)
method CodeTrafo3dArray (line 5239) | public void CodeTrafo3dArray(ref Trafo3d[] value)
method CodeCircle2dArray (line 5246) | public void CodeCircle2dArray(ref Circle2d[] value)
method CodeLine2dArray (line 5253) | public void CodeLine2dArray(ref Line2d[] value)
method CodeLine3dArray (line 5260) | public void CodeLine3dArray(ref Line3d[] value)
method CodePlane2dArray (line 5267) | public void CodePlane2dArray(ref Plane2d[] value)
method CodePlane3dArray (line 5274) | public void CodePlane3dArray(ref Plane3d[] value)
method CodePlaneWithPoint3dArray (line 5281) | public void CodePlaneWithPoint3dArray(ref PlaneWithPoint3d[] value)
method CodeQuad2dArray (line 5288) | public void CodeQuad2dArray(ref Quad2d[] value)
method CodeQuad3dArray (line 5295) | public void CodeQuad3dArray(ref Quad3d[] value)
method CodeRay2dArray (line 5302) | public void CodeRay2dArray(ref Ray2d[] value)
method CodeRay3dArray (line 5309) | public void CodeRay3dArray(ref Ray3d[] value)
method CodeSphere3dArray (line 5316) | public void CodeSphere3dArray(ref Sphere3d[] value)
method CodeTriangle2dArray (line 5323) | public void CodeTriangle2dArray(ref Triangle2d[] value)
method CodeTriangle3dArray (line 5330) | public void CodeTriangle3dArray(ref Triangle3d[] value)
method CodeCircle2fArray (line 5337) | public void CodeCircle2fArray(ref Circle2f[] value)
method CodeLine2fArray (line 5344) | public void CodeLine2fArray(ref Line2f[] value)
method CodeLine3fArray (line 5351) | public void CodeLine3fArray(ref Line3f[] value)
method CodePlane2fArray (line 5358) | public void CodePlane2fArray(ref Plane2f[] value)
method CodePlane3fArray (line 5365) | public void CodePlane3fArray(ref Plane3f[] value)
method CodePlaneWithPoint3fArray (line 5372) | public void CodePlaneWithPoint3fArray(ref PlaneWithPoint3f[] value)
method CodeQuad2fArray (line 5379) | public void CodeQuad2fArray(ref Quad2f[] value)
method CodeQuad3fArray (line 5386) | public void CodeQuad3fArray(ref Quad3f[] value)
method CodeRay2fArray (line 5393) | public void CodeRay2fArray(ref Ray2f[] value)
method CodeRay3fArray (line 5400) | public void CodeRay3fArray(ref Ray3f[] value)
method CodeSphere3fArray (line 5407) | public void CodeSphere3fArray(ref Sphere3f[] value)
method CodeTriangle2fArray (line 5414) | public void CodeTriangle2fArray(ref Triangle2f[] value)
method CodeTriangle3fArray (line 5421) | public void CodeTriangle3fArray(ref Triangle3f[] value)
method CodeVector_of_Byte_Array (line 5428) | public void CodeVector_of_Byte_Array(ref Vector<byte>[] value)
method CodeVector_of_SByte_Array (line 5435) | public void CodeVector_of_SByte_Array(ref Vector<sbyte>[] value)
method CodeVector_of_Short_Array (line 5442) | public void CodeVector_of_Short_Array(ref Vector<short>[] value)
method CodeVector_of_UShort_Array (line 5449) | public void CodeVector_of_UShort_Array(ref Vector<ushort>[] value)
method CodeVector_of_Int_Array (line 5456) | public void CodeVector_of_Int_Array(ref Vector<int>[] value)
method CodeVector_of_UInt_Array (line 5463) | public void CodeVector_of_UInt_Array(ref Vector<uint>[] value)
method CodeVector_of_Long_Array (line 5470) | public void CodeVector_of_Long_Array(ref Vector<long>[] value)
method CodeVector_of_ULong_Array (line 5477) | public void CodeVector_of_ULong_Array(ref Vector<ulong>[] value)
method CodeVector_of_Float_Array (line 5484) | public void CodeVector_of_Float_Array(ref Vector<float>[] value)
method CodeVector_of_Double_Array (line 5491) | public void CodeVector_of_Double_Array(ref Vector<double>[] value)
method CodeVector_of_Fraction_Array (line 5498) | public void CodeVector_of_Fraction_Array(ref Vector<Fraction>[] value)
method CodeVector_of_V2i_Array (line 5505) | public void CodeVector_of_V2i_Array(ref Vector<V2i>[] value)
method CodeVector_of_V2l_Array (line 5512) | public void CodeVector_of_V2l_Array(ref Vector<V2l>[] value)
method CodeVector_of_V2f_Array (line 5519) | public void CodeVector_of_V2f_Array(ref Vector<V2f>[] value)
method CodeVector_of_V2d_Array (line 5526) | public void CodeVector_of_V2d_Array(ref Vector<V2d>[] value)
method CodeVector_of_V3i_Array (line 5533) | public void CodeVector_of_V3i_Array(ref Vector<V3i>[] value)
method CodeVector_of_V3l_Array (line 5540) | public void CodeVector_of_V3l_Array(ref Vector<V3l>[] value)
method CodeVector_of_V3f_Array (line 5547) | public void CodeVector_of_V3f_Array(ref Vector<V3f>[] value)
method CodeVector_of_V3d_Array (line 5554) | public void CodeVector_of_V3d_Array(ref Vector<V3d>[] value)
method CodeVector_of_V4i_Array (line 5561) | public void CodeVector_of_V4i_Array(ref Vector<V4i>[] value)
method CodeVector_of_V4l_Array (line 5568) | public void CodeVector_of_V4l_Array(ref Vector<V4l>[] value)
method CodeVector_of_V4f_Array (line 5575) | public void CodeVector_of_V4f_Array(ref Vector<V4f>[] value)
method CodeVector_of_V4d_Array (line 5582) | public void CodeVector_of_V4d_Array(ref Vector<V4d>[] value)
method CodeVector_of_M22i_Array (line 5589) | public void CodeVector_of_M22i_Array(ref Vector<M22i>[] value)
method CodeVector_of_M22l_Array (line 5596) | public void CodeVector_of_M22l_Array(ref Vector<M22l>[] value)
method CodeVector_of_M22f_Array (line 5603) | public void CodeVector_of_M22f_Array(ref Vector<M22f>[] value)
method CodeVector_of_M22d_Array (line 5610) | public void CodeVector_of_M22d_Array(ref Vector<M22d>[] value)
method CodeVector_of_M23i_Array (line 5617) | public void CodeVector_of_M23i_Array(ref Vector<M23i>[] value)
method CodeVector_of_M23l_Array (line 5624) | public void CodeVector_of_M23l_Array(ref Vector<M23l>[] value)
method CodeVector_of_M23f_Array (line 5631) | public void CodeVector_of_M23f_Array(ref Vector<M23f>[] value)
method CodeVector_of_M23d_Array (line 5638) | public void CodeVector_of_M23d_Array(ref Vector<M23d>[] value)
method CodeVector_of_M33i_Array (line 5645) | public void CodeVector_of_M33i_Array(ref Vector<M33i>[] value)
method CodeVector_of_M33l_Array (line 5652) | public void CodeVector_of_M33l_Array(ref Vector<M33l>[] value)
method CodeVector_of_M33f_Array (line 5659) | public void CodeVector_of_M33f_Array(ref Vector<M33f>[] value)
method CodeVector_of_M33d_Array (line 5666) | public void CodeVector_of_M33d_Array(ref Vector<M33d>[] value)
method CodeVector_of_M34i_Array (line 5673) | public void CodeVector_of_M34i_Array(ref Vector<M34i>[] value)
method CodeVector_of_M34l_Array (line 5680) | public void CodeVector_of_M34l_Array(ref Vector<M34l>[] value)
method CodeVector_of_M34f_Array (line 5687) | public void CodeVector_of_M34f_Array(ref Vector<M34f>[] value)
method CodeVector_of_M34d_Array (line 5694) | public void CodeVector_of_M34d_Array(ref Vector<M34d>[] value)
method CodeVector_of_M44i_Array (line 5701) | public void CodeVector_of_M44i_Array(ref Vector<M44i>[] value)
method CodeVector_of_M44l_Array (line 5708) | public void CodeVector_of_M44l_Array(ref Vector<M44l>[] value)
method CodeVector_of_M44f_Array (line 5715) | public void CodeVector_of_M44f_Array(ref Vector<M44f>[] value)
method CodeVector_of_M44d_Array (line 5722) | public void CodeVector_of_M44d_Array(ref Vector<M44d>[] value)
method CodeVector_of_C3b_Array (line 5729) | public void CodeVector_of_C3b_Array(ref Vector<C3b>[] value)
method CodeVector_of_C3us_Array (line 5736) | public void CodeVector_of_C3us_Array(ref Vector<C3us>[] value)
method CodeVector_of_C3ui_Array (line 5743) | public void CodeVector_of_C3ui_Array(ref Vector<C3ui>[] value)
method CodeVector_of_C3f_Array (line 5750) | public void CodeVector_of_C3f_Array(ref Vector<C3f>[] value)
method CodeVector_of_C3d_Array (line 5757) | public void CodeVector_of_C3d_Array(ref Vector<C3d>[] value)
method CodeVector_of_C4b_Array (line 5764) | public void CodeVector_of_C4b_Array(ref Vector<C4b>[] value)
method CodeVector_of_C4us_Array (line 5771) | public void CodeVector_of_C4us_Array(ref Vector<C4us>[] value)
method CodeVector_of_C4ui_Array (line 5778) | public void CodeVector_of_C4ui_Array(ref Vector<C4ui>[] value)
method CodeVector_of_C4f_Array (line 5785) | public void CodeVector_of_C4f_Array(ref Vector<C4f>[] value)
method CodeVector_of_C4d_Array (line 5792) | public void CodeVector_of_C4d_Array(ref Vector<C4d>[] value)
method CodeVector_of_Range1b_Array (line 5799) | public void CodeVector_of_Range1b_Array(ref Vector<Range1b>[] value)
method CodeVector_of_Range1sb_Array (line 5806) | public void CodeVector_of_Range1sb_Array(ref Vector<Range1sb>[] value)
method CodeVector_of_Range1s_Array (line 5813) | public void CodeVector_of_Range1s_Array(ref Vector<Range1s>[] value)
method CodeVector_of_Range1us_Array (line 5820) | public void CodeVector_of_Range1us_Array(ref Vector<Range1us>[] value)
method CodeVector_of_Range1i_Array (line 5827) | public void CodeVector_of_Range1i_Array(ref Vector<Range1i>[] value)
method CodeVector_of_Range1ui_Array (line 5834) | public void CodeVector_of_Range1ui_Array(ref Vector<Range1ui>[] value)
method CodeVector_of_Range1l_Array (line 5841) | public void CodeVector_of_Range1l_Array(ref Vector<Range1l>[] value)
method CodeVector_of_Range1ul_Array (line 5848) | public void CodeVector_of_Range1ul_Array(ref Vector<Range1ul>[] value)
method CodeVector_of_Range1f_Array (line 5855) | public void CodeVector_of_Range1f_Array(ref Vector<Range1f>[] value)
method CodeVector_of_Range1d_Array (line 5862) | public void CodeVector_of_Range1d_Array(ref Vector<Range1d>[] value)
method CodeVector_of_Box2i_Array (line 5869) | public void CodeVector_of_Box2i_Array(ref Vector<Box2i>[] value)
method CodeVector_of_Box2l_Array (line 5876) | public void CodeVector_of_Box2l_Array(ref Vector<Box2l>[] value)
method CodeVector_of_Box2f_Array (line 5883) | public void CodeVector_of_Box2f_Array(ref Vector<Box2f>[] value)
method CodeVector_of_Box2d_Array (line 5890) | public void CodeVector_of_Box2d_Array(ref Vector<Box2d>[] value)
method CodeVector_of_Box3i_Array (line 5897) | public void CodeVector_of_Box3i_Array(ref Vector<Box3i>[] value)
method CodeVector_of_Box3l_Array (line 5904) | public void CodeVector_of_Box3l_Array(ref Vector<Box3l>[] value)
method CodeVector_of_Box3f_Array (line 5911) | public void CodeVector_of_Box3f_Array(ref Vector<Box3f>[] value)
method CodeVector_of_Box3d_Array (line 5918) | public void CodeVector_of_Box3d_Array(ref Vector<Box3d>[] value)
method CodeVector_of_Euclidean3f_Array (line 5925) | public void CodeVector_of_Euclidean3f_Array(ref Vector<Euclidean3f>[] ...
method CodeVector_of_Euclidean3d_Array (line 5932) | public void CodeVector_of_Euclidean3d_Array(ref Vector<Euclidean3d>[] ...
method CodeVector_of_Rot2f_Array (line 5939) | public void CodeVector_of_Rot2f_Array(ref Vector<Rot2f>[] value)
method CodeVector_of_Rot2d_Array (line 5946) | public void CodeVector_of_Rot2d_Array(ref Vector<Rot2d>[] value)
method CodeVector_of_Rot3f_Array (line 5953) | public void CodeVector_of_Rot3f_Array(ref Vector<Rot3f>[] value)
method CodeVector_of_Rot3d_Array (line 5960) | public void CodeVector_of_Rot3d_Array(ref Vector<Rot3d>[] value)
method CodeVector_of_Scale3f_Array (line 5967) | public void CodeVector_of_Scale3f_Array(ref Vector<Scale3f>[] value)
method CodeVector_of_Scale3d_Array (line 5974) | public void CodeVector_of_Scale3d_Array(ref Vector<Scale3d>[] value)
method CodeVector_of_Shift3f_Array (line 5981) | public void CodeVector_of_Shift3f_Array(ref Vector<Shift3f>[] value)
method CodeVector_of_Shift3d_Array (line 5988) | public void CodeVector_of_Shift3d_Array(ref Vector<Shift3d>[] value)
method CodeVector_of_Trafo2f_Array (line 5995) | public void CodeVector_of_Trafo2f_Array(ref Vector<Trafo2f>[] value)
method CodeVector_of_Trafo2d_Array (line 6002) | public void CodeVector_of_Trafo2d_Array(ref Vector<Trafo2d>[] value)
method CodeVector_of_Trafo3f_Array (line 6009) | public void CodeVector_of_Trafo3f_Array(ref Vector<Trafo3f>[] value)
method CodeVector_of_Trafo3d_Array (line 6016) | public void CodeVector_of_Trafo3d_Array(ref Vector<Trafo3d>[] value)
method CodeVector_of_Bool_Array (line 6023) | public void CodeVector_of_Bool_Array(ref Vector<bool>[] value)
method CodeVector_of_Char_Array (line 6030) | public void CodeVector_of_Char_Array(ref Vector<char>[] value)
method CodeVector_of_String_Array (line 6037) | public void CodeVector_of_String_Array(ref Vector<string>[] value)
method CodeVector_of_Type_Array (line 6044) | public void CodeVector_of_Type_Array(ref Vector<Type>[] value)
method CodeVector_of_Guid_Array (line 6051) | public void CodeVector_of_Guid_Array(ref Vector<Guid>[] value)
method CodeVector_of_Symbol_Array (line 6058) | public void CodeVector_of_Symbol_Array(ref Vector<Symbol>[] value)
method CodeVector_of_Circle2d_Array (line 6065) | public void CodeVector_of_Circle2d_Array(ref Vector<Circle2d>[] value)
method CodeVector_of_Line2d_Array (line 6072) | public void CodeVector_of_Line2d_Array(ref Vector<Line2d>[] value)
method CodeVector_of_Line3d_Array (line 6079) | public void CodeVector_of_Line3d_Array(ref Vector<Line3d>[] value)
method CodeVector_of_Plane2d_Array (line 6086) | public void CodeVector_of_Plane2d_Array(ref Vector<Plane2d>[] value)
method CodeVector_of_Plane3d_Array (line 6093) | public void CodeVector_of_Plane3d_Array(ref Vector<Plane3d>[] value)
method CodeVector_of_PlaneWithPoint3d_Array (line 6100) | public void CodeVector_of_PlaneWithPoint3d_Array(ref Vector<PlaneWithP...
method CodeVector_of_Quad2d_Array (line 6107) | public void CodeVector_of_Quad2d_Array(ref Vector<Quad2d>[] value)
method CodeVector_of_Quad3d_Array (line 6114) | public void CodeVector_of_Quad3d_Array(ref Vector<Quad3d>[] value)
method CodeVector_of_Ray2d_Array (line 6121) | public void CodeVector_of_Ray2d_Array(ref Vector<Ray2d>[] value)
method CodeVector_of_Ray3d_Array (line 6128) | public void CodeVector_of_Ray3d_Array(ref Vector<Ray3d>[] value)
method CodeVector_of_Sphere3d_Array (line 6135) | public void CodeVector_of_Sphere3d_Array(ref Vector<Sphere3d>[] value)
method CodeVector_of_Triangle2d_Array (line 6142) | public void CodeVector_of_Triangle2d_Array(ref Vector<Triangle2d>[] va...
method CodeVector_of_Triangle3d_Array (line 6149) | public void CodeVector_of_Triangle3d_Array(ref Vector<Triangle3d>[] va...
method CodeVector_of_Circle2f_Array (line 6156) | public void CodeVector_of_Circle2f_Array(ref Vector<Circle2f>[] value)
method CodeVector_of_Line2f_Array (line 6163) | public void CodeVector_of_Line2f_Array(ref Vector<Line2f>[] value)
method CodeVector_of_Line3f_Array (line 6170) | public void CodeVector_of_Line3f_Array(ref Vector<Line3f>[] value)
method CodeVector_of_Plane2f_Array (line 6177) | public void CodeVector_of_Plane2f_Array(ref Vector<Plane2f>[] value)
method CodeVector_of_Plane3f_Array (line 6184) | public void CodeVector_of_Plane3f_Array(ref Vector<Plane3f>[] value)
method CodeVector_of_PlaneWithPoint3f_Array (line 6191) | public void CodeVector_of_PlaneWithPoint3f_Array(ref Vector<PlaneWithP...
method CodeVector_of_Quad2f_Array (line 6198) | public void CodeVector_of_Quad2f_Array(ref Vector<Quad2f>[] value)
method CodeVector_of_Quad3f_Array (line 6205) | public void CodeVector_of_Quad3f_Array(ref Vector<Quad3f>[] value)
method CodeVector_of_Ray2f_Array (line 6212) | public void CodeVector_of_Ray2f_Array(ref Vector<Ray2f>[] value)
method CodeVector_of_Ray3f_Array (line 6219) | public void CodeVector_of_Ray3f_Array(ref Vector<Ray3f>[] value)
method CodeVector_of_Sphere3f_Array (line 6226) | public void CodeVector_of_Sphere3f_Array(ref Vector<Sphere3f>[] value)
method CodeVector_of_Triangle2f_Array (line 6233) | public void CodeVector_of_Triangle2f_Array(ref Vector<Triangle2f>[] va...
method CodeVector_of_Triangle3f_Array (line 6240) | public void CodeVector_of_Triangle3f_Array(ref Vector<Triangle3f>[] va...
method CodeMatrix_of_Byte_Array (line 6247) | public void CodeMatrix_of_Byte_Array(ref Matrix<byte>[] value)
method CodeMatrix_of_SByte_Array (line 6254) | public void CodeMatrix_of_SByte_Array(ref Matrix<sbyte>[] value)
method CodeMatrix_of_Short_Array (line 6261) | public void CodeMatrix_of_Short_Array(ref Matrix<short>[] value)
method CodeMatrix_of_UShort_Array (line 6268) | public void CodeMatrix_of_UShort_Array(ref Matrix<ushort>[] value)
method CodeMatrix_of_Int_Array (line 6275) | public void CodeMatrix_of_Int_Array(ref Matrix<int>[] value)
method CodeMatrix_of_UInt_Array (line 6282) | public void CodeMatrix_of_UInt_Array(ref Matrix<uint>[] value)
method CodeMatrix_of_Long_Array (line 6289) | public void CodeMatrix_of_Long_Array(ref Matrix<long>[] value)
method CodeMatrix_of_ULong_Array (line 6296) | public void CodeMatrix_of_ULong_Array(ref Matrix<ulong>[] value)
method CodeMatrix_of_Float_Array (line 6303) | public void CodeMatrix_of_Float_Array(ref Matrix<float>[] value)
method CodeMatrix_of_Double_Array (line 6310) | public void CodeMatrix_of_Double_Array(ref Matrix<double>[] value)
method CodeMatrix_of_Fraction_Array (line 6317) | public void CodeMatrix_of_Fraction_Array(ref Matrix<Fraction>[] value)
method CodeMatrix_of_V2i_Array (line 6324) | public void CodeMatrix_of_V2i_Array(ref Matrix<V2i>[] value)
method CodeMatrix_of_V2l_Array (line 6331) | public void CodeMatrix_of_V2l_Array(ref Matrix<V2l>[] value)
method CodeMatrix_of_V2f_Array (line 6338) | public void CodeMatrix_of_V2f_Array(ref Matrix<V2f>[] value)
method CodeMatrix_of_V2d_Array (line 6345) | public void CodeMatrix_of_V2d_Array(ref Matrix<V2d>[] value)
method CodeMatrix_of_V3i_Array (line 6352) | public void CodeMatrix_of_V3i_Array(ref Matrix<V3i>[] value)
method CodeMatrix_of_V3l_Array (line 6359) | public void CodeMatrix_of_V3l_Array(ref Matrix<V3l>[] value)
method CodeMatrix_of_V3f_Array (line 6366) | public void CodeMatrix_of_V3f_Array(ref Matrix<V3f>[] value)
method CodeMatrix_of_V3d_Array (line 6373) | public void CodeMatrix_of_V3d_Array(ref Matrix<V3d>[] value)
method CodeMatrix_of_V4i_Array (line 6380) | public void CodeMatrix_of_V4i_Array(ref Matrix<V4i>[] value)
method CodeMatrix_of_V4l_Array (line 6387) | public void CodeMatrix_of_V4l_Array(ref Matrix<V4l>[] value)
method CodeMatrix_of_V4f_Array (line 6394) | public void CodeMatrix_of_V4f_Array(ref Matrix<V4f>[] value)
method CodeMatrix_of_V4d_Array (line 6401) | public void CodeMatrix_of_V4d_Array(ref Matrix<V4d>[] value)
method CodeMatrix_of_M22i_Array (line 6408) | public void CodeMatrix_of_M22i_Array(ref Matrix<M22i>[] value)
method CodeMatrix_of_M22l_Array (line 6415) | public void CodeMatrix_of_M22l_Array(ref Matrix<M22l>[] value)
method CodeMatrix_of_M22f_Array (line 6422) | public void CodeMatrix_of_M22f_Array(ref Matrix<M22f>[] value)
method CodeMatrix_of_M22d_Array (line 6429) | public void CodeMatrix_of_M22d_Array(ref Matrix<M22d>[] value)
method CodeMatrix_of_M23i_Array (line 6436) | public void CodeMatrix_of_M23i_Array(ref Matrix<M23i>[] value)
method CodeMatrix_of_M23l_Array (line 6443) | public void CodeMatrix_of_M23l_Array(ref Matrix<M23l>[] value)
method CodeMatrix_of_M23f_Array (line 6450) | public void CodeMatrix_of_M23f_Array(ref Matrix<M23f>[] value)
method CodeMatrix_of_M23d_Array (line 6457) | public void CodeMatrix_of_M23d_Array(ref Matrix<M23d>[] value)
method CodeMatrix_of_M33i_Array (line 6464) | public void CodeMatrix_of_M33i_Array(ref Matrix<M33i>[] value)
method CodeMatrix_of_M33l_Array (line 6471) | public void CodeMatrix_of_M33l_Array(ref Matrix<M33l>[] value)
method CodeMatrix_of_M33f_Array (line 6478) | public void CodeMatrix_of_M33f_Array(ref Matrix<M33f>[] value)
method CodeMatrix_of_M33d_Array (line 6485) | public void CodeMatrix_of_M33d_Array(ref Matrix<M33d>[] value)
method CodeMatrix_of_M34i_Array (line 6492) | public void CodeMatrix_of_M34i_Array(ref Matrix<M34i>[] value)
method CodeMatrix_of_M34l_Array (line 6499) | public void CodeMatrix_of_M34l_Array(ref Matrix<M34l>[] value)
method CodeMatrix_of_M34f_Array (line 6506) | public void CodeMatrix_of_M34f_Array(ref Matrix<M34f>[] value)
method CodeMatrix_of_M34d_Array (line 6513) | public void CodeMatrix_of_M34d_Array(ref Matrix<M34d>[] value)
method CodeMatrix_of_M44i_Array (line 6520) | public void CodeMatrix_of_M44i_Array(ref Matrix<M44i>[] value)
method CodeMatrix_of_M44l_Array (line 6527) | public void CodeMatrix_of_M44l_Array(ref Matrix<M44l>[] value)
method CodeMatrix_of_M44f_Array (line 6534) | public void CodeMatrix_of_M44f_Array(ref Matrix<M44f>[] value)
method CodeMatrix_of_M44d_Array (line 6541) | public void CodeMatrix_of_M44d_Array(ref Matrix<M44d>[] value)
method CodeMatrix_of_C3b_Array (line 6548) | public void CodeMatrix_of_C3b_Array(ref Matrix<C3b>[] value)
method CodeMatrix_of_C3us_Array (line 6555) | public void CodeMatrix_of_C3us_Array(ref Matrix<C3us>[] value)
method CodeMatrix_of_C3ui_Array (line 6562) | public void CodeMatrix_of_C3ui_Array(ref Matrix<C3ui>[] value)
method CodeMatrix_of_C3f_Array (line 6569) | public void CodeMatrix_of_C3f_Array(ref Matrix<C3f>[] value)
method CodeMatrix_of_C3d_Array (line 6576) | public void CodeMatrix_of_C3d_Array(ref Matrix<C3d>[] value)
method CodeMatrix_of_C4b_Array (line 6583) | public void CodeMatrix_of_C4b_Array(ref Matrix<C4b>[] value)
method CodeMatrix_of_C4us_Array (line 6590) | public void CodeMatrix_of_C4us_Array(ref Matrix<C4us>[] value)
method CodeMatrix_of_C4ui_Array (line 6597) | public void CodeMatrix_of_C4ui_Array(ref Matrix<C4ui>[] value)
method CodeMatrix_of_C4f_Array (line 6604) | public void CodeMatrix_of_C4f_Array(ref Matrix<C4f>[] value)
method CodeMatrix_of_C4d_Array (line 6611) | public void CodeMatrix_of_C4d_Array(ref Matrix<C4d>[] value)
method CodeMatrix_of_Range1b_Array (line 6618) | public void CodeMatrix_of_Range1b_Array(ref Matrix<Range1b>[] value)
method CodeMatrix_of_Range1sb_Array (line 6625) | public void CodeMatrix_of_Range1sb_Array(ref Matrix<Range1sb>[] value)
method CodeMatrix_of_Range1s_Array (line 6632) | public void CodeMatrix_of_Range1s_Array(ref Matrix<Range1s>[] value)
method CodeMatrix_of_Range1us_Array (line 6639) | public void CodeMatrix_of_Range1us_Array(ref Matrix<Range1us>[] value)
method CodeMatrix_of_Range1i_Array (line 6646) | public void CodeMatrix_of_Range1i_Array(ref Matrix<Range1i>[] value)
method CodeMatrix_of_Range1ui_Array (line 6653) | public void CodeMatrix_of_Range1ui_Array(ref Matrix<Range1ui>[] value)
method CodeMatrix_of_Range1l_Array (line 6660) | public void CodeMatrix_of_Range1l_Array(ref Matrix<Range1l>[] value)
method CodeMatrix_of_Range1ul_Array (line 6667) | public void CodeMatrix_of_Range1ul_Array(ref Matrix<Range1ul>[] value)
method CodeMatrix_of_Range1f_Array (line 6674) | public void CodeMatrix_of_Range1f_Array(ref Matrix<Range1f>[] value)
method CodeMatrix_of_Range1d_Array (line 6681) | public void CodeMatrix_of_Range1d_Array(ref Matrix<Range1d>[] value)
method CodeMatrix_of_Box2i_Array (line 6688) | public void CodeMatrix_of_Box2i_Array(ref Matrix<Box2i>[] value)
method CodeMatrix_of_Box2l_Array (line 6695) | public void CodeMatrix_of_Box2l_Array(ref Matrix<Box2l>[] value)
method CodeMatrix_of_Box2f_Array (line 6702) | public void CodeMatrix_of_Box2f_Array(ref Matrix<Box2f>[] value)
method CodeMatrix_of_Box2d_Array (line 6709) | public void CodeMatrix_of_Box2d_Array(ref Matrix<Box2d>[] value)
method CodeMatrix_of_Box3i_Array (line 6716) | public void CodeMatrix_of_Box3i_Array(ref Matrix<Box3i>[] value)
method CodeMatrix_of_Box3l_Array (line 6723) | public void CodeMatrix_of_Box3l_Array(ref Matrix<Box3l>[] value)
method CodeMatrix_of_Box3f_Array (line 6730) | public void CodeMatrix_of_Box3f_Array(ref Matrix<Box3f>[] value)
method CodeMatrix_of_Box3d_Array (line 6737) | public void CodeMatrix_of_Box3d_Array(ref Matrix<Box3d>[] value)
method CodeMatrix_of_Euclidean3f_Array (line 6744) | public void CodeMatrix_of_Euclidean3f_Array(ref Matrix<Euclidean3f>[] ...
method CodeMatrix_of_Euclidean3d_Array (line 6751) | public void CodeMatrix_of_Euclidean3d_Array(ref Matrix<Euclidean3d>[] ...
method CodeMatrix_of_Rot2f_Array (line 6758) | public void CodeMatrix_of_Rot2f_Array(ref Matrix<Rot2f>[] value)
method CodeMatrix_of_Rot2d_Array (line 6765) | public void CodeMatrix_of_Rot2d_Array(ref Matrix<Rot2d>[] value)
method CodeMatrix_of_Rot3f_Array (line 6772) | public void CodeMatrix_of_Rot3f_Array(ref Matrix<Rot3f>[] value)
method CodeMatrix_of_Rot3d_Array (line 6779) | public void CodeMatrix_of_Rot3d_Array(ref Matrix<Rot3d>[] value)
method CodeMatrix_of_Scale3f_Array (line 6786) | public void CodeMatrix_of_Scale3f_Array(ref Matrix<Scale3f>[] value)
method CodeMatrix_of_Scale3d_Array (line 6793) | public void CodeMatrix_of_Scale3d_Array(ref Matrix<Scale3d>[] value)
method CodeMatrix_of_Shift3f_Array (line 6800) | public void CodeMatrix_of_Shift3f_Array(ref Matrix<Shift3f>[] value)
method CodeMatrix_of_Shift3d_Array (line 6807) | public void CodeMatrix_of_Shift3d_Array(ref Matrix<Shift3d>[] value)
method CodeMatrix_of_Trafo2f_Array (line 6814) | public void CodeMatrix_of_Trafo2f_Array(ref Matrix<Trafo2f>[] value)
method CodeMatrix_of_Trafo2d_Array (line 6821) | public void CodeMatrix_of_Trafo2d_Array(ref Matrix<Trafo2d>[] value)
method CodeMatrix_of_Trafo3f_Array (line 6828) | public void CodeMatrix_of_Trafo3f_Array(ref Matrix<Trafo3f>[] value)
method CodeMatrix_of_Trafo3d_Array (line 6835) | public void CodeMatrix_of_Trafo3d_Array(ref Matrix<Trafo3d>[] value)
method CodeMatrix_of_Bool_Array (line 6842) | public void CodeMatrix_of_Bool_Array(ref Matrix<bool>[] value)
method CodeMatrix_of_Char_Array (line 6849) | public void CodeMatrix_of_Char_Array(ref Matrix<char>[] value)
method CodeMatrix_of_String_Array (line 6856) | public void CodeMatrix_of_String_Array(ref Matrix<string>[] value)
method CodeMatrix_of_Type_Array (line 6863) | public void CodeMatrix_of_Type_Array(ref Matrix<Type>[] value)
method CodeMatrix_of_Guid_Array (line 6870) | public void CodeMatrix_of_Guid_Array(ref Matrix<Guid>[] value)
method CodeMatrix_of_Symbol_Array (line 6877) | public void CodeMatrix_of_Symbol_Array(ref Matrix<Symbol>[] value)
method CodeMatrix_of_Circle2d_Array (line 6884) | public void CodeMatrix_of_Circle2d_Array(ref Matrix<Circle2d>[] value)
method CodeMatrix_of_Line2d_Array (line 6891) | public void CodeMatrix_of_Line2d_Array(ref Matrix<Line2d>[] value)
method CodeMatrix_of_Line3d_Array (line 6898) | public void CodeMatrix_of_Line3d_Array(ref Matrix<Line3d>[] value)
method CodeMatrix_of_Plane2d_Array (line 6905) | public void CodeMatrix_of_Plane2d_Array(ref Matrix<Plane2d>[] value)
method CodeMatrix_of_Plane3d_Array (line 6912) | public void CodeMatrix_of_Plane3d_Array(ref Matrix<Plane3d>[] value)
method CodeMatrix_of_PlaneWithPoint3d_Array (line 6919) | public void CodeMatrix_of_PlaneWithPoint3d_Array(ref Matrix<PlaneWithP...
method CodeMatrix_of_Quad2d_Array (line 6926) | public void CodeMatrix_of_Quad2d_Array(ref Matrix<Quad2d>[] value)
method CodeMatrix_of_Quad3d_Array (line 6933) | public void CodeMatrix_of_Quad3d_Array(ref Matrix<Quad3d>[] value)
method CodeMatrix_of_Ray2d_Array (line 6940) | public void CodeMatrix_of_Ray2d_Array(ref Matrix<Ray2d>[] value)
method CodeMatrix_of_Ray3d_Array (line 6947) | public void CodeMatrix_of_Ray3d_Array(ref Matrix<Ray3d>[] value)
method CodeMatrix_of_Sphere3d_Array (line 6954) | public void CodeMatrix_of_Sphere3d_Array(ref Matrix<Sphere3d>[] value)
method CodeMatrix_of_Triangle2d_Array (line 6961) | public void CodeMatrix_of_Triangle2d_Array(ref Matrix<Triangle2d>[] va...
method CodeMatrix_of_Triangle3d_Array (line 6968) | public void CodeMatrix_of_Triangle3d_Array(ref Matrix<Triangle3d>[] va...
method CodeMatrix_of_Circle2f_Array (line 6975) | public void CodeMatrix_of_Circle2f_Array(ref Matrix<Circle2f>[] value)
method CodeMatrix_of_Line2f_Array (line 6982) | public void CodeMatrix_of_Line2f_Array(ref Matrix<Line2f>[] value)
method CodeMatrix_of_Line3f_Array (line 6989) | public void CodeMatrix_of_Line3f_Array(ref Matrix<Line3f>[] value)
method CodeMatrix_of_Plane2f_Array (line 6996) | public void CodeMatrix_of_Plane2f_Array(ref Matrix<Plane2f>[] value)
method CodeMatrix_of_Plane3f_Array (line 7003) | public void CodeMatrix_of_Plane3f_Array(ref Matrix<Plane3f>[] value)
method CodeMatrix_of_PlaneWithPoint3f_Array (line 7010) | public void CodeMatrix_of_PlaneWithPoint3f_Array(ref Matrix<PlaneWithP...
method CodeMatrix_of_Quad2f_Array (line 7017) | public void CodeMatrix_of_Quad2f_Array(ref Matrix<Quad2f>[] value)
method CodeMatrix_of_Quad3f_Array (line 7024) | public void CodeMatrix_of_Quad3f_Array(ref Matrix<Quad3f>[] value)
method CodeMatrix_of_Ray2f_Array (line 7031) | public void CodeMatrix_of_Ray2f_Array(ref Matrix<Ray2f>[] value)
method CodeMatrix_of_Ray3f_Array (line 7038) | public void CodeMatrix_of_Ray3f_Array(ref Matrix<Ray3f>[] value)
method CodeMatrix_of_Sphere3f_Array (line 7045) | public void CodeMatrix_of_Sphere3f_Array(ref Matrix<Sphere3f>[] value)
method CodeMatrix_of_Triangle2f_Array (line 7052) | public void CodeMatrix_of_Triangle2f_Array(ref Matrix<Triangle2f>[] va...
method CodeMatrix_of_Triangle3f_Array (line 7059) | public void CodeMatrix_of_Triangle3f_Array(ref Matrix<Triangle3f>[] va...
method CodeVolume_of_Byte_Array (line 7066) | public void CodeVolume_of_Byte_Array(ref Volume<byte>[] value)
method CodeVolume_of_SByte_Array (line 7073) | public void CodeVolume_of_SByte_Array(ref Volume<sbyte>[] value)
method CodeVolume_of_Short_Array (line 7080) | public void CodeVolume_of_Short_Array(ref Volume<short>[] value)
method CodeVolume_of_UShort_Array (line 7087) | public void CodeVolume_of_UShort_Array(ref Volume<ushort>[] value)
method CodeVolume_of_Int_Array (line 7094) | public void CodeVolume_of_Int_Array(ref Volume<int>[] value)
method CodeVolume_of_UInt_Array (line 7101) | public void CodeVolume_of_UInt_Array(ref Volume<uint>[] value)
method CodeVolume_of_Long_Array (line 7108) | public void CodeVolume_of_Long_Array(ref Volume<long>[] value)
method CodeVolume_of_ULong_Array (line 7115) | public void CodeVolume_of_ULong_Array(ref Volume<ulong>[] value)
method CodeVolume_of_Float_Array (line 7122) | public void CodeVolume_of_Float_Array(ref Volume<float>[] value)
method CodeVolume_of_Double_Array (line 7129) | public void CodeVolume_of_Double_Array(ref Volume<double>[] value)
method CodeVolume_of_Fraction_Array (line 7136) | public void CodeVolume_of_Fraction_Array(ref Volume<Fraction>[] value)
method CodeVolume_of_V2i_Array (line 7143) | public void CodeVolume_of_V2i_Array(ref Volume<V2i>[] value)
method CodeVolume_of_V2l_Array (line 7150) | public void CodeVolume_of_V2l_Array(ref Volume<V2l>[] value)
method CodeVolume_of_V2f_Array (line 7157) | public void CodeVolume_of_V2f_Array(ref Volume<V2f>[] value)
method CodeVolume_of_V2d_Array (line 7164) | public void CodeVolume_of_V2d_Array(ref Volume<V2d>[] value)
method CodeVolume_of_V3i_Array (line 7171) | public void CodeVolume_of_V3i_Array(ref Volume<V3i>[] value)
method CodeVolume_of_V3l_Array (line 7178) | public void CodeVolume_of_V3l_Array(ref Volume<V3l>[] value)
method CodeVolume_of_V3f_Array (line 7185) | public void CodeVolume_of_V3f_Array(ref Volume<V3f>[] value)
method CodeVolume_of_V3d_Array (line 7192) | public void CodeVolume_of_V3d_Array(ref Volume<V3d>[] value)
method CodeVolume_of_V4i_Array (line 7199) | public void CodeVolume_of_V4i_Array(ref Volume<V4i>[] value)
method CodeVolume_of_V4l_Array (line 7206) | public void CodeVolume_of_V4l_Array(ref Volume<V4l>[] value)
method CodeVolume_of_V4f_Array (line 7213) | public void CodeVolume_of_V4f_Array(ref Volume<V4f>[] value)
method CodeVolume_of_V4d_Array (line 7220) | public void CodeVolume_of_V4d_Array(ref Volume<V4d>[] value)
method CodeVolume_of_M22i_Array (line 7227) | public void CodeVolume_of_M22i_Array(ref Volume<M22i>[] value)
method CodeVolume_of_M22l_Array (line 7234) | public void CodeVolume_of_M22l_Array(ref Volume<M22l>[] value)
method CodeVolume_of_M22f_Array (line 7241) | public void CodeVolume_of_M22f_Array(ref Volume<M22f>[] value)
method CodeVolume_of_M22d_Array (line 7248) | public void CodeVolume_of_M22d_Array(ref Volume<M22d>[] value)
method CodeVolume_of_M23i_Array (line 7255) | public void CodeVolume_of_M23i_Array(ref Volume<M23i>[] value)
method CodeVolume_of_M23l_Array (line 7262) | public void CodeVolume_of_M23l_Array(ref Volume<M23l>[] value)
method CodeVolume_of_M23f_Array (line 7269) | public void CodeVolume_of_M23f_Array(ref Volume<M23f>[] value)
method CodeVolume_of_M23d_Array (line 7276) | public void CodeVolume_of_M23d_Array(ref Volume<M23d>[] value)
method CodeVolume_of_M33i_Array (line 7283) | public void CodeVolume_of_M33i_Array(ref Volume<M33i>[] value)
method CodeVolume_of_M33l_Array (line 7290) | public void CodeVolume_of_M33l_Array(ref Volume<M33l>[] value)
method CodeVolume_of_M33f_Array (line 7297) | public void CodeVolume_of_M33f_Array(ref Volume<M33f>[] value)
method CodeVolume_of_M33d_Array (line 7304) | public void CodeVolume_of_M33d_Array(ref Volume<M33d>[] value)
method CodeVolume_of_M34i_Array (line 7311) | public void CodeVolume_of_M34i_Array(ref Volume<M34i>[] value)
method CodeVolume_of_M34l_Array (line 7318) | public void CodeVolume_of_M34l_Array(ref Volume<M34l>[] value)
method CodeVolume_of_M34f_Array (line 7325) | public void CodeVolume_of_M34f_Array(ref Volume<M34f>[] value)
method CodeVolume_of_M34d_Array (line 7332) | public void CodeVolume_of_M34d_Array(ref Volume<M34d>[] value)
method CodeVolume_of_M44i_Array (line 7339) | public void CodeVolume_of_M44i_Array(ref Volume<M44i>[] value)
method CodeVolume_of_M44l_Array (line 7346) | public void CodeVolume_of_M44l_Array(ref Volume<M44l>[] value)
method CodeVolume_of_M44f_Array (line 7353) | public void CodeVolume_of_M44f_Array(ref Volume<M44f>[] value)
method CodeVolume_of_M44d_Array (line 7360) | public void CodeVolume_of_M44d_Array(ref Volume<M44d>[] value)
method CodeVolume_of_C3b_Array (line 7367) | public void CodeVolume_of_C3b_Array(ref Volume<C3b>[] value)
method CodeVolume_of_C3us_Array (line 7374) | public void CodeVolume_of_C3us_Array(ref Volume<C3us>[] value)
method CodeVolume_of_C3ui_Array (line 7381) | public void CodeVolume_of_C3ui_Array(ref Volume<C3ui>[] value)
method CodeVolume_of_C3f_Array (line 7388) | public void CodeVolume_of_C3f_Array(ref Volume<C3f>[] value)
method CodeVolume_of_C3d_Array (line 7395) | public void CodeVolume_of_C3d_Array(ref Volume<C3d>[] value)
method CodeVolume_of_C4b_Array (line 7402) | public void CodeVolume_of_C4b_Array(ref Volume<C4b>[] value)
method CodeVolume_of_C4us_Array (line 7409) | public void CodeVolume_of_C4us_Array(ref Volume<C4us>[] value)
method CodeVolume_of_C4ui_Array (line 7416) | public void CodeVolume_of_C4ui_Array(ref Volume<C4ui>[] value)
method CodeVolume_of_C4f_Array (line 7423) | public void CodeVolume_of_C4f_Array(ref Volume<C4f>[] value)
method CodeVolume_of_C4d_Array (line 7430) | public void CodeVolume_of_C4d_Array(ref Volume<C4d>[] value)
method CodeVolume_of_Range1b_Array (line 7437) | public void CodeVolume_of_Range1b_Array(ref Volume<Range1b>[] value)
method CodeVolume_of_Range1sb_Array (line 7444) | public void CodeVolume_of_Range1sb_Array(ref Volume<Range1sb>[] value)
method CodeVolume_of_Range1s_Array (line 7451) | public void CodeVolume_of_Range1s_Array(ref Volume<Range1s>[] value)
method CodeVolume_of_Range1us_Array (line 7458) | public void CodeVolume_of_Range1us_Array(ref Volume<Range1us>[] value)
method CodeVolume_of_Range1i_Array (line 7465) | public void CodeVolume_of_Range1i_Array(ref Volume<Range1i>[] value)
method CodeVolume_of_Range1ui_Array (line 7472) | public void CodeVolume_of_Range1ui_Array(ref Volume<Range1ui>[] value)
method CodeVolume_of_Range1l_Array (line 7479) | public void CodeVolume_of_Range1l_Array(ref Volume<Range1l>[] value)
method CodeVolume_of_Range1ul_Array (line 7486) | public void CodeVolume_of_Range1ul_Array(ref Volume<Range1ul>[] value)
method CodeVolume_of_Range1f_Array (line 7493) | public void CodeVolume_of_Range1f_Array(ref Volume<Range1f>[] value)
method CodeVolume_of_Range1d_Array (line 7500) | public void CodeVolume_of_Range1d_Array(ref Volume<Range1d>[] value)
method CodeVolume_of_Box2i_Array (line 7507) | public void CodeVolume_of_Box2i_Array(ref Volume<Box2i>[] value)
method CodeVolume_of_Box2l_Array (line 7514) | public void CodeVolume_of_Box2l_Array(ref Volume<Box2l>[] value)
method CodeVolume_of_Box2f_Array (line 7521) | public void CodeVolume_of_Box2f_Array(ref Volume<Box2f>[] value)
method CodeVolume_of_Box2d_Array (line 7528) | public void CodeVolume_of_Box2d_Array(ref Volume<Box2d>[] value)
method CodeVolume_of_Box3i_Array (line 7535) | public void CodeVolume_of_Box3i_Array(ref Volume<Box3i>[] value)
method CodeVolume_of_Box3l_Array (line 7542) | public void CodeVolume_of_Box3l_Array(ref Volume<Box3l>[] value)
method CodeVolume_of_Box3f_Array (line 7549) | public void CodeVolume_of_Box3f_Array(ref Volume<Box3f>[] value)
method CodeVolume_of_Box3d_Array (line 7556) | public void CodeVolume_of_Box3d_Array(ref Volume<Box3d>[] value)
method CodeVolume_of_Euclidean3f_Array (line 7563) | public void CodeVolume_of_Euclidean3f_Array(ref Volume<Euclidean3f>[] ...
method CodeVolume_of_Euclidean3d_Array (line 7570) | public void CodeVolume_of_Euclidean3d_Array(ref Volume<Euclidean3d>[] ...
method CodeVolume_of_Rot2f_Array (line 7577) | public void CodeVolume_of_Rot2f_Array(ref Volume<Rot2f>[] value)
method CodeVolume_of_Rot2d_Array (line 7584) | public void CodeVolume_of_Rot2d_Array(ref Volume<Rot2d>[] value)
method CodeVolume_of_Rot3f_Array (line 7591) | public void CodeVolume_of_Rot3f_Array(ref Volume<Rot3f>[] value)
method CodeVolume_of_Rot3d_Array (line 7598) | public void CodeVolume_of_Rot3d_Array(ref Volume<Rot3d>[] value)
method CodeVolume_of_Scale3f_Array (line 7605) | public void CodeVolume_of_Scale3f_Array(ref Volume<Scale3f>[] value)
method CodeVolume_of_Scale3d_Array (line 7612) | public void CodeVolume_of_Scale3d_Array(ref Volume<Scale3d>[] value)
method CodeVolume_of_Shift3f_Array (line 7619) | public void CodeVolume_of_Shift3f_Array(ref Volume<Shift3f>[] value)
method CodeVolume_of_Shift3d_Array (line 7626) | public void CodeVolume_of_Shift3d_Array(ref Volume<Shift3d>[] value)
method CodeVolume_of_Trafo2f_Array (line 7633) | public void CodeVolume_of_Trafo2f_Array(ref Volume<Trafo2f>[] value)
method CodeVolume_of_Trafo2d_Array (line 7640) | public void CodeVolume_of_Trafo2d_Array(ref Volume<Trafo2d>[] value)
method CodeVolume_of_Trafo3f_Array (line 7647) | public void CodeVolume_of_Trafo3f_Array(ref Volume<Trafo3f>[] value)
method CodeVolume_of_Trafo3d_Array (line 7654) | public void CodeVolume_of_Trafo3d_Array(ref Volume<Trafo3d>[] value)
method CodeVolume_of_Bool_Array (line 7661) | public void CodeVolume_of_Bool_Array(ref Volume<bool>[] value)
method CodeVolume_of_Char_Array (line 7668) | public void CodeVolume_of_Char_Array(ref Volume<char>[] value)
method CodeVolume_of_String_Array (line 7675) | public void CodeVolume_of_String_Array(ref Volume<string>[] value)
method CodeVolume_of_Type_Array (line 7682) | public void CodeVolume_of_Type_Array(ref Volume<Type>[] value)
method CodeVolume_of_Guid_Array (line 7689) | public void CodeVolume_of_Guid_Array(ref Volume<Guid>[] value)
method CodeVolume_of_Symbol_Array (line 7696) | public void CodeVolume_of_Symbol_Array(ref Volume<Symbol>[] value)
method CodeVolume_of_Circle2d_Array (line 7703) | public void CodeVolume_of_Circle2d_Array(ref Volume<Circle2d>[] value)
method CodeVolume_of_Line2d_Array (line 7710) | public void CodeVolume_of_Line2d_Array(ref Volume<Line2d>[] value)
method CodeVolume_of_Line3d_Array (line 7717) | public void CodeVolume_of_Line3d_Array(ref Volume<Line3d>[] value)
method CodeVolume_of_Plane2d_Array (line 7724) | public void CodeVolume_of_Plane2d_Array(ref Volume<Plane2d>[] value)
method CodeVolume_of_Plane3d_Array (line 7731) | public void CodeVolume_of_Plane3d_Array(ref Volume<Plane3d>[] value)
method CodeVolume_of_PlaneWithPoint3d_Array (line 7738) | public void CodeVolume_of_PlaneWithPoint3d_Array(ref Volume<PlaneWithP...
method CodeVolume_of_Quad2d_Array (line 7745) | public void CodeVolume_of_Quad2d_Array(ref Volume<Quad2d>[] value)
method CodeVolume_of_Quad3d_Array (line 7752) | public void CodeVolume_of_Quad3d_Array(ref Volume<Quad3d>[] value)
method CodeVolume_of_Ray2d_Array (line 7759) | public void CodeVolume_of_Ray2d_Array(ref Volume<Ray2d>[] value)
method CodeVolume_of_Ray3d_Array (line 7766) | public void CodeVolume_of_Ray3d_Array(ref Volume<Ray3d>[] value)
method CodeVolume_of_Sphere3d_Array (line 7773) | public void CodeVolume_of_Sphere3d_Array(ref Volume<Sphere3d>[] value)
method CodeVolume_of_Triangle2d_Array (line 7780) | public void CodeVolume_of_Triangle2d_Array(ref Volume<Triangle2d>[] va...
method CodeVolume_of_Triangle3d_Array (line 7787) | public void CodeVolume_of_Triangle3d_Array(ref Volume<Triangle3d>[] va...
method CodeVolume_of_Circle2f_Array (line 7794) | public void CodeVolume_of_Circle2f_Array(ref Volume<Circle2f>[] value)
method CodeVolume_of_Line2f_Array (line 7801) | public void CodeVolume_of_Line2f_Array(ref Volume<Line2f>[] value)
method CodeVolume_of_Line3f_Array (line 7808) | public void CodeVolume_of_Line3f_Array(ref Volume<Line3f>[] value)
method CodeVolume_of_Plane2f_Array (line 7815) | public void CodeVolume_of_Plane2f_Array(ref Volume<Plane2f>[] value)
method CodeVolume_of_Plane3f_Array (line 7822) | public void CodeVolume_of_Plane3f_Array(ref Volume<Plane3f>[] value)
method CodeVolume_of_PlaneWithPoint3f_Array (line 7829) | public void CodeVolume_of_PlaneWithPoint3f_Array(ref Volume<PlaneWithP...
method CodeVolume_of_Quad2f_Array (line 7836) | public void CodeVolume_of_Quad2f_Array(ref Volume<Quad2f>[] value)
method CodeVolume_of_Quad3f_Array (line 7843) | public void CodeVolume_of_Quad3f_Array(ref Volume<Quad3f>[] value)
method CodeVolume_of_Ray2f_Array (line 7850) | public void CodeVolume_of_Ray2f_Array(ref Volume<Ray2f>[] value)
method CodeVolume_of_Ray3f_Array (line 7857) | public void CodeVolume_of_Ray3f_Array(ref Volume<Ray3f>[] value)
method CodeVolume_of_Sphere3f_Array (line 7864) | public void CodeVolume_of_Sphere3f_Array(ref Volume<Sphere3f>[] value)
method CodeVolume_of_Triangle2f_Array (line 7871) | public void CodeVolume_of_Triangle2f_Array(ref Volume<Triangle2f>[] va...
method CodeVolume_of_Triangle3f_Array (line 7878) | public void CodeVolume_of_Triangle3f_Array(ref Volume<Triangle3f>[] va...
method CodeTensor_of_Byte_Array (line 7885) | public void CodeTensor_of_Byte_Array(ref Tensor<byte>[] value)
method CodeTensor_of_SByte_Array (line 7892) | public void CodeTensor_of_SByte_Array(ref Tensor<sbyte>[] value)
method CodeTensor_of_Short_Array (line 7899) | public void CodeTensor_of_Short_Array(ref Tensor<short>[] value)
method CodeTensor_of_UShort_Array (line 7906) | public void CodeTensor_of_UShort_Array(ref Tensor<ushort>[] value)
method CodeTensor_of_Int_Array (line 7913) | public void CodeTensor_of_Int_Array(ref Tensor<int>[] value)
method CodeTensor_of_UInt_Array (line 7920) | public void CodeTensor_of_UInt_Array(ref Tensor<uint>[] value)
method CodeTensor_of_Long_Array (line 7927) | public void CodeTensor_of_Long_Array(ref Tensor<long>[] value)
method CodeTensor_of_ULong_Array (line 7934) | public void CodeTensor_of_ULong_Array(ref Tensor<ulong>[] value)
method CodeTensor_of_Float_Array (line 7941) | public void CodeTensor_of_Float_Array(ref Tensor<float>[] value)
method CodeTensor_of_Double_Array (line 7948) | public void CodeTensor_of_Double_Array(ref Tensor<double>[] value)
method CodeTensor_of_Fraction_Array (line 7955) | public void CodeTensor_of_Fraction_Array(ref Tensor<Fraction>[] value)
method CodeTensor_of_V2i_Array (line 7962) | public void CodeTensor_of_V2i_Array(ref Tensor<V2i>[] value)
method CodeTensor_of_V2l_Array (line 7969) | public void CodeTensor_of_V2l_Array(ref Tensor<V2l>[] value)
method CodeTensor_of_V2f_Array (line 7976) | public void CodeTensor_of_V2f_Array(ref Tensor<V2f>[] value)
method CodeTensor_of_V2d_Array (line 7983) | public void CodeTensor_of_V2d_Array(ref Tensor<V2d>[] value)
method CodeTensor_of_V3i_Array (line 7990) | public void CodeTensor_of_V3i_Array(ref Tensor<V3i>[] value)
method CodeTensor_of_V3l_Array (line 7997) | public void CodeTensor_of_V3l_Array(ref Tensor<V3l>[] value)
method CodeTensor_of_V3f_Array (line 8004) | public void CodeTensor_of_V3f_Array(ref Tensor<V3f>[] value)
method CodeTensor_of_V3d_Array (line 8011) | public void CodeTensor_of_V3d_Array(ref Tensor<V3d>[] value)
method CodeTensor_of_V4i_Array (line 8018) | public void CodeTensor_of_V4i_Array(ref Tensor<V4i>[] value)
method CodeTensor_of_V4l_Array (line 8025) | public void CodeTensor_of_V4l_Array(ref Tensor<V4l>[] value)
method CodeTensor_of_V4f_Array (line 8032) | public void CodeTensor_of_V4f_Array(ref Tensor<V4f>[] value)
method CodeTensor_of_V4d_Array (line 8039) | public void CodeTensor_of_V4d_Array(ref Tensor<V4d>[] value)
method CodeTensor_of_M22i_Array (line 8046) | public void CodeTensor_of_M22i_Array(ref Tensor<M22i>[] value)
method CodeTensor_of_M22l_Array (line 8053) | public void CodeTensor_of_M22l_Array(ref Tensor<M22l>[] value)
method CodeTensor_of_M22f_Array (line 8060) | public void CodeTensor_of_M22f_Array(ref Tensor<M22f>[] value)
method CodeTensor_of_M22d_Array (line 8067) | public void CodeTensor_of_M22d_Array(ref Tensor<M22d>[] value)
method CodeTensor_of_M23i_Array (line 8074) | public void CodeTensor_of_M23i_Array(ref Tensor<M23i>[] value)
method CodeTensor_of_M23l_Array (line 8081) | public void CodeTensor_of_M23l_Array(ref Tensor<M23l>[] value)
method CodeTensor_of_M23f_Array (line 8088) | public void CodeTensor_of_M23f_Array(ref Tensor<M23f>[] value)
method CodeTensor_of_M23d_Array (line 8095) | public void CodeTensor_of_M23d_Array(ref Tensor<M23d>[] value)
method CodeTensor_of_M33i_Array (line 8102) | public void CodeTensor_of_M33i_Array(ref Tensor<M33i>[] value)
method CodeTensor_of_M33l_Array (line 8109) | public void CodeTensor_of_M33l_Array(ref Tensor<M33l>[] value)
method CodeTensor_of_M33f_Array (line 8116) | public void CodeTensor_of_M33f_Array(ref Tensor<M33f>[] value)
method CodeTensor_of_M33d_Array (line 8123) | public void CodeTensor_of_M33d_Array(ref Tensor<M33d>[] value)
method CodeTensor_of_M34i_Array (line 8130) | public void CodeTensor_of_M34i_Array(ref Tensor<M34i>[] value)
method CodeTensor_of_M34l_Array (line 8137) | public void CodeTensor_of_M34l_Array(ref Tensor<M34l>[] value)
method CodeTensor_of_M34f_Array (line 8144) | public void CodeTensor_of_M34f_Array(ref Tensor<M34f>[] value)
method CodeTensor_of_M34d_Array (line 8151) | public void CodeTensor_of_M34d_Array(ref Tensor<M34d>[] value)
method CodeTensor_of_M44i_Array (line 8158) | public void CodeTensor_of_M44i_Array(ref Tensor<M44i>[] value)
method CodeTensor_of_M44l_Array (line 8165) | public void CodeTensor_of_M44l_Array(ref Tensor<M44l>[] value)
method CodeTensor_of_M44f_Array (line 8172) | public void CodeTensor_of_M44f_Array(ref Tensor<M44f>[] value)
method CodeTensor_of_M44d_Array (line 8179) | public void CodeTensor_of_M44d_Array(ref Tensor<M44d>[] value)
method CodeTensor_of_C3b_Array (line 8186) | public void CodeTensor_of_C3b_Array(ref Tensor<C3b>[] value)
method CodeTensor_of_C3us_Array (line 8193) | public void CodeTensor_of_C3us_Array(ref Tensor<C3us>[] value)
method CodeTensor_of_C3ui_Array (line 8200) | public void CodeTensor_of_C3ui_Array(ref Tensor<C3ui>[] value)
method CodeTensor_of_C3f_Array (line 8207) | public void CodeTensor_of_C3f_Array(ref Tensor<C3f>[] value)
method CodeTensor_of_C3d_Array (line 8214) | public void CodeTensor_of_C3d_Array(ref Tensor<C3d>[] value)
method CodeTensor_of_C4b_Array (line 8221) | public void CodeTensor_of_C4b_Array(ref Tensor<C4b>[] value)
method CodeTensor_of_C4us_Array (line 8228) | public void CodeTensor_of_C4us_Array(ref Tensor<C4us>[] value)
method CodeTensor_of_C4ui_Array (line 8235) | public void CodeTensor_of_C4ui_Array(ref Tensor<C4ui>[] value)
method CodeTensor_of_C4f_Array (line 8242) | public void CodeTensor_of_C4f_Array(ref Tensor<C4f>[] value)
method CodeTensor_of_C4d_Array (line 8249) | public void CodeTensor_of_C4d_Array(ref Tensor<C4d>[] value)
method CodeTensor_of_Range1b_Array (line 8256) | public void CodeTensor_of_Range1b_Array(ref Tensor<Range1b>[] value)
method CodeTensor_of_Range1sb_Array (line 8263) | public void CodeTensor_of_Range1sb_Array(ref Tensor<Range1sb>[] value)
method CodeTensor_of_Range1s_Array (line 8270) | public void CodeTensor_of_Range1s_Array(ref Tensor<Range1s>[] value)
method CodeTensor_of_Range1us_Array (line 8277) | public void CodeTensor_of_Range1us_Array(ref Tensor<Range1us>[] value)
method CodeTensor_of_Range1i_Array (line 8284) | public void CodeTensor_of_Range1i_Array(ref Tensor<Range1i>[] value)
method CodeTensor_of_Range1ui_Array (line 8291) | public void CodeTensor_of_Range1ui_Array(ref Tensor<Range1ui>[] value)
method CodeTensor_of_Range1l_Array (line 8298) | public void CodeTensor_of_Range1l_Array(ref Tensor<Range1l>[] value)
method CodeTensor_of_Range1ul_Array (line 8305) | public void CodeTensor_of_Range1ul_Array(ref Tensor<Range1ul>[] value)
method CodeTensor_of_Range1f_Array (line 8312) | public void CodeTensor_of_Range1f_Array(ref Tensor<Range1f>[] value)
method CodeTensor_of_Range1d_Array (line 8319) | public void CodeTensor_of_Range1d_Array(ref Tensor<Range1d>[] value)
method CodeTensor_of_Box2i_Array (line 8326) | public void CodeTensor_of_Box2i_Array(ref Tensor<Box2i>[] value)
method CodeTensor_of_Box2l_Array (line 8333) | public void CodeTensor_of_Box2l_Array(ref Tensor<Box2l>[] value)
method CodeTensor_of_Box2f_Array (line 8340) | public void CodeTensor_of_Box2f_Array(ref Tensor<Box2f>[] value)
method CodeTensor_of_Box2d_Array (line 8347) | public void CodeTensor_of_Box2d_Array(ref Tensor<Box2d>[] value)
method CodeTensor_of_Box3i_Array (line 8354) | public void CodeTensor_of_Box3i_Array(ref Tensor<Box3i>[] value)
method CodeTensor_of_Box3l_Array (line 8361) | public void CodeTensor_of_Box3l_Array(ref Tensor<Box3l>[] value)
method CodeTensor_of_Box3f_Array (line 8368) | public void CodeTensor_of_Box3f_Array(ref Tensor<Box3f>[] value)
method CodeTensor_of_Box3d_Array (line 8375) | public void CodeTensor_of_Box3d_Array(ref Tensor<Box3d>[] value)
method CodeTensor_of_Euclidean3f_Array (line 8382) | public void CodeTensor_of_Euclidean3f_Array(ref Tensor<Euclidean3f>[] ...
method CodeTensor_of_Euclidean3d_Array (line 8389) | public void CodeTensor_of_Euclidean3d_Array(ref Tensor<Euclidean3d>[] ...
method CodeTensor_of_Rot2f_Array (line 8396) | public void CodeTensor_of_Rot2f_Array(ref Tensor<Rot2f>[] value)
method CodeTensor_of_Rot2d_Array (line 8403) | public void CodeTensor_of_Rot2d_Array(ref Tensor<Rot2d>[] value)
method CodeTensor_of_Rot3f_Array (line 8410) | public void CodeTensor_of_Rot3f_Array(ref Tensor<Rot3f>[] value)
method CodeTensor_of_Rot3d_Array (line 8417) | public void CodeTensor_of_Rot3d_Array(ref Tensor<Rot3d>[] value)
method CodeTensor_of_Scale3f_Array (line 8424) | public void CodeTensor_of_Scale3f_Array(ref Tensor<Scale3f>[] value)
method CodeTensor_of_Scale3d_Array (line 8431) | public void CodeTensor_of_Scale3d_Array(ref Tensor<Scale3d>[] value)
method CodeTensor_of_Shift3f_Array (line 8438) | public void CodeTensor_of_Shift3f_Array(ref Tensor<Shift3f>[] value)
method CodeTensor_of_Shift3d_Array (line 8445) | public void CodeTensor_of_Shift3d_Array(ref Tensor<Shift3d>[] value)
method CodeTensor_of_Trafo2f_Array (line 8452) | public void CodeTensor_of_Trafo2f_Array(ref Tensor<Trafo2f>[] value)
method CodeTensor_of_Trafo2d_Array (line 8459) | public void CodeTensor_of_Trafo2d_Array(ref Tensor<Trafo2d>[] value)
method CodeTensor_of_Trafo3f_Array (line 8466) | public void CodeTensor_of_Trafo3f_Array(ref Tensor<Trafo3f>[] value)
method CodeTensor_of_Trafo3d_Array (line 8473) | public void CodeTensor_of_Trafo3d_Array(ref Tensor<Trafo3d>[] value)
method CodeTensor_of_Bool_Array (line 8480) | public void CodeTensor_of_Bool_Array(ref Tensor<bool>[] value)
method CodeTensor_of_Char_Array (line 8487) | public void CodeTensor_of_Char_Array(ref Tensor<char>[] value)
method CodeTensor_of_String_Array (line 8494) | public void CodeTensor_of_String_Array(ref Tensor<string>[] value)
method CodeTensor_of_Type_Array (line 8501) | public void CodeTensor_of_Type_Array(ref Tensor<Type>[] value)
method CodeTensor_of_Guid_Array (line 8508) | public void CodeTensor_of_Guid_Array(ref Tensor<Guid>[] value)
method CodeTensor_of_Symbol_Array (line 8515) | public void CodeTensor_of_Symbol_Array(ref Tensor<Symbol>[] value)
method CodeTensor_of_Circle2d_Array (line 8522) | public void CodeTensor_of_Circle2d_Array(ref Tensor<Circle2d>[] value)
method CodeTensor_of_Line2d_Array (line 8529) | public void CodeTensor_of_Line2d_Array(ref Tensor<Line2d>[] value)
method CodeTensor_of_Line3d_Array (line 8536) | public void CodeTensor_of_Line3d_Array(ref Tensor<Line3d>[] value)
method CodeTensor_of_Plane2d_Array (line 8543) | public void CodeTensor_of_Plane2d_Array(ref Tensor<Plane2d>[] value)
method CodeTensor_of_Plane3d_Array (line 8550) | public void CodeTensor_of_Plane3d_Array(ref Tensor<Plane3d>[] value)
method CodeTensor_of_PlaneWithPoint3d_Array (line 8557) | public void CodeTensor_of_PlaneWithPoint3d_Array(ref Tensor<PlaneWithP...
method CodeTensor_of_Quad2d_Array (line 8564) | public void CodeTensor_of_Quad2d_Array(ref Tensor<Quad2d>[] value)
method CodeTensor_of_Quad3d_Array (line 8571) | public void CodeTensor_of_Quad3d_Array(ref Tensor<Quad3d>[] value)
method CodeTensor_of_Ray2d_Array (line 8578) | public void CodeTensor_of_Ray2d_Array(ref Tensor<Ray2d>[] value)
method CodeTensor_of_Ray3d_Array (line 8585) | public void CodeTensor_of_Ray3d_Array(ref Tensor<Ray3d>[] value)
method CodeTensor_of_Sphere3d_Array (line 8592) | public void CodeTensor_of_Sphere3d_Array(ref Tensor<Sphere3d>[] value)
method CodeTensor_of_Triangle2d_Array (line 8599) | public void CodeTensor_of_Triangle2d_Array(ref Tensor<Triangle2d>[] va...
method CodeTensor_of_Triangle3d_Array (line 8606) | public void CodeTensor_of_Triangle3d_Array(ref Tensor<Triangle3d>[] va...
method CodeTensor_of_Circle2f_Array (line 8613) | public void CodeTensor_of_Circle2f_Array(ref Tensor<Circle2f>[] value)
method CodeTensor_of_Line2f_Array (line 8620) | public void CodeTensor_of_Line2f_Array(ref Tensor<Line2f>[] value)
method CodeTensor_of_Line3f_Array (line 8627) | public void CodeTensor_of_Line3f_Array(ref Tensor<Line3f>[] value)
method CodeTensor_of_Plane2f_Array (line 8634) | public void CodeTensor_of_Plane2f_Array(ref Tensor<Plane2f>[] value)
method CodeTensor_of_Plane3f_Array (line 8641) | public void CodeTensor_of_Plane3f_Array(ref Tensor<Plane3f>[] value)
method CodeTensor_of_PlaneWithPoint3f_Array (line 8648) | public void CodeTensor_of_PlaneWithPoint3f_Array(ref Tensor<PlaneWithP...
method CodeTensor_of_Quad2f_Array (line 8655) | public void CodeTensor_of_Quad2f_Array(ref Tensor<Quad2f>[] value)
method CodeTensor_of_Quad3f_Array (line 8662) | public void CodeTensor_of_Quad3f_Array(ref Tensor<Quad3f>[] value)
method CodeTensor_of_Ray2f_Array (line 8669) | public void CodeTensor_of_Ray2f_Array(ref Tensor<Ray2f>[] value)
method CodeTensor_of_Ray3f_Array (line 8676) | public void CodeTensor_of_Ray3f_Array(ref Tensor<Ray3f>[] value)
method CodeTensor_of_Sphere3f_Array (line 8683) | public void CodeTensor_of_Sphere3f_Array(ref Tensor<Sphere3f>[] value)
method CodeTensor_of_Triangle2f_Array (line 8690) | public void CodeTensor_of_Triangle2f_Array(ref Tensor<Triangle2f>[] va...
method CodeTensor_of_Triangle3f_Array (line 8697) | public void CodeTensor_of_Triangle3f_Array(ref Tensor<Triangle3f>[] va...
method CodeByteArray2d (line 8708) | public void CodeByteArray2d(ref byte[,] value)
method CodeByteArray3d (line 8716) | public void CodeByteArray3d(ref byte[, ,] value)
method CodeSByteArray2d (line 8725) | public void CodeSByteArray2d(ref sbyte[,] value)
method CodeSByteArray3d (line 8733) | public void CodeSByteArray3d(ref sbyte[, ,] value)
method CodeShortArray2d (line 8742) | public void CodeShortArray2d(ref short[,] value)
method CodeShortArray3d (line 8750) | public void CodeShortArray3d(ref short[, ,] value)
method CodeUShortArray2d (line 8759) | public void CodeUShortArray2d(ref ushort[,] value)
method CodeUShortArray3d (line 8767) | public void CodeUShortArray3d(ref ushort[, ,] value)
method CodeIntArray2d (line 8776) | public void CodeIntArray2d(ref int[,] value)
method CodeIntArray3d (line 8784) | public void CodeIntArray3d(ref int[, ,] value)
method CodeUIntArray2d (line 8793) | public void CodeUIntArray2d(ref uint[,] value)
method CodeUIntArray3d (line 8801) | public void CodeUIntArray3d(ref uint[, ,] value)
method CodeLongArray2d (line 8810) | public void CodeLongArray2d(ref long[,] value)
method CodeLongArray3d (line 8818) | public void CodeLongArray3d(ref long[, ,] value)
method CodeULongArray2d (line 8827) | public void CodeULongArray2d(ref ulong[,] value)
method CodeULongArray3d (line 8835) | public void CodeULongArray3d(ref ulong[, ,] value)
method CodeFloatArray2d (line 8844) | public void CodeFloatArray2d(ref float[,] value)
method CodeFloatArray3d (line 8852) | public void CodeFloatArray3d(ref float[, ,] value)
method CodeDoubleArray2d (line 8861) | public void CodeDoubleArray2d(ref double[,] value)
method CodeDoubleArray3d (line 8869) | public void CodeDoubleArray3d(ref double[, ,] value)
method CodeFractionArray2d (line 8878) | public void CodeFractionArray2d(ref Fraction[,] value)
method CodeFractionArray3d (line 8886) | public void CodeFractionArray3d(ref Fraction[, ,] value)
method CodeV2iArray2d (line 8895) | public void CodeV2iArray2d(ref V2i[,] value)
method CodeV2iArray3d (line 8903) | public void CodeV2iArray3d(ref V2i[, ,] value)
method CodeV2lArray2d (line 8912) | public void CodeV2lArray2d(ref V2l[,] value)
method CodeV2lArray3d (line 8920) | public void CodeV2lArray3d(ref V2l[, ,] value)
method CodeV2fArray2d (line 8929) | public void CodeV2fArray2d(ref V2f[,] value)
method CodeV2fArray3d (line 8937) | public void CodeV2fArray3d(ref V2f[, ,] value)
method CodeV2dArray2d (line 8946) | public void CodeV2dArray2d(ref V2d[,] value)
method CodeV2dArray3d (line 8954) | public void CodeV2dArray3d(ref V2d[, ,] value)
method CodeV3iArray2d (line 8963) | public void CodeV3iArray2d(ref V3i[,] value)
method CodeV3iArray3d (line 8971) | public void CodeV3iArray3d(ref V3i[, ,] value)
method CodeV3lArray2d (line 8980) | public void CodeV3lArray2d(ref V3l[,] value)
method CodeV3lArray3d (line 8988) | public void CodeV3lArray3d(ref V3l[, ,] value)
method CodeV3fArray2d (line 8997) | public void CodeV3fArray2d(ref V3f[,] value)
method CodeV3fArray3d (line 9005) | public void CodeV3fArray3d(ref V3f[, ,] value)
method CodeV3dArray2d (line 9014) | public void CodeV3dArray2d(ref V3d[,] value)
method CodeV3dArray3d (line 9022) | public void CodeV3dArray3d(ref V3d[, ,] value)
method CodeV4iArray2d (line 9031) | public void CodeV4iArray2d(ref V4i[,] value)
method CodeV4iArray3d (line 9039) | public void CodeV4iArray3d(ref V4i[, ,] value)
method CodeV4lArray2d (line 9048) | public void CodeV4lArray2d(ref V4l[,] value)
method CodeV4lArray3d (line 9056) | public void CodeV4lArray3d(ref V4l[, ,] value)
method CodeV4fArray2d (line 9065) | public void CodeV4fArray2d(ref V4f[,] value)
method CodeV4fArray3d (line 9073) | public void CodeV4fArray3d(ref V4f[, ,] value)
method CodeV4dArray2d (line 9082) | public void CodeV4dArray2d(ref V4d[,] value)
method CodeV4dArray3d (line 9090) | public void CodeV4dArray3d(ref V4d[, ,] value)
method CodeM22iArray2d (line 9099) | public void CodeM22iArray2d(ref M22i[,] value)
method CodeM22iArray3d (line 9107) | public void CodeM22iArray3d(ref M22i[, ,] value)
method CodeM22lArray2d (line 9116) | public void CodeM22lArray2d(ref M22l[,] value)
method CodeM22lArray3d (line 9124) | public void CodeM22lArray3d(ref M22l[, ,] value)
method CodeM22fArray2d (line 9133) | public void CodeM22fArray2d(ref M22f[,] value)
method CodeM22fArray3d (line 9141) | public void CodeM22fArray3d(ref M22f[, ,] value)
method CodeM22dArray2d (line 9150) | public void CodeM22dArray2d(ref M22d[,] value)
method CodeM22dArray3d (line 9158) | public void CodeM22dArray3d(ref M22d[, ,] value)
method CodeM23iArray2d (line 9167) | public void CodeM23iArray2d(ref M23i[,] value)
method CodeM23iArray3d (line 9175) | public void CodeM23iArray3d(ref M23i[, ,] value)
method CodeM23lArray2d (line 9184) | public void CodeM23lArray2d(ref M23l[,] value)
method CodeM23lArray3d (line 9192) | public void CodeM23lArray3d(ref M23l[, ,] value)
method CodeM23fArray2d (line 9201) | public void CodeM23fArray2d(ref M23f[,] value)
method CodeM23fArray3d (line 9209) | public void CodeM23fArray3d(ref M23f[, ,] value)
method CodeM23dArray2d (line 9218) | public void CodeM23dArray2d(ref M23d[,] value)
method CodeM23dArray3d (line 9226) | public void CodeM23dArray3d(ref M23d[, ,] value)
method CodeM33iArray2d (line 9235) | public void CodeM33iArray2d(ref M33i[,] value)
method CodeM33iArray3d (line 9243) | public void CodeM33iArray3d(ref M33i[, ,] value)
method CodeM33lArray2d (line 9252) | public void CodeM33lArray2d(ref M33l[,] value)
method CodeM33lArray3d (line 9260) | public void CodeM33lArray3d(ref M33l[, ,] value)
method CodeM33fArray2d (line 9269) | public void CodeM33fArray2d(ref M33f[,] value)
method CodeM33fArray3d (line 9277) | public void CodeM33fArray3d(ref M33f[, ,] value)
method CodeM33dArray2d (line 9286) | public void CodeM33dArray2d(ref M33d[,] value)
method CodeM33dArray3d (line 9294) | public void CodeM33dArray3d(ref M33d[, ,] value)
method CodeM34iArray2d (line 9303) | public void CodeM34iArray2d(ref M34i[,] value)
method CodeM34iArray3d (line 9311) | public void CodeM34iArray3d(ref M34i[, ,] value)
method CodeM34lArray2d (line 9320) | public void CodeM34lArray2d(ref M34l[,] value)
method CodeM34lArray3d (line 9328) | public void CodeM34lArray3d(ref M34l[, ,] value)
method CodeM34fArray2d (line 9337) | public void CodeM34fArray2d(ref M34f[,] value)
method CodeM34fArray3d (line 9345) | public void CodeM34fArray3d(ref M34f[, ,] value)
method CodeM34dArray2d (line 9354) | public void CodeM34dArray2d(ref M34d[,] value)
method CodeM34dArray3d (line 9362) | public void CodeM34dArray3d(ref M34d[, ,] value)
method CodeM44iArray2d (line 9371) | public void CodeM44iArray2d(ref M44i[,] value)
method CodeM44iArray3d (line 9379) | public void CodeM44iArray3d(ref M44i[, ,] value)
method CodeM44lArray2d (line 9388) | public void CodeM44lArray2d(ref M44l[,] value)
method CodeM44lArray3d (line 9396) | public void CodeM44lArray3d(ref M44l[, ,] value)
method CodeM44fArray2d (line 9405) | public void CodeM44fArray2d(ref M44f[,] value)
method CodeM44fArray3d (line 9413) | public void CodeM44fArray3d(ref M44f[, ,] value)
method CodeM44dArray2d (line 9422) | public void CodeM44dArray2d(ref M44d[,] value)
method CodeM44dArray3d (line 9430) | public void CodeM44dArray3d(ref M44d[, ,] value)
method CodeC3bArray2d (line 9439) | public void CodeC3bArray2d(ref C3b[,] value)
method CodeC3bArray3d (line 9447) | public void CodeC3bArray3d(ref C3b[, ,] value)
method CodeC3usArray2d (line 9456) | public void CodeC3usArray2d(ref C3us[,] value)
method CodeC3usArray3d (line 9464) | public void CodeC3usArray3d(ref C3us[, ,] value)
method CodeC3uiArray2d (line 9473) | public void CodeC3uiArray2d(ref C3ui[,] value)
method CodeC3uiArray3d (line 9481) | public void CodeC3uiArray3d(ref C3ui[, ,] value)
method CodeC3fArray2d (line 9490) | public void CodeC3fArray2d(ref C3f[,] value)
method CodeC3fArray3d (line 9498) | public void CodeC3fArray3d(ref C3f[, ,] value)
method CodeC3dArray2d (line 9507) | public void CodeC3dArray2d(ref C3d[,] value)
method CodeC3dArray3d (line 9515) | public void CodeC3dArray3d(ref C3d[, ,] value)
method CodeC4bArray2d (line 9524) | public void CodeC4bArray2d(ref C4b[,] value)
method CodeC4bArray3d (line 9532) | public void CodeC4bArray3d(ref C4b[, ,] value)
method CodeC4usArray2d (line 9541) | public void CodeC4usArray2d(ref C4us[,] value)
method CodeC4usArray3d (line 9549) | public void CodeC4usArray3d(ref C4us[, ,] value)
method CodeC4uiArray2d (line 9558) | public void CodeC4uiArray2d(ref C4ui[,] value)
method CodeC4uiArray3d (line 9566) | public void CodeC4uiArray3d(ref C4ui[, ,] value)
method CodeC4fArray2d (line 9575) | public void CodeC4fArray2d(ref C4f[,] value)
method CodeC4fArray3d (line 9583) | public void CodeC4fArray3d(ref C4f[, ,] value)
method CodeC4dArray2d (line 9592) | public void CodeC4dArray2d(ref C4d[,] value)
method CodeC4dArray3d (line 9600) | public void CodeC4dArray3d(ref C4d[, ,] value)
method CodeRange1bArray2d (line 9609) | public void CodeRange1bArray2d(ref Range1b[,] value)
method CodeRange1bArray3d (line 9617) | public void CodeRange1bArray3d(ref Range1b[, ,] value)
method CodeRange1sbArray2d (line 9626) | public void CodeRange1sbArray2d(ref Range1sb[,] value)
method CodeRange1sbArray3d (line 9634) | public void CodeRange1sbArray3d(ref Range1sb[, ,] value)
method CodeRange1sArray2d (line 9643) | public void CodeRange1sArray2d(ref Range1s[,] value)
method CodeRange1sArray3d (line 9651) | public void CodeRange1sArray3d(ref Range1s[, ,] value)
method CodeRange1usArray2d (line 9660) | public void CodeRange1usArray2d(ref Range1us[,] value)
method CodeRange1usArray3d (line 9668) | public void CodeRange1usArray3d(ref Range1us[, ,] value)
method CodeRange1iArray2d (line 9677) | public void CodeRange1iArray2d(ref Range1i[,] value)
method CodeRange1iArray3d (line 9685) | public void CodeRange1iArray3d(ref Range1i[, ,] value)
method CodeRange1uiArray2d (line 9694) | public void CodeRange1uiArray2d(ref Range1ui[,] value)
method CodeRange1uiArray3d (line 9702) | public void CodeRange1uiArray3d(ref Range1ui[, ,] value)
method CodeRange1lArray2d (line 9711) | public void CodeRange1lArray2d(ref Range1l[,] value)
method CodeRange1lArray3d (line 9719) | public void CodeRange1lArray3d(ref Range1l[, ,] value)
method CodeRange1ulArray2d (line 9728) | public void CodeRange1ulArray2d(ref Range1ul[,] value)
method CodeRange1ulArray3d (line 9736) | public void CodeRange1ulArray3d(ref Range1ul[, ,] value)
method CodeRange1fArray2d (line 9745) | public void CodeRange1fArray2d(ref Range1f[,] value)
method CodeRange1fArray3d (line 9753) | public void CodeRange1fArray3d(ref Range1f[, ,] value)
method CodeRange1dArray2d (line 9762) | public void CodeRange1dArray2d(ref Range1d[,] value)
method CodeRange1dArray3d (line 9770) | public void CodeRange1dArray3d(ref Range1d[, ,] value)
method CodeBox2iArray2d (line 9779) | public void CodeBox2iArray2d(ref Box2i[,] value)
method CodeBox2iArray3d (line 9787) | public void CodeBox2iArray3d(ref Box2i[, ,] value)
method CodeBox2lArray2d (line 9796) | public void CodeBox2lArray2d(ref Box2l[,] value)
method CodeBox2lArray3d (line 9804) | public void CodeBox2lArray3d(ref Box2l[, ,] value)
method CodeBox2fArray2d (line 9813) | public void CodeBox2fArray2d(ref Box2f[,] value)
method CodeBox2fArray3d (line 9821) | public void CodeBox2fArray3d(ref Box2f[, ,] value)
method CodeBox2dArray2d (line 9830) | public void CodeBox2dArray2d(ref Box2d[,] value)
method CodeBox2dArray3d (line 9838) | public void CodeBox2dArray3d(ref Box2d[, ,] value)
method CodeBox3iArray2d (line 9847) | public void CodeBox3iArray2d(ref Box3i[,] value)
method CodeBox3iArray3d (line 9855) | public void CodeBox3iArray3d(ref Box3i[, ,] value)
method CodeBox3lArray2d (line 9864) | public void CodeBox3lArray2d(ref Box3l[,] value)
method CodeBox3lArray3d (line 9872) | public void CodeBox3lArray3d(ref Box3l[, ,] value)
method CodeBox3fArray2d (line 9881) | public void CodeBox3fArray2d(ref Box3f[,] value)
method CodeBox3fArray3d (line 9889) | public void CodeBox3fArray3d(ref Box3f[, ,] value)
method CodeBox3dArray2d (line 9898) | public void CodeBox3dArray2d(ref Box3d[,] value)
method CodeBox3dArray3d (line 9906) | public void CodeBox3dArray3d(ref Box3d[, ,] value)
method CodeEuclidean3fArray2d (line 9915) | public void CodeEuclidean3fArray2d(ref Euclidean3f[,] value)
method CodeEuclidean3fArray3d (line 9923) | public void CodeEuclidean3fArray3d(ref Euclidean3f[, ,] value)
method CodeEuclidean3dArray2d (line 9932) | public void CodeEuclidean3dArray2d(ref Euclidean3d[,] value)
method CodeEuclidean3dArray3d (line 9940) | public void CodeEuclidean3dArray3d(ref Euclidean3d[, ,] value)
method CodeRot2fArray2d (line 9949) | public void CodeRot2fArray2d(ref Rot2f[,] value)
method CodeRot2fArray3d (line 9957) | public void CodeRot2fArray3d(ref Rot2f[, ,] value)
method CodeRot2dArray2d (line 9966) | public void CodeRot2dArray2d(ref Rot2d[,] value)
method CodeRot2dArray3d (line 9974) | public void CodeRot2dArray3d(ref Rot2d[, ,] value)
method CodeRot3fArray2d (line 9983) | public void CodeRot3fArray2d(ref Rot3f[,] value)
method CodeRot3fArray3d (line 9991) | public void CodeRot3fArray3d(ref Rot3f[, ,] value)
method CodeRot3dArray2d (line 10000) | public void CodeRot3dArray2d(ref Rot3d[,] value)
method CodeRot3dArray3d (line 10008) | public void CodeRot3dArray3d(ref Rot3d[, ,] value)
method CodeScale3fArray2d (line 10017) | public void CodeScale3fArray2d(ref Scale3f[,] value)
method CodeScale3fArray3d (line 10025) | public void CodeScale3fArray3d(ref Scale3f[, ,] value)
method CodeScale3dArray2d (line 10034) | public void CodeScale3dArray2d(ref Scale3d[,] value)
method CodeScale3dArray3d (line 10042) | public void CodeScale3dArray3d(ref Scale3d[, ,] value)
method CodeShift3fArray2d (line 10051) | public void CodeShift3fArray2d(ref Shift3f[,] value)
method CodeShift3fArray3d (line 10059) | public void CodeShift3fArray3d(ref Shift3f[, ,] value)
method CodeShift3dArray2d (line 10068) | public void CodeShift3dArray2d(ref Shift3d[,] value)
method CodeShift3dArray3d (line 10076) | public void CodeShift3dArray3d(ref Shift3d[, ,] value)
method CodeTrafo2fArray2d (line 10085) | public void CodeTrafo2fArray2d(ref Trafo2f[,] value)
method CodeTrafo2fArray3d (line 10093) | public void CodeTrafo2fArray3d(ref Trafo2f[, ,] value)
method CodeTrafo2dArray2d (line 10102) | public void CodeTrafo2dArray2d(ref Trafo2d[,] value)
method CodeTrafo2dArray3d (line 10110) | public void CodeTrafo2dArray3d(ref Trafo2d[, ,] value)
method CodeTrafo3fArray2d (line 10119) | public void CodeTrafo3fArray2d(ref Trafo3f[,] value)
method CodeTrafo3fArray3d (line 10127) | public void CodeTrafo3fArray3d(ref Trafo3f[, ,] value)
method CodeTrafo3dArray2d (line 10136) | public void CodeTrafo3dArray2d(ref Trafo3d[,] value)
method CodeTrafo3dArray3d (line 10144) | public void CodeTrafo3dArray3d(ref Trafo3d[, ,] value)
method CodeByteArrayArray (line 10157) | public void CodeByteArrayArray(ref byte[][] value)
method CodeByteArrayArrayArray (line 10164) | public void CodeByteArrayArrayArray(ref byte[][][] value)
method CodeSByteArrayArray (line 10171) | public void CodeSByteArrayArray(ref sbyte[][] value)
method CodeSByteArrayArrayArray (line 10178) | public void CodeSByteArrayArrayArray(ref sbyte[][][] value)
method CodeShortArrayArray (line 10185) | public void CodeShortArrayArray(ref short[][] value)
method CodeShortArrayArrayArray (line 10192) | public void CodeShortArrayArrayArray(ref short[][][] value)
method CodeUShortArrayArray (line 10199) | public void CodeUShortArrayArray(ref ushort[][] value)
method CodeUShortArrayArrayArray (line 10206) | public void CodeUShortArrayArrayArray(ref ushort[][][] value)
method CodeIntArrayArray (line 10213) | public void CodeIntArrayArray(ref int[][] value)
method CodeIntArrayArrayArray (line 10220) | public void CodeIntArrayArrayArray(ref int[][][] value)
method CodeUIntArrayArray (line 10227) | public void CodeUIntArrayArray(ref uint[][] value)
method CodeUIntArrayArrayArray (line 10234) | public void CodeUIntArrayArrayArray(ref uint[][][] value)
method CodeLongArrayArray (line 10241) | public void CodeLongArrayArray(ref long[][] value)
method CodeLongArrayArrayArray (line 10248) | public void CodeLongArrayArrayArray(ref long[][][] value)
method CodeULongArrayArray (line 10255) | public void CodeULongArrayArray(ref ulong[][] value)
method CodeULongArrayArrayArray (line 10262) | public void CodeULongArrayArrayArray(ref ulong[][][] value)
method CodeFloatArrayArray (line 10269) | public void CodeFloatArrayArray(ref float[][] value)
method CodeFloatArrayArrayArray (line 10276) | public void CodeFloatArrayArrayArray(ref float[][][] value)
method CodeDoubleArrayArray (line 10283) | public void CodeDoubleArrayArray(ref double[][] value)
method CodeDoubleArrayArrayArray (line 10290) | public void CodeDoubleArrayArrayArray(ref double[][][] value)
method CodeFractionArrayArray (line 10297) | public void CodeFractionArrayArray(ref Fraction[][] value)
method CodeFractionArrayArrayArray (line 10304) | public void CodeFractionArrayArrayArray(ref Fraction[][][] value)
method CodeV2iArrayArray (line 10311) | public void CodeV2iArrayArray(ref V2i[][] value)
method CodeV2iArrayArrayArray (line 10318) | public void CodeV2iArrayArrayArray(ref V2i[][][] value)
method CodeV2lArrayArray (line 10325) | public void CodeV2lArrayArray(ref V2l[][] value)
method CodeV2lArrayArrayArray (line 10332) | public void CodeV2lArrayArrayArray(ref V2l[][][] value)
method CodeV2fArrayArray (line 10339) | public void CodeV2fArrayArray(ref V2f[][] value)
method CodeV2fArrayArrayArray (line 10346) | public void CodeV2fArrayArrayArray(ref V2f[][][] value)
method CodeV2dArrayArray (line 10353) | public void CodeV2dArrayArray(ref V2d[][] value)
method CodeV2dArrayArrayArray (line 10360) | public void CodeV2dArrayArrayArray(ref V2d[][][] value)
method CodeV3iArrayArray (line 10367) | public void CodeV3iArrayArray(ref V3i[][] value)
method CodeV3iArrayArrayArray (line 10374) | public void CodeV3iArrayArrayArray(ref V3i[][][] value)
method CodeV3lArrayArray (line 10381) | public void CodeV3lArrayArray(ref V3l[][] value)
method CodeV3lArrayArrayArray (line 10388) | public void CodeV3lArrayArrayArray(ref V3l[][][] value)
method CodeV3fArrayArray (line 10395) | public void CodeV3fArrayArray(ref V3f[][] value)
method CodeV3fArrayArrayArray (line 10402) | public void CodeV3fArrayArrayArray(ref V3f[][][] value)
method CodeV3dArrayArray (line 10409) | public void CodeV3dArrayArray(ref V3d[][] value)
method CodeV3dArrayArrayArray (line 10416) | public void CodeV3dArrayArrayArray(ref V3d[][][] value)
method CodeV4iArrayArray (line 10423) | public void CodeV4iArrayArray(ref V4i[][] value)
method CodeV4iArrayArrayArray (line 10430) | public void CodeV4iArrayArrayArray(ref V4i[][][] value)
method CodeV4lArrayArray (line 10437) | public void CodeV4lArrayArray(ref V4l[][] value)
method CodeV4lArrayArrayArray (line 10444) | public void CodeV4lArrayArrayArray(ref V4l[][][] value)
method CodeV4fArrayArray (line 10451) | public void CodeV4fArrayArray(ref V4f[][] value)
method CodeV4fArrayArrayArray (line 10458) | public void CodeV4fArrayArrayArray(ref V4f[][][] value)
method CodeV4dArrayArray (line 10465) | public void CodeV4dArrayArray(ref V4d[][] value)
method CodeV4dArrayArrayArray (line 10472) | public void CodeV4dArrayArrayArray(ref V4d[][][] value)
method CodeM22iArrayArray (line 10479) | public void CodeM22iArrayArray(ref M22i[][] value)
method CodeM22iArrayArrayArray (line 10486) | public void CodeM22iArrayArrayArray(ref M22i[][][] value)
method CodeM22lArrayArray (line 10493) | public void CodeM22lArrayArray(ref M22l[][] value)
method CodeM22lArrayArrayArray (line 10500) | public void CodeM22lArrayArrayArray(ref M22l[][][] value)
method CodeM22fArrayArray (line 10507) | public void CodeM22fArrayArray(ref M22f[][] value)
method CodeM22fArrayArrayArray (line 10514) | public void CodeM22fArrayArrayArray(ref M22f[][][] value)
method CodeM22dArrayArray (line 10521) | public void CodeM22dArrayArray(ref M22d[][] value)
method CodeM22dArrayArrayArray (line 10528) | public void CodeM22dArrayArrayArray(ref M22d[][][] value)
method CodeM23iArrayArray (line 10535) | public void CodeM23iArrayArray(ref M23i[][] value)
method CodeM23iArrayArrayArray (line 10542) | public void CodeM23iArrayArrayArray(ref M23i[][][] value)
method CodeM23lArrayArray (line 10549) | public void CodeM23lArrayArray(ref M23l[][] value)
method CodeM23lArrayArrayArray (line 10556) | public void CodeM23lArrayArrayArray(ref M23l[][][] value)
method CodeM23fArrayArray (line 10563) | public void CodeM23fArrayArray(ref M23f[][] value)
method CodeM23fArrayArrayArray (line 10570) | public void CodeM23fArrayArrayArray(ref M23f[][][] value)
method CodeM23dArrayArray (line 10577) | public void CodeM23dArrayArray(ref M23d[][] value)
method CodeM23dArrayArrayArray (line 10584) | public void CodeM23dArrayArrayArray(ref M23d[][][] value)
method CodeM33iArrayArray (line 10591) | public void CodeM33iArrayArray(ref M33i[][] value)
method CodeM33iArrayArrayArray (line 10598) | public void CodeM33iArrayArrayArray(ref M33i[][][] value)
method CodeM33lArrayArray (line 10605) | public void CodeM33lArrayArray(ref M33l[][] value)
method CodeM33lArrayArrayArray (line 10612) | public void CodeM33lArrayArrayArray(ref M33l[][][] value)
method CodeM33fArrayArray (line 10619) | public void CodeM33fArrayArray(ref M33f[][] value)
method CodeM33fArrayArrayArray (line 10626) | public void CodeM33fArrayArrayArray(ref M33f[][][] value)
method CodeM33dArrayArray (line 10633) | public void CodeM33dArrayArray(ref M33d[][] value)
method CodeM33dArrayArrayArray (line 10640) | public void CodeM33dArrayArrayArray(ref M33d[][][] value)
method CodeM34iArrayArray (line 10647) | public void CodeM34iArrayArray(ref M34i[][] value)
method CodeM34iArrayArrayArray (line 10654) | public void CodeM34iArrayArrayArray(ref M34i[][][] value)
method CodeM34lArrayArray (line 10661) | public void CodeM34lArrayArray(ref M34l[][] value)
method CodeM34lArrayArrayArray (line 10668) | public void CodeM34lArrayArrayArray(ref M34l[][][] value)
method CodeM34fArrayArray (line 10675) | public void CodeM34fArrayArray(ref M34f[][] value)
method CodeM34fArrayArrayArray (line 10682) | public void CodeM34fArrayArrayArray(ref M34f[][][] value)
method CodeM34dArrayArray (line 10689) | public void CodeM34dArrayArray(ref M34d[][] value)
method CodeM34dArrayArrayArray (line 10696) | public void CodeM34dArrayArrayArray(ref M34d[][][] value)
method CodeM44iArrayArray (line 10703) | public void CodeM44iArrayArray(ref M44i[][] value)
method CodeM44iArrayArrayArray (line 10710) | public void CodeM44iArrayArrayArray(ref M44i[][][] value)
method CodeM44lArrayArray (line 10717) | public void CodeM44lArrayArray(ref M44l[][] value)
method CodeM44lArrayArrayArray (line 10724) | public void CodeM44lArrayArrayArray(ref M44l[][][] value)
method CodeM44fArrayArray (line 10731) | public void CodeM44fArrayArray(ref M44f[][] value)
method CodeM44fArrayArrayArray (line 10738) | public void CodeM44fArrayArrayArray(ref M44f[][][] value)
method CodeM44dArrayArray (line 10745) | public void CodeM44dArrayArray(ref M44d[][] value)
method CodeM44dArrayArrayArray (line 10752) | public void CodeM44dArrayArrayArray(ref M44d[][][] value)
method CodeC3bArrayArray (line 10759) | public void CodeC3bArrayArray(ref C3b[][] value)
method CodeC3bArrayArrayArray (line 10766) | public void CodeC3bArrayArrayArray(ref C3b[][][] value)
method CodeC3usArrayArray (line 10773) | public void CodeC3usArrayArray(ref C3us[][] value)
method CodeC3usArrayArrayArray (line 10780) | public void CodeC3usArrayArrayArray(ref C3us[][][] value)
method CodeC3uiArrayArray (line 10787) | public void CodeC3uiArrayArray(ref C3ui[][] value)
method CodeC3uiArrayArrayArray (line 10794) | public void CodeC3uiArrayArrayArray(ref C3ui[][][] value)
method CodeC3fArrayArray (line 10801) | public void CodeC3fArrayArray(ref C3f[][] value)
method CodeC3fArrayArrayArray (line 10808) | public void CodeC3fArrayArrayArray(ref C3f[][][] value)
method CodeC3dArrayArray (line 10815) | public void CodeC3dArrayArray(ref C3d[][] value)
method CodeC3dArrayArrayArray (line 10822) | public void CodeC3dArrayArrayArray(ref C3d[][][] value)
method CodeC4bArrayArray (line 10829) | public void CodeC4bArrayArray(ref C4b[][] value)
method CodeC4bArrayArrayArray (line 10836) | public void CodeC4bArrayArrayArray(ref C4b[][][] value)
method CodeC4usArrayArray (line 10843) | public void CodeC4usArrayArray(ref C4us[][] value)
method CodeC4usArrayArrayArray (line 10850) | public void CodeC4usArrayArrayArray(ref C4us[][][] value)
method CodeC4uiArrayArray (line 10857) | public void CodeC4uiArrayArray(ref C4ui[][] value)
method CodeC4uiArrayArrayArray (line 10864) | public void CodeC4uiArrayArrayArray(ref C4ui[][][] value)
method CodeC4fArrayArray (line 10871) | public void CodeC4fArrayArray(ref C4f[][] value)
method CodeC4fArrayArrayArray (line 10878) | public void CodeC4fArrayArrayArray(ref C4f[][][] value)
method CodeC4dArrayArray (line 10885) | public void CodeC4dArrayArray(ref C4d[][] value)
method CodeC4dArrayArrayArray (line 10892) | public void CodeC4dArrayArrayArray(ref C4d[][][] value)
method CodeRange1bArrayArray (line 10899) | public void CodeRange1bArrayArray(ref Range1b[][] value)
method CodeRange1bArrayArrayArray (line 10906) | public void CodeRange1bArrayArrayArray(ref Range1b[][][] value)
method CodeRange1sbArrayArray (line 10913) | public void CodeRange1sbArrayArray(ref Range1sb[][] value)
method CodeRange1sbArrayArrayArray (line 10920) | public void CodeRange1sbArrayArrayArray(ref Range1sb[][][] value)
method CodeRange1sArrayArray (line 10927) | public void CodeRange1sArrayArray(ref Range1s[][] value)
method CodeRange1sArrayArrayArray (line 10934) | public void CodeRange1sArrayArrayArray(ref Range1s[][][] value)
method CodeRange1usArrayArray (line 10941) | public void CodeRange1usArrayArray(ref Range1us[][] value)
method CodeRange1usArrayArrayArray (line 10948) | public void CodeRange1usArrayArrayArray(ref Range1us[][][] value)
method CodeRange1iArrayArray (line 10955) | public void CodeRange1iArrayArray(ref Range1i[][] value)
method CodeRange1iArrayArrayArray (line 10962) | public void CodeRange1iArrayArrayArray(ref Range1i[][][] value)
method CodeRange1uiArrayArray (line 10969) | public void CodeRange1uiArrayArray(ref Range1ui[][] value)
method CodeRange1uiArrayArrayArray (line 10976) | public void CodeRange1uiArrayArrayArray(ref Range1ui[][][] value)
method CodeRange1lArrayArray (line 10983) | public void CodeRange1lArrayArray(ref Range1l[][] value)
method CodeRange1lArrayArrayArray (line 10990) | public void CodeRange1lArrayArrayArray(ref Range1l[][][] value)
method CodeRange1ulArrayArray (line 10997) | public void CodeRange1ulArrayArray(ref Range1ul[][] value)
method CodeRange1ulArrayArrayArray (line 11004) | public void CodeRange1ulArrayArrayArray(ref Range1ul[][][] value)
method CodeRange1fArrayArray (line 11011) | public void CodeRange1fArrayArray(ref Range1f[][] value)
method CodeRange1fArrayArrayArray (line 11018) | public void CodeRange1fArrayArrayArray(ref Range1f[][][] value)
method CodeRange1dArrayArray (line 11025) | public void CodeRange1dArrayArray(ref Range1d[][] value)
method CodeRange1dArrayArrayArray (line 11032) | public void CodeRange1dArrayArrayArray(ref Range1d[][][] value)
method CodeBox2iArrayArray (line 11039) | public void CodeBox2iArrayArray(ref Box2i[][] value)
method CodeBox2iArrayArrayArray (line 11046) | public void CodeBox2iArrayArrayArray(ref Box2i[][][] value)
method CodeBox2lArrayArray (line 11053) | public void CodeBox2lArrayArray(ref Box2l[][] value)
method CodeBox2lArrayArrayArray (line 11060) | public void CodeBox2lArrayArrayArray(ref Box2l[][][] value)
method CodeBox2fArrayArray (line 11067) | public void CodeBox2fArrayArray(ref Box2f[][] value)
method CodeBox2fArrayArrayArray (line 11074) | public void CodeBox2fArrayArrayArray(ref Box2f[][][] value)
method CodeBox2dArrayArray (line 11081) | public void CodeBox2dArrayArray(ref Box2d[][] value)
method CodeBox2dArrayArrayArray (line 11088) | public void CodeBox2dArrayArrayArray(ref Box2d[][][] value)
method CodeBox3iArrayArray (line 11095) | public void CodeBox3iArrayArray(ref Box3i[][] value)
method CodeBox3iArrayArrayArray (line 11102) | public void CodeBox3iArrayArrayArray(ref Box3i[][][] value)
method CodeBox3lArrayArray (line 11109) | public void CodeBox3lArrayArray(ref Box3l[][] value)
method CodeBox3lArrayArrayArray (line 11116) | public void CodeBox3lArrayArrayArray(ref Box3l[][][] value)
method CodeBox3fArrayArray (line 11123) | public void CodeBox3fArrayArray(ref Box3f[][] value)
method CodeBox3fArrayArrayArray (line 11130) | public void CodeBox3fArrayArrayArray(ref Box3f[][][] value)
method CodeBox3dArrayArray (line 11137) | public void CodeBox3dArrayArray(ref Box3d[][] value)
method CodeBox3dArrayArrayArray (line 11144) | public void CodeBox3dArrayArrayArray(ref Box3d[][][] value)
method CodeEuclidean3fArrayArray (line 11151) | public void CodeEuclidean3fArrayArray(ref Euclidean3f[][] value)
method CodeEuclidean3fArrayArrayArray (line 11158) | public void CodeEuclidean3fArrayArrayArray(ref Euclidean3f[][][] value)
method CodeEuclidean3dArrayArray (line 11165) | public void CodeEuclidean3dArrayArray(ref Euclidean3d[][] value)
method CodeEuclidean3dArrayArrayArray (line 11172) | public void CodeEuclidean3dArrayArrayArray(ref Euclidean3d[][][] value)
method CodeRot2fArrayArray (line 11179) | public void CodeRot2fArrayArray(ref Rot2f[][] value)
method CodeRot2fArrayArrayArray (line 11186) | public void CodeRot2fArrayArrayArray(ref Rot2f[][][] value)
method CodeRot2dArrayArray (line 11193) | public void CodeRot2dArrayArray(ref Rot2d[][] value)
method CodeRot2dArrayArrayArray (line 11200) | public void CodeRot2dArrayArrayArray(ref Rot2d[][][] value)
method CodeRot3fArrayArray (line 11207) | public void CodeRot3fArrayArray(ref Rot3f[][] value)
method CodeRot3fArrayArrayArray (line 11214) | public void CodeRot3fArrayArrayArray(ref Rot3f[][][] value)
method CodeRot3dArrayArray (line 11221) | public void CodeRot3dArrayArray(ref Rot3d[][] value)
method CodeRot3dArrayArrayArray (line 11228) | public void CodeRot3dArrayArrayArray(ref Rot3d[][][] value)
method CodeScale3fArrayArray (line 11235) | public void CodeScale3fArray
Copy disabled (too large)
Download .json
Condensed preview — 804 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (44,369K chars).
[
{
"path": ".claude/CLAUDE.md",
"chars": 104,
"preview": "# AI Documentation\n\nRead `ai/README.md` for indexed reference docs on types, algorithms, and utilities.\n"
},
{
"path": ".config/dotnet-tools.json",
"chars": 309,
"preview": "{\n \"version\": 1,\n \"isRoot\": true,\n \"tools\": {\n \"paket\": {\n \"version\": \"10.0.0-alpha011\",\n \"commands\": [\n"
},
{
"path": ".github/workflows/build.yml",
"chars": 1881,
"preview": "name: Build\n\non:\n push:\n paths-ignore:\n - 'README.md'\n - 'docs/**'\n pull_request:\n paths-ignore:\n - 'RE"
},
{
"path": ".github/workflows/docs-check.yml",
"chars": 579,
"preview": "name: Docs Check\n\non:\n push:\n pull_request:\n\njobs:\n docs-check:\n runs-on: ${{ matrix.os }}\n strategy:\n fai"
},
{
"path": ".github/workflows/publish.yml",
"chars": 5052,
"preview": "name: Publish\non:\n push:\n branches:\n - master\n - v53\n paths:\n - RELEASE_NOTES.md\n - .github/w"
},
{
"path": ".gitignore",
"chars": 707,
"preview": "**/.DS_Store\r\n/.paket/paket.exe\r\n/src/Aardvark.Base/obj\r\n/src/*.suo\r\n/src/*.userprefs\r\n/bin/net40\r\n/bin/net45\r\n/packages"
},
{
"path": ".vscode/settings.json",
"chars": 382,
"preview": "{\n \"dotnet-test-explorer.testProjectPath\": \"src/Aardvark.sln\",\n \"files.exclude\": {\n \"**/.git\": true,\n "
},
{
"path": ".vscode/tasks.json",
"chars": 2456,
"preview": "{\n // See https://go.microsoft.com/fwlink/?LinkId=733558\n // for the documentation about the tasks.json format\n "
},
{
"path": "AGENTS.md",
"chars": 7697,
"preview": "# AI Agent Guide\n\nRepository-specific rules and verified operational facts for coding agents.\n\nPrimary AI reference inde"
},
{
"path": "LICENSE",
"chars": 11378,
"preview": "Apache License\n Version 2.0, January 2004\n http://www.apache.org/licens"
},
{
"path": "PACKAGES.md",
"chars": 275,
"preview": "# Approach\n\nStable packages will be pushed to nuget by the maintainers.\n\n# Developer packages\n\nCommunity packages go to "
},
{
"path": "README.md",
"chars": 2852,
"preview": "# Aardvark.Base\n\n[](ht"
},
{
"path": "RELEASE_NOTES.md",
"chars": 18837,
"preview": "- [IO] Hardened `UberStream` constructor and read/write argument validation\n- [Base] Made `EnumerableEx.AllDistinct` and"
},
{
"path": "ai/ALGORITHMS.md",
"chars": 2246,
"preview": "# Aardvark.Base Algorithms Reference\n\nSource-verified map of key algorithm types and entry points.\n\n## ShortestPath<T>\n\n"
},
{
"path": "ai/COLLECTIONS.md",
"chars": 2143,
"preview": "# Aardvark.Base Collections Reference\n\nSource-verified reference for custom collection and symbol infrastructure.\n\n## Sy"
},
{
"path": "ai/DOC_ACCURACY_AUDIT.md",
"chars": 1824,
"preview": "# AI Docs Accuracy Audit\n\nAudit baseline for coding-agent docs in this repository.\n\n## Last Audit\n\n- Date: 2026-02-26\n- "
},
{
"path": "ai/FSHARP_INTEROP.md",
"chars": 6567,
"preview": "# Aardvark.Base F# Interop Reference\n\nAI-targeted reference for using Aardvark.Base types from F#. Covers modules, exten"
},
{
"path": "ai/INCREMENTAL.md",
"chars": 8925,
"preview": "# Incremental/Adaptive System\n\nReactive computation with automatic dependency tracking. Values form a DAG; changes propa"
},
{
"path": "ai/PIXIMAGE.md",
"chars": 2452,
"preview": "# Aardvark.Base Pix/Image Reference\n\nSource-verified orientation for `PixImage`, `PixVolume`, and related types.\n\n## Cor"
},
{
"path": "ai/PRIMITIVE_TYPES.md",
"chars": 3493,
"preview": "# Aardvark.Base Primitive Types Reference\n\nFast orientation for core math and geometry types in `Aardvark.Base`.\n\nUse t"
},
{
"path": "ai/README.md",
"chars": 1771,
"preview": "# Aardvark.Base AI Reference\n\nTask-first docs for coding agents.\n\nGoal: open one focused document, not the whole `ai/` f"
},
{
"path": "ai/RECIPE_AI_FRIENDLINESS.md",
"chars": 10725,
"preview": "# Recipe: Making a Repository AI-Friendly\n\nStep-by-step guide for Claude instances to add AI-optimized documentation to "
},
{
"path": "ai/SEMANTICS_GEOMETRY_CORE.md",
"chars": 1731,
"preview": "# Aardvark.Base Geometry Semantics\n\nUse this for transform correctness questions in geometry code.\n\n## Transform Semanti"
},
{
"path": "ai/SEMANTICS_LINEAR_ALGEBRA.md",
"chars": 2502,
"preview": "# Aardvark.Base Linear Algebra Semantics\n\nUse this when matrix/vector layout and interop correctness matter.\n\n## M44d Co"
},
{
"path": "ai/SERIALIZATION.md",
"chars": 7599,
"preview": "# Aardvark.Base Serialization Reference\n\nAI-targeted reference for the ICoder serialization system - bidirectional read/"
},
{
"path": "ai/SYMBOL_INDEX.md",
"chars": 2500,
"preview": "# Aardvark.Base Symbol Index\n\nQuick symbol-to-doc map for incremental discovery.\n\n## Core Math / Geometry\n\n| Symbol | Pr"
},
{
"path": "ai/TENSORS.md",
"chars": 1595,
"preview": "# Aardvark.Base Tensor Types Reference\n\nSource-verified reference for stride-based tensor containers.\n\n## Core Model\n\nIn"
},
{
"path": "ai/UTILITIES.md",
"chars": 2707,
"preview": "# Aardvark.Base Utilities Reference\n\nSource-verified orientation for reporting, telemetry, random, traversal, and geodes"
},
{
"path": "build.cmd",
"chars": 443,
"preview": "@echo off\ndotnet tool restore\nIF ERRORLEVEL 1 EXIT /B %ERRORLEVEL%\nREM `dotnet paket restore` alone does not recreate Pa"
},
{
"path": "build.sh",
"chars": 331,
"preview": "#!/bin/bash\n\nset -eu\n\nmode=\"${1-}\"\n\ndotnet tool restore\n# `dotnet paket restore` alone does not recreate Paket.Restore.t"
},
{
"path": "check-docs.cmd",
"chars": 79,
"preview": "@echo off\ndotnet run --project tools\\DocsChecker\\DocsChecker.csproj -c Release\n"
},
{
"path": "check-docs.sh",
"chars": 100,
"preview": "#!/bin/bash\nset -euo pipefail\n\ndotnet run --project tools/DocsChecker/DocsChecker.csproj -c Release\n"
},
{
"path": "generate.cmd",
"chars": 107,
"preview": "@echo off\ndotnet build src\\CodeGenerator\\CodeGenerator.csproj\ndotnet bin\\Debug\\net8.0\\CodeGenerator.dll %*\n"
},
{
"path": "generate.sh",
"chars": 110,
"preview": "#! /bin/sh\ndotnet build src/CodeGenerator/CodeGenerator.csproj\ndotnet bin/Debug/net8.0/CodeGenerator.dll \"$@\"\n"
},
{
"path": "global.json",
"chars": 117,
"preview": "{\n \"sdk\": {\n \"version\": \"8.0.0\",\n \"rollForward\": \"latestFeature\",\n \"allowPrerelease\": false\n }\n}"
},
{
"path": "paket.dependencies",
"chars": 1876,
"preview": "framework: netstandard2.0, net8.0\r\nstorage: none\r\nsource https://api.nuget.org/v3/index.json\r\n\r\nnuget Aardvark.Build "
},
{
"path": "src/Aardvark.Base/Aardvark.Base.csproj",
"chars": 1339,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Project Sdk=\"Microsoft.NET.Sdk\">\r\n <PropertyGroup>\r\n <TargetFrameworks>net8"
},
{
"path": "src/Aardvark.Base/AlgoDat/AdaBoost.cs",
"chars": 6657,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n ///"
},
{
"path": "src/Aardvark.Base/AlgoDat/ConcurrentHashSet.cs",
"chars": 3206,
"preview": "using System.Collections.Generic;\nusing System.Linq;\n\nnamespace System.Collections.Concurrent\n{\n /// <summary>\n /"
},
{
"path": "src/Aardvark.Base/AlgoDat/ExtendedCore/BitHelpers.cs",
"chars": 5518,
"preview": "// Copyright (c) Microsoft. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project roo"
},
{
"path": "src/Aardvark.Base/AlgoDat/ExtendedCore/SortedSetExt.cs",
"chars": 90661,
"preview": "// Copyright (c) Microsoft. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project roo"
},
{
"path": "src/Aardvark.Base/AlgoDat/INode.cs",
"chars": 3720,
"preview": "using Aardvark.Base;\nusing System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.VRVis\n{\n "
},
{
"path": "src/Aardvark.Base/AlgoDat/LruCache.cs",
"chars": 10318,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// A least-recently-us"
},
{
"path": "src/Aardvark.Base/AlgoDat/Meta.cs",
"chars": 50308,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/AlgoDat/MinimumSpanningTree.cs",
"chars": 4248,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/AlgoDat/SalesmanOfDeath.cs",
"chars": 30786,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.Base\n{\n public readonly struc"
},
{
"path": "src/Aardvark.Base/AlgoDat/ShortestPath.cs",
"chars": 13633,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading;\nusing System.Threading.Tasks"
},
{
"path": "src/Aardvark.Base/AlgoDat/Span.cs",
"chars": 719,
"preview": "using System;\n\nnamespace Aardvark.Base\n{\n public static class SpanPinning\n {\n /// <summary>\n /// Pi"
},
{
"path": "src/Aardvark.Base/Delegates/Delegates.cs",
"chars": 1968,
"preview": "using System;\n\nnamespace Aardvark.Base\n{\n public delegate void ActionValRef<T0, T1>(T0 a0, ref T1 a1);\n public de"
},
{
"path": "src/Aardvark.Base/Delegates/Delegates_auto.cs",
"chars": 62423,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n // "
},
{
"path": "src/Aardvark.Base/Delegates/Delegates_template.cs",
"chars": 1999,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n //"
},
{
"path": "src/Aardvark.Base/Delegates/HigherOrderFunctions.cs",
"chars": 9824,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing static System.Math;\n\nnamespace Aardvark.Base\n{"
},
{
"path": "src/Aardvark.Base/Extensions/ArrayExtensions.cs",
"chars": 99400,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.Runtime.CompilerServices;\nusing System.Ru"
},
{
"path": "src/Aardvark.Base/Extensions/CastExtensions.cs",
"chars": 1392,
"preview": "using System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.Base\n{"
},
{
"path": "src/Aardvark.Base/Extensions/DagExtensions.cs",
"chars": 1407,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.VRVis\n{\n public static class TreeExtensions\n "
},
{
"path": "src/Aardvark.Base/Extensions/DateTimeExtensions.cs",
"chars": 3777,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n public static class D"
},
{
"path": "src/Aardvark.Base/Extensions/DictionaryExtensions.cs",
"chars": 9016,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n #r"
},
{
"path": "src/Aardvark.Base/Extensions/EnumHelpers.cs",
"chars": 4270,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class EnumHelpers\n {\n "
},
{
"path": "src/Aardvark.Base/Extensions/EventHandlerExtensions.cs",
"chars": 625,
"preview": "using System;\n\nnamespace Aardvark.Base\n{\n public static class EventHandlerExtensions\n {\n /// <summary>\n "
},
{
"path": "src/Aardvark.Base/Extensions/FuncActionExtensions.cs",
"chars": 480,
"preview": "using System;\n\nnamespace Aardvark.Base\n{\n public static partial class FuncActionExtensions\n {\n /// <summar"
},
{
"path": "src/Aardvark.Base/Extensions/FuncActionExtensions_auto.cs",
"chars": 36297,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pub"
},
{
"path": "src/Aardvark.Base/Extensions/FuncActionExtensions_template.cs",
"chars": 2207,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/Extensions/HigherOrderFunctions.cs",
"chars": 18126,
"preview": "using System;\nusing System.Collections.Generic;\nusing static System.Math;\n\nnamespace Aardvark.Base\n{\n public static "
},
{
"path": "src/Aardvark.Base/Extensions/ICollectionExtensions.cs",
"chars": 992,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\n\nna"
},
{
"path": "src/Aardvark.Base/Extensions/IEnumerableExtensions.cs",
"chars": 90272,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Linq;\nusing System.Tex"
},
{
"path": "src/Aardvark.Base/Extensions/IListExtensions.cs",
"chars": 23083,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class IListExtensions\n "
},
{
"path": "src/Aardvark.Base/Extensions/IsExternalInit.cs",
"chars": 267,
"preview": "#if !NET8_0_OR_GREATER\n\nusing System.ComponentModel;\n\nnamespace System.Runtime.CompilerServices\n{\n // See: https://g"
},
{
"path": "src/Aardvark.Base/Extensions/ListExtensions.cs",
"chars": 24308,
"preview": "using System;\nusing System.Collections.Generic;\nusing static System.Math;\n\nnamespace Aardvark.Base\n{\n public static "
},
{
"path": "src/Aardvark.Base/Extensions/NonGenericArray.cs",
"chars": 27676,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class NonGenericArrayExten"
},
{
"path": "src/Aardvark.Base/Extensions/SequenceExtensions_auto.cs",
"chars": 241007,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pub"
},
{
"path": "src/Aardvark.Base/Extensions/SequenceExtensions_template.cs",
"chars": 16773,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/Extensions/StreamExtensions.cs",
"chars": 1868,
"preview": "using System;\nusing System.IO;\n\nnamespace Aardvark.Base\n{\n public static class StreamExtensions\n {\n /// <s"
},
{
"path": "src/Aardvark.Base/Extensions/StringExtensions.cs",
"chars": 16057,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Security.Cr"
},
{
"path": "src/Aardvark.Base/Extensions/Structs.cs",
"chars": 1744,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Linq;\nusing System.Tex"
},
{
"path": "src/Aardvark.Base/Extensions/SubRange.cs",
"chars": 2910,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// A SubRange is an I"
},
{
"path": "src/Aardvark.Base/Extensions/SystemDrawingExtensions.cs",
"chars": 7065,
"preview": "using System.Drawing;\n\nnamespace Aardvark.Base.SystemDrawingInterop\n{\n /// <summary>\n /// Extensions for converti"
},
{
"path": "src/Aardvark.Base/Extensions/TupleExtensions.cs",
"chars": 4758,
"preview": "using System;\n\nnamespace Aardvark.Base\n{\n public static class TupleExtensions\n {\n /// <summary>\n //"
},
{
"path": "src/Aardvark.Base/Extensions/TypeExtensions.cs",
"chars": 809,
"preview": "using System;\nusing System.Collections.Concurrent;\nusing System.Reflection;\nusing System.Runtime.CompilerServices;\n\nnam"
},
{
"path": "src/Aardvark.Base/Extensions/VariousExtensions.cs",
"chars": 306,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class VariousExtensions\n "
},
{
"path": "src/Aardvark.Base/Geodesy/GeoConsts.cs",
"chars": 6595,
"preview": "namespace Aardvark.Base\n{\n /// <summary>\n /// Holds data for a geodesic transform from one datum to another. \n "
},
{
"path": "src/Aardvark.Base/Geodesy/GeoConversion.cs",
"chars": 26048,
"preview": "using System;\nusing System.Globalization;\nusing System.Net;\nusing static Aardvark.Base.Constant;\nusing static System.Mat"
},
{
"path": "src/Aardvark.Base/Geometry/Algorithms_auto.cs",
"chars": 32965,
"preview": "using Aardvark.Base.Sorting;\nusing System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.Base"
},
{
"path": "src/Aardvark.Base/Geometry/Algorithms_template.cs",
"chars": 19261,
"preview": "using Aardvark.Base.Sorting;\nusing System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.Bas"
},
{
"path": "src/Aardvark.Base/Geometry/BbTree.cs",
"chars": 9169,
"preview": "using Aardvark.Base;\nusing System;\nusing Aardvark.Base.Sorting;\n\nnamespace Aardvark.Base\n{\n public struct BbTreeHit\n "
},
{
"path": "src/Aardvark.Base/Geometry/ClippingFunctions_auto.cs",
"chars": 30851,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pub"
},
{
"path": "src/Aardvark.Base/Geometry/ClippingFunctions_template.cs",
"chars": 16507,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/Geometry/Interfaces/IBoundingBox_auto.cs",
"chars": 1769,
"preview": "namespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n /// <summary>\n /// Return an axis aligned "
},
{
"path": "src/Aardvark.Base/Geometry/Interfaces/IBoundingBox_template.cs",
"chars": 652,
"preview": "namespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n //# foreach (var ft in Meta.SignedVecFieldTy"
},
{
"path": "src/Aardvark.Base/Geometry/Interfaces/IBoundingCircle.cs",
"chars": 218,
"preview": "namespace Aardvark.Base\n{\n public interface IBoundingCircle2f\n {\n Circle2f BoundingCircle2f { get; }\n }"
},
{
"path": "src/Aardvark.Base/Geometry/Interfaces/IBoundingSphere.cs",
"chars": 218,
"preview": "namespace Aardvark.Base\n{\n public interface IBoundingSphere3f\n {\n Sphere3f BoundingSphere3f { get; }\n }"
},
{
"path": "src/Aardvark.Base/Geometry/Interfaces/IImmutablePolygon.cs",
"chars": 1545,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// An immutable polyg"
},
{
"path": "src/Aardvark.Base/Geometry/Interfaces/IPolygon.cs",
"chars": 169,
"preview": "namespace Aardvark.Base\n{\n public interface IPolygon<T>\n {\n int PointCount { get; }\n T this[int ind"
},
{
"path": "src/Aardvark.Base/Geometry/IntersectionTests_auto.cs",
"chars": 297220,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/Geometry/IntersectionTests_template.cs",
"chars": 155205,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/Geometry/Relations/LinearCombination_auto.cs",
"chars": 2693,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n public static class LinearCombination\n {\n "
},
{
"path": "src/Aardvark.Base/Geometry/Relations/LinearCombination_template.cs",
"chars": 1817,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n public static class LinearCombination\n {\n "
},
{
"path": "src/Aardvark.Base/Geometry/Relations/Orthogonality_auto.cs",
"chars": 4308,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// Provides various methods det"
},
{
"path": "src/Aardvark.Base/Geometry/Relations/Orthogonality_template.cs",
"chars": 2765,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// Provides various methods de"
},
{
"path": "src/Aardvark.Base/Geometry/Relations/Parallelism_auto.cs",
"chars": 9438,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// Provides various methods det"
},
{
"path": "src/Aardvark.Base/Geometry/Relations/Parallelism_template.cs",
"chars": 5623,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// Provides various methods de"
},
{
"path": "src/Aardvark.Base/Geometry/Relations/SubPrimitives_auto.cs",
"chars": 36530,
"preview": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class Su"
},
{
"path": "src/Aardvark.Base/Geometry/Relations/SubPrimitives_template.cs",
"chars": 19633,
"preview": "using System;\nusing System.Linq;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class S"
},
{
"path": "src/Aardvark.Base/Geometry/SpecialPoints_auto.cs",
"chars": 84405,
"preview": "using System.Collections.Generic;\nusing System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n "
},
{
"path": "src/Aardvark.Base/Geometry/SpecialPoints_template.cs",
"chars": 46969,
"preview": "using System.Collections.Generic;\nusing System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n "
},
{
"path": "src/Aardvark.Base/Geometry/Types/Capsule/Capsule3_auto.cs",
"chars": 7659,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\nusing System.Runtime"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Capsule/Capsule3_template.cs",
"chars": 4809,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\nusing System.Runtim"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Circle/Circle2_auto.cs",
"chars": 15017,
"preview": "/*\n Copyright 2006-2020. The Aardvark Platform Team.\n\n https://aardvark.graphics\n\n Licensed under the Apach"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Circle/Circle2_template.cs",
"chars": 8701,
"preview": "/*\n Copyright 2006-2020. The Aardvark Platform Team.\n\n https://aardvark.graphics\n\n Licensed under the Apach"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Circle/Circle3_auto.cs",
"chars": 16739,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Inte"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Circle/Circle3_template.cs",
"chars": 9332,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Inte"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Cone/Cone3_auto.cs",
"chars": 22126,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\nusing System.Runtime"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Cone/Cone3_template.cs",
"chars": 12266,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\nusing System.Runtim"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Cone/Conic2_auto.cs",
"chars": 2550,
"preview": "using System.Linq;\nusing System.Runtime.InteropServices;\nusing System.Runtime.Serialization;\n\nnamespace Aardvark.Base\n{\n"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Cone/Conic2_template.cs",
"chars": 1778,
"preview": "using System.Linq;\nusing System.Runtime.InteropServices;\nusing System.Runtime.Serialization;\n\nnamespace Aardvark.Base\n{"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Cylinder/Cylinder3_auto.cs",
"chars": 13828,
"preview": "using System;\nusing System.Globalization;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing "
},
{
"path": "src/Aardvark.Base/Geometry/Types/Cylinder/Cylinder3_template.cs",
"chars": 7916,
"preview": "using System;\nusing System.Globalization;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ellipse/Ellipse2_auto.cs",
"chars": 1767,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Runtime.CompilerServices;\nusing System.Linq;\nusing System.T"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ellipse/Ellipse2_template.cs",
"chars": 1279,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Runtime.CompilerServices;\nusing System.Linq;\nusing System."
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ellipse/Ellipse3_auto.cs",
"chars": 1801,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Runtime.CompilerServices;\nusing System.Linq;\nusing System.T"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ellipse/Ellipse3_template.cs",
"chars": 1312,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Runtime.CompilerServices;\nusing System.Linq;\nusing System."
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ellipse/Ellipse_auto.cs",
"chars": 33766,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Inte"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ellipse/Ellipse_template.cs",
"chars": 10482,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Int"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Geometry1i.cs",
"chars": 1846,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n #r"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Geometry1i_auto.cs",
"chars": 13963,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.ComponentModel;\nusing System.Diagnostics;\nusing System.Linq"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Geometry1i_template.cs",
"chars": 4259,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.ComponentModel;\nusing System.Diagnostics;\nusing System.Lin"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Geometry_auto.cs",
"chars": 543421,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Inte"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Geometry_template.cs",
"chars": 47064,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Int"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Hull/Hull2_auto.cs",
"chars": 16804,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Comp"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Hull/Hull2_template.cs",
"chars": 9364,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Com"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Hull/Hull3_auto.cs",
"chars": 26844,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Comp"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Hull/Hull3_template.cs",
"chars": 15255,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Com"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Line/Line2_auto.cs",
"chars": 6546,
"preview": "using System.Xml.Serialization;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n #region Line"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Line/Line2_template.cs",
"chars": 4200,
"preview": "using System.Xml.Serialization;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n //# foreach"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Line/Line3_auto.cs",
"chars": 2358,
"preview": "using System;\nusing System.Xml.Serialization;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n "
},
{
"path": "src/Aardvark.Base/Geometry/Types/Line/Line3_template.cs",
"chars": 2005,
"preview": "using System;\nusing System.Xml.Serialization;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n "
},
{
"path": "src/Aardvark.Base/Geometry/Types/Line1iPoint.cs",
"chars": 596,
"preview": "namespace Aardvark.Base\n{\n /// <summary>\n /// Represents a value at an interpolated point between two indexed\n "
},
{
"path": "src/Aardvark.Base/Geometry/Types/Plane/Plane2_auto.cs",
"chars": 20430,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\nusing System.Xml.Ser"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Plane/Plane2_template.cs",
"chars": 11092,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\nusing System.Xml.Se"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Plane/Plane3_auto.cs",
"chars": 61264,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Comp"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Plane/Plane3_template.cs",
"chars": 32957,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Comp"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/IImmutablePolygonExtensions_auto.cs",
"chars": 9606,
"preview": "using System;\nusing System.Linq;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n public stat"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/IImmutablePolygonExtensions_template.cs",
"chars": 6093,
"preview": "using System;\nusing System.Linq;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n public sta"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/ImmutablePolygon.cs",
"chars": 3783,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Globalization;\nusing S"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/Polygon2_auto.cs",
"chars": 45296,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/Polygon2_template.cs",
"chars": 24060,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED COD"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/Polygon3_auto.cs",
"chars": 23633,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\n\nnamespace Aar"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/Polygon3_template.cs",
"chars": 13250,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\n\nnamespace Aa"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/PolygonExtensions_auto.cs",
"chars": 4194,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class IPolygonExtensions\n "
},
{
"path": "src/Aardvark.Base/Geometry/Types/Polygon/PolygonExtensions_template.cs",
"chars": 3061,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n public static class IPolygonExtensions\n "
},
{
"path": "src/Aardvark.Base/Geometry/Types/Quad/Quad2_auto.cs",
"chars": 2318,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n #regi"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Quad/Quad2_template.cs",
"chars": 1569,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n //# f"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Quad/Quad3_auto.cs",
"chars": 3067,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n #regi"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Quad/Quad3_template.cs",
"chars": 1944,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n //# f"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Quadric/Quadric_auto.cs",
"chars": 6042,
"preview": "using System;\nusing System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHAN"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Quadric/Quadric_template.cs",
"chars": 3813,
"preview": "using System;\nusing System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHA"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ray/Ray2_auto.cs",
"chars": 37011,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.InteropServices;\nusing System.Runtime."
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ray/Ray2_template.cs",
"chars": 19882,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.InteropServices;\nusing System.Runtime."
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ray/Ray3_auto.cs",
"chars": 137232,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.InteropServices;\nusing System.Runtime."
},
{
"path": "src/Aardvark.Base/Geometry/Types/Ray/Ray3_template.cs",
"chars": 71747,
"preview": "using System;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.InteropServices;\nusing System.Runtime."
},
{
"path": "src/Aardvark.Base/Geometry/Types/Sphere/Sphere3_auto.cs",
"chars": 14953,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Inte"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Sphere/Sphere3_template.cs",
"chars": 8356,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.Inte"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Torus/Torus3_auto.cs",
"chars": 13651,
"preview": "using System;\nusing System.Globalization;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Runtime.Comp"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Torus/Torus3_template.cs",
"chars": 7903,
"preview": "using System;\nusing System.Globalization;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Runtime.Com"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Triangle/Triangle2_auto.cs",
"chars": 16303,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n #regi"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Triangle/Triangle2_template.cs",
"chars": 9224,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n //# f"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Triangle/Triangle3_auto.cs",
"chars": 15255,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n #regi"
},
{
"path": "src/Aardvark.Base/Geometry/Types/Triangle/Triangle3_template.cs",
"chars": 8583,
"preview": "using System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n // AUTO GENERATED CODE - DO NOT CHANGE!\n\n //# f"
},
{
"path": "src/Aardvark.Base/Hashing/HashCode.cs",
"chars": 16558,
"preview": "using System.Collections.Generic;\nusing System.Linq;\nusing System.Runtime.CompilerServices;\nusing static System.Math;\n\n"
},
{
"path": "src/Aardvark.Base/Introspection/Aardvark.cs",
"chars": 6626,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.IO;\nusing System.Reflection;\nusing System.Runtime.InteropServices;\n"
},
{
"path": "src/Aardvark.Base/Introspection/CachingProperties.cs",
"chars": 2993,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.IO;\nusing System.Reflection;\n\npublic static class CachingProperties"
},
{
"path": "src/Aardvark.Base/Introspection/Introspection.cs",
"chars": 15566,
"preview": "namespace Aardvark.Base;\r\n\r\nusing System;\r\nusing System.Collections.Generic;\r\nusing System.Diagnostics;\r\nusing System.G"
},
{
"path": "src/Aardvark.Base/Introspection/IntrospectionProperties.cs",
"chars": 7230,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.Reflection;\nusin"
},
{
"path": "src/Aardvark.Base/Introspection/Native.cs",
"chars": 28710,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.IO.Compression;\n"
},
{
"path": "src/Aardvark.Base/Introspection/Platform/Dl.cs",
"chars": 872,
"preview": "using System;\nusing System.Runtime.InteropServices;\n\nnamespace Aardvark.Base;\n\npublic partial class Aardvark\n{\n inter"
},
{
"path": "src/Aardvark.Base/Introspection/Platform/Kernel32.cs",
"chars": 5375,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.Runtime.InteropServices;\n\npublic partial class Aardvark\n{\n /// <"
},
{
"path": "src/Aardvark.Base/Introspection/Platform/LdConfig.cs",
"chars": 4194,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.Collections.Generic;\nusing System.Diagnostics;\n\npublic partial clas"
},
{
"path": "src/Aardvark.Base/Introspection/Plugins.cs",
"chars": 19378,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.Linq;\nusing Syst"
},
{
"path": "src/Aardvark.Base/Introspection/RegexPatterns.cs",
"chars": 3488,
"preview": "using System.Runtime.InteropServices;\nusing System.Text.RegularExpressions;\n\nnamespace Aardvark.Base;\n\npublic partial cl"
},
{
"path": "src/Aardvark.Base/Introspection/Utilities.cs",
"chars": 4087,
"preview": "namespace Aardvark.Base;\n\nusing System;\nusing System.IO;\nusing System.Reflection;\n\n#if !NET8_0_OR_GREATER\nusing System.L"
},
{
"path": "src/Aardvark.Base/Json/JsonConverters.cs",
"chars": 220507,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics;\nusing System.Runtime.CompilerServices;\nusing "
},
{
"path": "src/Aardvark.Base/Math/Base/Adler32.cs",
"chars": 6656,
"preview": "using System;\nusing System.IO;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// Computes Adler32 checksum for a str"
},
{
"path": "src/Aardvark.Base/Math/Base/AliasTable_auto.cs",
"chars": 8843,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\n\nnam"
},
{
"path": "src/Aardvark.Base/Math/Base/AliasTable_template.cs",
"chars": 4737,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\n\nna"
},
{
"path": "src/Aardvark.Base/Math/Base/Complex_auto.cs",
"chars": 72583,
"preview": "using System;\nusing System.Linq;\nusing System.Globalization;\nusing System.ComponentModel;\nusing System.Runtime.InteropSe"
},
{
"path": "src/Aardvark.Base/Math/Base/Complex_template.cs",
"chars": 35947,
"preview": "using System;\nusing System.Linq;\nusing System.Globalization;\nusing System.ComponentModel;\nusing System.Runtime.InteropS"
},
{
"path": "src/Aardvark.Base/Math/Base/Constant.cs",
"chars": 15638,
"preview": "using System;\n\nnamespace Aardvark.Base\n{\n public enum Metric\n {\n Manhattan = 1,\n Euclidean = 2,\n "
},
{
"path": "src/Aardvark.Base/Math/Base/Conversion.cs",
"chars": 17363,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Globalization;\nusing System.Text;\n\nnamespace Aardvark.Base\n"
},
{
"path": "src/Aardvark.Base/Math/Base/DistributionFunction.cs",
"chars": 5369,
"preview": "using System.Linq;\nusing System.Runtime.CompilerServices;\n\nnamespace Aardvark.Base\n{\n /// <summary>\n /// Represen"
},
{
"path": "src/Aardvark.Base/Math/Base/Fraction.cs",
"chars": 9011,
"preview": "using System.Runtime.InteropServices;\nusing System.Runtime.Serialization;\nusing System.Runtime.CompilerServices;\n\nnames"
},
{
"path": "src/Aardvark.Base/Math/Base/Fun.cs",
"chars": 42097,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing System.Globalization;\nusing S"
},
{
"path": "src/Aardvark.Base/Math/Base/Fun_auto.cs",
"chars": 244661,
"preview": "using System;\nusing System.ComponentModel;\nusing System.Collections.Generic;\nusing System.Diagnostics;\nusing System.Diag"
},
{
"path": "src/Aardvark.Base/Math/Base/Fun_template.cs",
"chars": 71227,
"preview": "using System;\nusing System.ComponentModel;\nusing System.Collections.Generic;\nusing System.Diagnostics;\nusing System.Diag"
},
{
"path": "src/Aardvark.Base/Math/Base/Half.cs",
"chars": 59388,
"preview": "using System;\nusing System.Diagnostics;\nusing System.Globalization;\nusing System.Runtime.CompilerServices;\nusing System"
},
{
"path": "src/Aardvark.Base/Math/Base/MedianWindow.cs",
"chars": 2165,
"preview": "using Aardvark.Base.Sorting;\nusing System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n /// <summar"
},
{
"path": "src/Aardvark.Base/Math/Base/PhysicsConsts.cs",
"chars": 13107,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace Aardvark.Base\n{\n pu"
},
{
"path": "src/Aardvark.Base/Math/Base/Quaternion_auto.cs",
"chars": 46160,
"preview": "using System;\nusing System.Diagnostics;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.InteropServi"
},
{
"path": "src/Aardvark.Base/Math/Base/Quaternion_template.cs",
"chars": 24191,
"preview": "using System;\nusing System.Diagnostics;\nusing System.Globalization;\nusing System.Linq;\nusing System.Runtime.InteropServ"
},
{
"path": "src/Aardvark.Base/Math/Base/SampleGrid2d.cs",
"chars": 14854,
"preview": "using System;\n\nnamespace Aardvark.Base\n{\n public class SampleGrid2d\n {\n private V2l m_last;\n privat"
},
{
"path": "src/Aardvark.Base/Math/Base/Statistics.cs",
"chars": 14233,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace Aardvark.Base\n{\n #region Extremum<T>\n\n /// <summary>\n "
},
{
"path": "src/Aardvark.Base/Math/Base/WeightedIndex.cs",
"chars": 405,
"preview": "namespace Aardvark.Base\n{\n /// <summary>\n /// A structure holding a double weight and an index.\n /// </summary"
}
]
// ... and 604 more files (download for full content)
About this extraction
This page contains the full source code of the aardvark-platform/aardvark.base GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 804 files (41.1 MB), approximately 10.8M tokens, and a symbol index with 54120 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.