xtensor-stack/xtensor

Features

• Lazy Numerical Expressions - Computes numerical operations like absolute values and remainders using a lazy evaluation engine to minimize memory overhead.
• Multidimensional Arrays - Provides dense multidimensional containers with fixed dimensions and configurable layouts for numerical computing.
• Lazy Evaluation Expression Engines - Implements a lazy evaluation expression engine that defers numerical computations until assignment to minimize memory overhead.
• Multi-Dimensional Arrays - Provides a C++ implementation of N-dimensional arrays with support for row-major and column-major memory layouts.
• Multidimensional Array Containers - Provides a dense multidimensional container supporting row-major and column-major layouts with dynamic or static dimensionality.
• Numerical Computing - Provides a comprehensive library for high-performance numerical computing with lazy broadcasting and N-dimensional arrays.
• Lazy Shape Expansion - Expands tensor shapes lazily to execute operations without creating intermediate temporary copies.
• Tensor Shape Expansions - Expands expressions by repeating data along dimensions to enable element-wise operations between mismatched shapes.
• In-Place Tensor Operations - Wraps arrays from external languages to perform direct numerical operations without copying data between memory spaces.
• Tensor Indexing - Uses coordinates, ranges, and ellipses to extract specific rows or columns as views.
• Tensor Initialization - Provides mechanisms to initialize tensors with either dynamic or static shapes for numerical data storage.
• Implicit Dimension Broadcasting - Expands expressions to a larger target shape during iteration to perform operations on mismatched dimensions without data duplication.
• Array and Tensor Manipulation - Provides comprehensive operations for reshaping, joining, splitting, squeezing, and padding multidimensional data structures.
• Array View Creation - Allows the extraction of slices and masked subsets to manipulate data without modifying original storage.
• Cross-Language In-Place Modification - Interacts with existing structures from NumPy, Julia, or R to perform inplace modifications.
• Zero-Copy Container Wrapping - Wraps external data containers into the expression system to perform numerical operations without duplicating data.
• Multidimensional Element Accessors - Retrieves elements using multidimensional or flat indices with optional bounds-checking.
• Zero-Copy Array Slicing - Extracts sub-sections of arrays using indices or ranges without duplicating underlying memory.
• Strided - Controls how multidimensional data maps to linear memory using shapes and strides to enable efficient slicing and transposition.
• Multidimensional Interface Adaptors - Maps external memory pointers or third-party containers to a multidimensional interface using custom adaptors.
• Direct Buffer Processing - Manipulates Python numerical data structures directly via the buffer protocol to eliminate data duplication.
• Array Reductions - Deno-xtensor applies a reducing function across specified axes to compute a summary value.
• Memory Buffer Wrapping - Maps external memory pointers or third-party containers to a multidimensional interface without copying data.
• Lazy Evaluation - Uses a lazy evaluation engine to defer numerical computations until assignment, minimizing memory allocations.
• Numerical Expression Evaluation - Implements a lazy evaluation engine that defers numerical and logical tensor computations until assignment.
• In-Place Data Modification - Manipulates data structures from other languages in original memory locations using a shared buffer protocol.
• Arithmetic Broadcasting - Expands multidimensional expressions to specified shapes for use in mixed-dimension arithmetic operations.
• Advanced Array Indexing - Implements index-based lookup using shapes and strides for efficient access to multidimensional data.
• Array Initialization - Enables the allocation of dense containers with specified shapes and layouts to store numerical data.
• Array Manipulations - Provides comprehensive tools for changing data organization through transposition, axis swapping, and reshaping.
• Basic Numeric Operations - Implements fundamental mathematical utilities such as absolute values, signs, and element clipping for numeric data.
• Buffer-Protocol Array Integration - Manipulates Python numerical arrays directly via the buffer protocol for high-performance analysis on external memory.
• Element-wise Array Operations - Executes high-performance element-wise arithmetic and universal functions across multi-dimensional arrays.
• External Memory Wrapping - Wraps external memory pointers and third-party containers into a multidimensional interface to perform in-place numerical operations.
• High-Performance Computing - Executing vectorized numerical analysis and linear algebra by leveraging BLAS and LAPACK for optimized hardware performance.
• Lazy Expression Broadcasting - Expands expressions to larger shapes lazily to minimize memory allocations until final assignment.
• Linear Algebra Libraries - Connects high-level array expressions to low-level BLAS and LAPACK implementations for high-performance linear algebra.
• Arithmetic Operations - Provides fundamental arithmetic operations for numerical data, including absolute values and fused multiply-add.
• Linear Algebra - Provides high-performance routines for matrix products, decompositions, and solving linear equations.
• Aliasing-Safe Assignments - Computes expressions into temporary variables before assignment to prevent data aliasing.
• NumPy-Compatible Frameworks - Provides a C++ implementation of array operations and syntax designed to mirror the NumPy API for data science.
• Tensor Data Management - Creating and manipulating multidimensional containers through slicing, reshaping, and broadcasting to reorganize numerical datasets.
• Array Compound Assignments - Executes compound assignment operations like addition directly on arrays and expressions to modify data in place.
• NumPy Broadcasting Alignments - Aligns multidimensional arrays using broadcasting rules to enable efficient element-wise computation.
• Elementary Math Functions - Calculates standard elementary math functions, including trigonometric and exponential operations, element-wise.
• Cumulative Aggregate Calculations - Deno-xtensor generates running totals or products along a specified axis.
• Cumulative Aggregations - Deno-xtensor calculates running accumulations like sums or products along a single axis.
• Cumulative Product Calculations - Deno-xtensor calculates the accumulated product of elements along an axis or flattened array.
• Cumulative Sums - Deno-xtensor calculates the accumulated sum of elements along an axis or flattened array.
• Logarithmic Transformers - Provides utilities for computing base-2, base-10, or natural logarithms across array elements.
• Non-Zero Element Detection - Deno-xtensor locates coordinates of all elements not equal to zero or meeting a truth condition.
• Tensor Reductions - Deno-xtensor calculates sums, means, variances, and standard deviations across specified axes.
• Dimension Squeezing - Provides operations to remove dimensions of size one to simplify array shapes.
• Element Repetition - Provides the ability to duplicate elements across dimensions for tiling and broadcasting.
• Numerical SIMD Optimizations - Employs platform-specific instruction sets to execute complex mathematical calculations with high efficiency.
• Boolean Mask Filtration - Generates one-dimensional views of elements satisfying logical conditions without duplicating data.
• Element Classifications - Deno-xtensor checks elements for finiteness, infinity, or NaN and compares arrays for proximity.
• Element Reversals - Provides capabilities to flip the order of elements along specified axes of an array.
• Element Shifting - Implements rolling elements along an axis, wrapping those that move past the array edge.
• Collection Iteration - Provides protocols for traversing N-dimensional expressions using random access iterators.
• Iterable Expression Interfaces - Provides interfaces that allow broadcasted numerical expressions to be traversed using standard iteration patterns.
• Axis-Specific Traversal - Traverses elements across multidimensional expressions along a chosen axis or slice.
• STL Iterator Adaptors - Wraps low-level data steppers in a random-access iterator interface for standard algorithms.
• Fixed-Dimension Storage - Creates dense containers with compile-time dimensions to ensure consistency and memory optimization.
• Spreadsheet Data Exchange - Deno-xtensor reads and writes array data to comma-separated value files for spreadsheet interoperability.
• Scientific Array Serialization - Reading and writing multidimensional arrays using NPY, CSV, and JSON formats for cross-platform data exchange.
• Lazy Iterators - Provides memory-efficient, STL-compatible forward and reverse iterators to process tensor data.
• Array Transposition - Creates lazy views that swap dimensions to reorient data without performing memory copies.
• Dynamic Index Selection - Provides flexible views that support non-contiguous index selection via index keeping or dropping.
• Flat Index Views - Extracts one-dimensional views of arrays by selecting elements at specified index positions.
• View Data Assignment - Writes temporary data into multidimensional array views to update the contents of the underlying array.
• Grid Generation - Provides utilities to generate multidimensional arrays and grids based on mathematical products of indices.
• Constant Tensor Generation - Implements the creation of tensors filled with fixed constant values.
• Dimension Resizing - Allows changing the dimensions of a tensor to a specific size using new dimensions or stride configurations.
• Scalar-Tensor Integrations - Wraps scalars into zero-dimensional expressions to allow seamless mathematical operations with multidimensional tensors.
• Array Inspection - Retrieves metadata including total size, dimension count, and axis lengths for array expressions.
• Labeled Array Management - Provides support for data frames and labeled tensors that integrate with lazy broadcasting.
• View Generation - Generates views with specified offsets and strides to control the spacing of accessed elements.
• Native Missing Value Handlers - Deno-xtensor manages arrays with invalid entries using optional value types to maintain integrity.
• Numerical Array Persistence - Deno-xtensor reads and writes multidimensional arrays using CSV, NPY, and JSON formats for persistence.
• Boolean Masked Views - Creates multidimensional views that hide specific elements based on a boolean mask for numerical analysis.
• CSV Data Loaders - Deno-xtensor parses comma-separated value files into multidimensional arrays with custom delimiters and filters.
• SIMD-Accelerated Arithmetic - Utilizes processor-specific SIMD vector instruction sets to accelerate mathematical operations on batches of data.
• Multi-Language Bindings - Creates language bindings that allow C++ implementations to be called from other high-level data science languages.
• Lazy Tensor Initialization - Generates lazy expressions for array initialization that are only computed upon access or assignment.
• Random Number Generator Seeding - Initializes random number generators with seed values to ensure computational reproducibility.
• Component Extractions - Creates views of real or imaginary parts of complex tensors for independent manipulation.
• Uninitialized Allocators - Reserves memory buffers without initialization to avoid performance overhead during array allocation.
• Chunked Array Creation - Implements the allocation of multidimensional data into discrete memory chunks for optimized processing and memory management.
• Array Flattening Utilities - Provides utilities to collapse multidimensional arrays into a one-dimensional view based on memory layout.
• Raw Pointer Access - Returns a pointer to the underlying one-dimensional memory buffer for direct manipulation.
• Compile-Time Rank Dispatch - Specializes function behavior at compile time based on whether an array has a fixed or flexible number of dimensions.
• Computation Trees - Builds expression trees to defer calculations and minimize intermediate memory allocations.
• Diagonal Manipulations - Retrieves elements along the diagonal of a multidimensional array.
• Extreme Value Identification - Deno-xtensor identifies maximum and minimum elements within an array or along specified axes.
• Joining - Provides functions for concatenating or stacking multiple arrays along specified axes.
• Reshaping - Implements methods for modifying the dimensions and layout of arrays in-place without altering underlying data.
• Random Data Generators - Provides utilities for producing arrays of random numbers based on statistical distributions.
• Flat Index Calculation - Calculates linear memory offsets from multidimensional coordinates using strides.
• Index Format Translation - Translates between flat linear indices and multidimensional array indices.
• Array Padding - Implements the addition of values to array edges using constants, mirroring, or periodic repetition.
• Array Tiling - Constructs new arrays by repeating the original array along its specified axes.
• Container Interfaces - Defines a base interface for dense containers to ensure consistent semantic operations and assignments.
• Custom Storage Backends - Allows defining the memory layouts, shape containers, and underlying data structures used for multidimensional arrays.
• Linear-to-Multidimensional Adaptors - Wraps random-access containers like vectors or C-arrays as multidimensional interfaces without copying underlying data.
• Concatenation - Provides methods for joining multiple arrays or stacking them along specified axes.
• Element-wise Comparisons - Evaluates element-wise equality across arrays using broadcasting to produce boolean masks.
• Finite Value Masks - Deno-xtensor identifies finite values, infinity, or NaN across array elements to find invalid states.
• Random Variate Sampling - Generates non-uniform random numbers based on specific probability distributions like uniform or normal.
• Rank-Based Logic Dispatch - Specializes function behavior based on whether an array has a fixed or flexible number of dimensions.
• Universal Array Function Dispatchers - Deno-xtensor applies universal functions including trigonometric, exponential, and hyperbolic operations.
• Array Axis Relocation - Relocates a single axis from its current position to a new target position in a tensor.
• Array Axis Swapping - Interchanges two specified axes to reorient the multidimensional data structure.
• Array Convolutions - Calculates the convolution of multidimensional arrays along a specified axis, including Fourier-domain processing.
• Array Function Mapping - Executes user-specified functions across multidimensional expressions with integrated broadcasting support.
• Array Geometry Management - Modifies shape, strides, and total size to control how multidimensional data maps to dimensions.
• Array Layout Management - Transforms how multidimensional data maps to linear memory to optimize numerical access patterns.
• Array Combinations - Provides methods to merge multiple arrays via concatenation, stacking, or the creation of coordinate grids.
• Array Rotations - Provides the ability to rotate arrays by 90-degree increments along a specified plane.
• Array Splitting - Implements the division of an array into multiple sub-arrays along a specified axis.
• Boundary Extensions - Provides capabilities to expand array dimensions through padding and tiling using mirroring or constant values.
• Dimension Expansions - Allows the insertion of new axes into an array to increase its overall dimensionality.
• Array Sorting and Partitioning - Deno-xtensor organizes elements or indices using sorting, partitioning, and quantile-based selection.
• Axis-Based Iterators - Traverses arrays by producing one-dimensional slices oriented along a specified axis.
• BLAS and LAPACK Integrations - Integrates with BLAS and LAPACK to provide high-performance matrix and vector computations.
• Broadcasting Iterators - Traverses elements according to a broadcast shape by repeating data lazily.
• Conditional Element Indexing - Deno-xtensor returns indices of elements meeting logical conditions to facilitate selective access.
• Container Geometry Modification - Changes dimensions and layout through resizing or reshaping while optionally preserving elements.
• Coordinate-Based Array Generation - Enables the creation of arrays by applying a custom function to each element's coordinate index.
• Coordinate Mesh Generation - Implements N-D coordinate expressions by repeating one-dimensional arrays to construct grids.
• CSV Array Exporters - Deno-xtensor writes multidimensional array data to a stream in comma-separated value format.
• Fourier Transforms - Performs one-dimensional forward and inverse discrete Fourier transforms along specified axes.
• Discrete Difference Calculations - Computes the discrete difference between elements along a specified axis for numerical analysis.
• Distribution Analysis - Deno-xtensor computes histograms and bin counts to summarize the distribution of numerical data.
• Bitwise Array Operations - Applies logical AND, OR, XOR, and NOT operations to individual elements of multi-dimensional arrays.
• Element-wise Type Casting - Converts the data type of array elements using explicit element-wise static casts.
• Exponential Functions - Computes natural and binary logarithms as well as base-e and base-2 exponentials.
• Expression Evaluation Results - Provides the mechanism to trigger the computation of lazy expressions and return them as concrete arrays.
• Expression Result Sharing - Manages the lifetime of temporary numerical expressions using shared pointers to allow reuse within complex calculations.
• Functor-Based Array Mapping - Transforms array elements by applying functors to create virtual, non-copying views of data.
• High-Performance and Parallel Computing - Provides high-performance parallel execution and specialized instructions to increase the processing speed of multidimensional arrays.
• Functional Vectorization - Lifts scalar operations into batch primitives to allow them to operate on arrays with lazy broadcasting.
• Histogram Generators - Deno-xtensor calculates data distribution into bins using specified edges or weight factors.
• Identity Matrix Generators - Creates square matrices with ones on the main diagonal and zeros elsewhere.
• Immediate Expression Evaluation - Allows triggering the immediate execution of a lazy numerical expression to obtain a concrete array.
• Index-Based Array Generation - Produces N-dimensional values based on coordinates using a specified generator function.
• Lazy Random Value Generation - Implements lazy expressions that calculate new random values only when an element is accessed.
• Mathematical Operation Modeling - Models complex mathematical functions as expressions that can be iterated as if they were containers.
• Norm Calculators - Deno-xtensor computes L0, L1, L2, and infinity norms across specified array dimensions.
• Array Initialization - Creates arrays filled with constants, identity matrices, or sequences as lazy or evaluated containers.
• Template-Based Initialization - Creates new arrays by mirroring the shape, type, and layout of an existing array.
• Dimensionality Enforcement - Converts arrays to a minimum number of dimensions by automatically adding new axes.
• Dimensionality Management - Optimizes memory by using either dynamic runtime reshaping or fixed compile-time dimensions.
• Slicing Iteration - Traverses an array by returning lower-dimensional slices oriented along an axis.
• Sub-Array Traversal - Traverses an array by extracting (N-1)-dimensional sub-arrays along a chosen axis.
• Rounding Utilities - Computes the nearest integer for array elements using ceiling, flooring, or truncation strategies.
• Array Masking Logic - Computes boolean logic across arrays to select values based on boolean masks.
• Exponential Computation Utilities - Calculates natural, base-2, and adjusted exponential values for every element in a numerical array.
• Hyperbolic Function Libraries - Calculates hyperbolic sine, cosine, and tangent element-wise across numerical arrays.
• Trigonometric Functions - Deno-xtensor calculates sine, cosine, tangent, and hyperbolic counterparts across arrays.
• Rounding Utilities - Rounds array elements to the nearest integer using floor, ceiling, or truncation.
• Numerical Sequence Generation - Produces arrays of evenly spaced numbers within a half-open interval.
• NumPy Array Integration - Deno-xtensor reads multidimensional arrays from the NumPy storage format via file paths or streams.
• Optional Tensor Storage - Stores optional values in dense structures optimized for tensor operations using associated masks.
• Optional Value Management - Deno-xtensor separates an optional array into data and validity-flag expressions.
• Order Statistics - Deno-xtensor finds minimums, maximums, medians, or quantiles and sorts data along specified axes.
• Probabilistic Array Sampling - Produces arrays sampled from uniform, normal, binomial, or Poisson distributions.
• Random Tensor Generation - Produces tensors filled with random values using various statistical sampling methods.
• Multidimensional Sorting - Deno-xtensor rearranges elements along an axis or globally to produce a sorted copy.
• Spaced Sequence Generators - Creates tensors of equally spaced linear or logarithmic points.
• Statistical Distribution Sampling - Produces random floating-point arrays sampled from Gamma and Weibull distributions.
• Tensor Accumulations - Deno-xtensor accumulates values along axes using operations like sum, product, or mean.
• Tensor Bitwise Operations - Performs bitwise logical operations like AND, OR, and XOR across integer-type tensors.
• Trigonometric Functions - Deno-xtensor calculates sine, cosine, tangent, and inverses element-wise across arrays and scalars.
• Conditional Value Selection - Picks elements from different arrays or scalars based on a boolean condition.
• In-Place Reshaping - Changes the dimensions of an existing array in place using inferred dimensions.
• In-Place Resizing - Adjusts container size in place without new allocations if the total element count remains constant.
• Power Functions - Implements optimized calculations for floating-point and integer powers across arrays.
• Tensor Comparison Operators - Provides logical operators to evaluate equality and relative magnitude between tensor elements.
• Arithmetic Operations - Deno-xtensor executes math operations on arrays with missing values while preserving the missing state.
• Tensor Rearrangements - Implements tensor transposition, flipping, rolling, and rotation to change the orientation of array elements.
• Lifetime Management - Manages the lifetime of temporary numerical expressions using shared pointers to allow multiple references within complex calculations.
• Array Equality Comparison - Determines if array elements are approximately equal using absolute and relative tolerances.
• Numerical Array Generation - Creates arrays filled with zeros, ones, or constants based on a specified shape.
• Mathematical Libraries - Numerical analysis with multi-dimensional arrays.

Historial de estrellas