|
| template<ControlFlowMode CFM> |
| void | ADOLC::Sparse::detail::checkBVPInput (const double *basepoint) |
| | Verifies input data consistency for bit-vector propagation.
|
| |
| void | ADOLC::Sparse::detail::resetInput (std::span< uint * > &compressedRowStorage) |
| | Resets all entries in the compressed row storage pointer array to nullptr.
|
| |
| template<BitPatternPropagationDirection BPPD> |
| void | ADOLC::Sparse::detail::resetOldSeed (BvpData< BPPD > &data, size_t dim2) |
| | Sets all seed matrix entries to zero for reuse in the next strip-mined batch.
|
| |
| template<BitPatternPropagationDirection BPPD> |
| void | ADOLC::Sparse::detail::prepareSeedMatrix (size_t stripIdx, BvpData< BPPD > &data) |
| | Builds a strip-mined partition of the seed matrix for a given batch.
|
| |
| template<BitPatternPropagationDirection BPPD> |
| void | ADOLC::Sparse::detail::setSeed (BvpData< BPPD > &data, size_t idx, size_t currentStripWordIdx) |
| | Sets a single bit in the seed matrix corresponding to a specific variable index.
|
| |
| template<BitPatternPropagationDirection BPPD> |
| void | ADOLC::Sparse::detail::createSeed (BvpData< BPPD > &data, size_t stripIdx, size_t end) |
| | Creates a seed matrix segment by invoking setSeed() for each variable in the strip.
|
| |
| void | ADOLC::Sparse::detail::extract (size_t wordIdx, size_t stripIdx, size_t currentStripWordIdx, BvpData< BitPatternPropagationDirection::Forward > &data, std::span< uint * > &compressedRowStorage) |
| | Extracts the sparsity pattern for one dependent variable (row) in forward bit-vector propagation mode.
|
| |
| void | ADOLC::Sparse::detail::extract (size_t wordIdx, size_t stripIdx, BvpData< BitPatternPropagationDirection::Reverse > &data, std::span< uint * > &compressedRowStorage) |
| | Extracts the sparsity pattern for one dependent variable (row) in reverse bit-vector propagation mode.
|
| |
| template<BitPatternPropagationDirection BPPD> |
| void | ADOLC::Sparse::detail::extractCompressedRowStorage (int stripIdx, std::span< uint * > &compressedRowStorage, BvpData< BPPD > &data) |
| | Converts Jacobian bit patterns to compressed row storage (CRS) format for one strip.
|
| |
| template<BitPatternPropagationDirection BPPD, ControlFlowMode CFM> |
| void | ADOLC::Sparse::detail::prepareADCalls (short tapeId, const double *basepoint, BvpData< BPPD > &data) |
| | Prepares reverse call using zos_forward.
|
| |
| template<BitPatternPropagationDirection BPPD, ControlFlowMode CFM> |
| void | ADOLC::Sparse::detail::ADCalls (short tapeId, const double *basepoint, BvpData< BPPD > &data) |
| | Executes the ADOL-C internal bit-vector propagation calls (forward or reverse).
|
| |
| template<ControlFlowMode CFM, BitPatternPropagationDirection BPPD> |
| int | ADOLC::Sparse::detail::bitVectorPropagation (short tapeId, int depen, int indep, const double *basepoint, std::span< uint * > &compressedRowStorage) |
| | Main internal implementation for bit-vector propagation.
|
| |
| template<ControlFlowMode CFM, BitPatternPropagationDirection BPPD = BitPatternPropagationDirection::Auto> |
| ADOLC_API int | ADOLC::Sparse::bit_vector_propagation (short tapeId, int depen, int indep, const double *basepoint, std::span< uint * > &compressedRowStorage) |
| | Computes the sparsity pattern of a Jacobian using bit-vector propagation.
|
| |
| template<SparseMethod SM, ControlFlowMode CFM, BitPatternPropagationDirection BPPD = BitPatternPropagationDirection::Auto> |
| ADOLC_API int | ADOLC::Sparse::jac_pat (short tag, int depen, int indep, const double *basepoint, std::span< uint * > &compressedRowStorage) |
| | Compute Jacobian sparsity pattern using the selected sparse method.
|
| |
| template<PiecewiseLinear > |
| ADOLC_API int | ADOLC::Sparse::jac_pat (short tag, int depen, int indep, int numsw, const double *basepoint, std::span< uint * > &compressedRowStorage) |
| | Computes the Jacobian sparsity pattern for an abs-smooth function.
|
| |
| template<CompressionMode CM> |
| ADOLC_API void | ADOLC::Sparse::generate_seed_jac (int m, int n, const std::span< uint * > JP, double ***Seed, int *p) |
| | Generate a seed matrix (coloring) for compressed Jacobian recovery.
|
| |
| template<SparseMethod SM, CompressionMode CM, ControlFlowMode CFM, BitPatternPropagationDirection BPPD = BitPatternPropagationDirection::Auto> |
| int | ADOLC::Sparse::detail::buildJacPatternAndSeed (short tag, int depen, int indep, const double *basepoint) |
| | Allocates and computes pattern of jacobian and computes a seed to compute a sparse Jacobian.
|
| |
| template<PiecewiseLinear > |
| int | ADOLC::Sparse::detail::buildJacPatternAndSeed (short tag, int depen, int indep, int numSwitches, const double *basepoint) |
| | Build pattern and seed data for the piecewise-linear sparse Jacobian.
|
| |
| template<CompressionMode CM, MemoryHandler MH> |
| void | ADOLC::Sparse::detail::recover (const ValueTape &tape, SparseMatrix &sparseJac) |
| | Passes args to jacobian-recover method based on the template-args.
|
| |
| template<MemoryHandler MH> |
| void | ADOLC::Sparse::detail::recover (const ValueTape &tape, SparseANF &sparseANF) |
| | Passes args to ANF recovery methods based on the template args.
|
| |
| template<CompressionMode CM, MemoryHandler MH> |
| int | ADOLC::Sparse::detail::computeSparseJac (short tag, int depen, int indep, const double *basepoint, SparseMatrix &sparseJac) |
| | Compute sparse Jacobian using precomputed seed matrix and recovery information.
|
| |
| template<MemoryHandler MH> |
| int | ADOLC::Sparse::detail::computeSparseJac (short tag, int depen, int indep, int numSwitches, const double *basepoint, SparseANF &sparseANF) |
| | Recover the piecewise-linear sparse Jacobian into ANF blocks.
|
| |
| template<SparseMethod SM = SparseMethod::IndexDomains, CompressionMode CM = CompressionMode::Column, ControlFlowMode CFM = ControlFlowMode::Safe, BitPatternPropagationDirection BPPD = BitPatternPropagationDirection::Auto, MemoryHandler MH = MemoryHandler::Auto> |
| ADOLC_API int | ADOLC::Sparse::sparse_jac (short tag, int depen, int indep, int repeat, const double *basepoint, SparseMatrix &sparseJac) |
| | High-level API to compute a sparse Jacobian (single call or repeat).
|
| |
| template<PiecewiseLinear PL = PiecewiseLinear{}, MemoryHandler MH = MemoryHandler::Auto> |
| ADOLC_API int | ADOLC::Sparse::sparse_jac (short tag, int depen, int indep, int numSwitches, int repeat, const double *basepoint, SparseANF &sparseANF) |
| | Compute the sparse extended Jacobian of a piecewise-linear abs-normal form in block form.
|
| |
| template<ControlFlowMode CFM> |
| ADOLC_API int | ADOLC::Sparse::hess_pat (short tag, int indep, const double *basepoint, std::span< uint * > &compressedRowStorage) |
| | Compute Hessian sparsity pattern (dispatch by control-flow mode).
|
| |
| template<RecoveryMethod RCM> |
| ADOLC_API void | ADOLC::Sparse::generate_seed_hess (int n, std::span< uint * > HP, double ***Seed, int *p) |
| | Generate a seed matrix for compressed Hessian recovery.
|
| |
| template<ControlFlowMode CFM, RecoveryMethod RCM> |
| int | ADOLC::Sparse::detail::buildHessPatternAndSeed (short tag, int indep, const double *basepoint, int *nnz) |
| | Build Hessian sparsity pattern and generate ColPack seed for recovery.
|
| |
| template<RecoveryMethod RCM> |
| int | ADOLC::Sparse::detail::computeSparseHess (short tag, int indep, const double *basepoint, int *nnz, unsigned int **rind, unsigned int **cind, double **values) |
| | Compute sparse Hessian using precomputed seed/recovery info.
|
| |
| template<ControlFlowMode CFM, RecoveryMethod RCM> |
| ADOLC_API int | ADOLC::Sparse::sparse_hess (short tag, int indep, int repeat, const double *basepoint, int *nnz, unsigned int **rind, unsigned int **cind, double **values) |
| | High-level API to compute a sparse Hessian.
|
| |
