|
| class | AdvectiveStress |
| | Variational advective stress associated with swelling induced volume change. More...
|
| |
| class | AnisotropicElasticity |
| |
| class | ArrheniusParameter |
| | A scalar-valued parameter following an Arrhenius type relation. More...
|
| |
| class | AssociativeIsotropicPlasticHardening |
| |
| class | AssociativeJ2FlowDirection |
| | The plastic flow direction assuming an associative J2 flow. More...
|
| |
| class | AssociativeKinematicPlasticHardening |
| |
| class | AssociativePlasticFlow |
| |
| class | AvramiErofeevNucleation |
| | Avrami-Erofeev nucleation model. More...
|
| |
| class | BackwardEulerTimeIntegration |
| |
| class | BilinearInterpolation |
| | Linearly interpolate the parameter along on a 2D grid. More...
|
| |
| class | BrooksCoreyCapillaryPressure |
| | Define the Brooks-Corey correlation for capillary pressure. More...
|
| |
| class | BufferStore |
| | Interface for object which can store buffers. More...
|
| |
| class | CapillaryPressure |
| | Base class for capillary pressure models in porous flow. More...
|
| |
| class | ChabochePlasticHardening |
| |
| class | ComposedModel |
| |
| struct | concat_seq |
| |
| struct | concat_seq< std::integer_sequence< Size, A... >, std::integer_sequence< Size, B... > > |
| |
| class | ConstantParameter |
| | A parameter that is actually just a constant. More...
|
| |
| class | ContractingGeometry |
| | Contracting geometry model in the context of solid-state reaction kinetics. More...
|
| |
| class | CopyVariable |
| | Copy the value of a variable into another variable. More...
|
| |
| class | CrackGeometricFunction |
| |
| class | CrackGeometricFunctionAT1 |
| |
| class | CrackGeometricFunctionAT2 |
| |
| class | CubicElasticityConverter |
| | Converter for linearized elastic constants assuming cubic symmetry. More...
|
| |
| class | CubicElasticityTensor |
| | Define an cubic symmetry elasticity tensor in various ways. More...
|
| |
| class | CylindricalChannelGeometry |
| |
| class | Data |
| |
| class | DegradationFunction |
| |
| class | DependencyDefinition |
| |
| class | DependencyResolver |
| | The DependencyResolver identifies and resolves the dependencies among a set of objects derived from DependencyDefinition. More...
|
| |
| class | Derivative |
| | Derivative wrapper. More...
|
| |
| class | Determinant |
| | Determinant of a rank two tensor. More...
|
| |
| struct | Diagnosing |
| |
| class | Diagnosis |
| | Exception type reserved for diagnostics, so as to not conceptually clash with other exceptions. More...
|
| |
| class | DiagnosticsInterface |
| | Interface for object making diagnostics about common setup errors. More...
|
| |
| struct | DiagnosticState |
| |
| class | DiffusionLimitedReaction |
| |
| class | Driver |
| | The Driver drives the execution of a NEML2 Model. More...
|
| |
| class | DTensor |
| | Abstract representation of the derivative of a primitive tensor with respect to another primitive tensor. More...
|
| |
| struct | DTensorBase |
| |
| struct | DTensorBase< Derived, std::integer_sequence< Size, S... > > |
| |
| class | DynamicMean |
| |
| class | DynamicSum |
| |
| class | EffectiveSaturation |
| | Define the effective saturation. More...
|
| |
| class | EffectiveVolume |
| | Update the effective volume of a control mass composite during reaction. More...
|
| |
| class | Eigenstrain |
| |
| class | Elasticity |
| |
| class | ElasticityConverter |
| | Base class for converters responsible for converting between different parameterizations of the linear elasticity tensor in different symmetry groups. More...
|
| |
| class | ElasticityInterface |
| | Interface for objects defining elasticity tensors in terms of other parameters. More...
|
| |
| class | ElasticStrainRate |
| | Calculate the elastic strain rate from crystal model kinematics. More...
|
| |
| class | EnumSelection |
| | Selection of an enum value from a list of choices. More...
|
| |
| class | EnumSelectionBase |
| |
| class | ExponentialLawPermeability |
| |
| class | Factory |
| |
| class | FactoryException |
| |
| class | FactoryMethodBase |
| | Create an empty tensor of type T from the input file. More...
|
| |
| class | FillR2 |
| | Create a filled R2 from the input file. More...
|
| |
| class | FillRot |
| | Create a filled R2 from the input file. More...
|
| |
| class | FillSR2 |
| | Create a filled SR2 from the input file. More...
|
| |
| class | FillWR2 |
| | Create a filled WR2 from the input file. More...
|
| |
| class | FischerBurmeister |
| | Define the Fischer Burmeister Complementary Conditions. More...
|
| |
| class | FixedSizeWorkGenerator |
| | Interface for work generators that generate a fixed number of batches, i.e., the total amount of work is known at construction time. More...
|
| |
| class | FixOrientation |
| | Swap orientation plane when the singularity at \( 2 \pi \) is met with the modified Rodrigues vector. More...
|
| |
| class | FlowRule |
| |
| class | ForwardEulerTimeIntegration |
| |
| class | FredrickArmstrongPlasticHardening |
| |
| class | FromTorchScript |
| | Read the tensors provided by a torch script file. More...
|
| |
| class | FullTensorTmpl |
| | Create a full tensor of type T from the input file. More...
|
| |
| class | GeneralElasticity |
| |
| class | GreenLagrangeStrain |
| |
| class | GTNYieldFunction |
| |
| class | GursonCavitation |
| |
| class | HermiteSmoothStep |
| |
| class | HITParser |
| | A parser is responsible for parsing an input file into a collection of options which can be used by the Factory to manufacture corresponding objects. More...
|
| |
| class | IdentityTensor |
| | Create an identity Tensor from the input file. More...
|
| |
| struct | imap_t |
| |
| struct | imap_t< R2 > |
| |
| struct | imap_t< Scalar > |
| |
| struct | imap_t< SR2 > |
| |
| struct | imap_t< Vec > |
| |
| class | ImplicitUpdate |
| |
| class | IncrementToRate |
| |
| class | InputFile |
| | A data structure that holds options of multiple objects. More...
|
| |
| class | InputParameter |
| | A parameter that is defined by an input variable. More...
|
| |
| class | IntermediateMean |
| |
| class | IntermediateSum |
| |
| class | Interpolation |
| | The base class for interpolated variable. More...
|
| |
| class | IsotropicElasticityConverter |
| | Converter for linearized elastic constants assuming isotropic symmetry. More...
|
| |
| class | IsotropicElasticityTensor |
| | Define an isotropoic elasticity tensor in various ways. More...
|
| |
| class | IsotropicHardening |
| |
| class | IsotropicHardeningStaticRecovery |
| |
| class | IsotropicMandelStress |
| |
| class | KinematicHardening |
| |
| class | KinematicHardeningStaticRecovery |
| |
| class | KocksMeckingActivationEnergy |
| |
| class | KocksMeckingFlowSwitch |
| |
| class | KocksMeckingFlowViscosity |
| | A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C) More...
|
| |
| class | KocksMeckingIntercept |
| | A scalar-valued parameter defined by (C-B) / A. More...
|
| |
| class | KocksMeckingRateSensitivity |
| | A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C) More...
|
| |
| class | KocksMeckingYieldStress |
| | A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C) More...
|
| |
| class | KozenyCarmanPermeability |
| | The Kozeny-Carman porosity-permeability relation. More...
|
| |
| class | LabeledAxis |
| | A labeled axis is used to associate layout of a tensor with human-interpretable names. More...
|
| |
| class | LabeledAxisAccessor |
| | The accessor containing all the information needed to access an item in a LabeledAxis. More...
|
| |
| class | LDISolidMechanicsDriver |
| | Large deformation incremental solid mechanics driver. More...
|
| |
| class | LinearCombination |
| |
| class | LinearInterpolation |
| | Linearly interpolate the parameter along an intermediate axis. More...
|
| |
| class | LinearIsotropicElasticity |
| |
| class | LinearIsotropicElasticJ2TrialStressUpdate |
| | Update the trial stress under the assumptions of J2 plasticity and isotropic linear elasticity. More...
|
| |
| class | LinearIsotropicHardening |
| | Simple linear map between equivalent strain and isotropic hardening. More...
|
| |
| class | LinearIsotropicStrainEnergyDensity |
| |
| class | LinearKinematicHardening |
| | Simple linear map between equivalent strain and hardening. More...
|
| |
| class | LinearSingleSlipHardeningRule |
| | Linear slip hardening of the type \(\dot{\bar{\tau}} = \theta \sum \left|\dot{\gamma}_i \right|\). More...
|
| |
| class | LinspaceTensorTmpl |
| | Create a linspace tensor of type T from the input file. More...
|
| |
| class | LogspaceTensorTmpl |
| | Create a logspace tensor of type T from the input file. More...
|
| |
| class | MandelStress |
| |
| class | MatrixAssembler |
| | Helper to assemble a matrix of tensors into a single tensor and also to split a tensor into a map of map of tensors. More...
|
| |
| class | MillerIndex |
| | Represention of a crystal direction or plane a Miller Index. More...
|
| |
| class | MixedControlSetup |
| |
| class | Model |
| | The base class for all constitutive models. More...
|
| |
| class | ModelDriver |
| | A general-purpose driver that does something with a model. More...
|
| |
| class | MultiEnumSelection |
| | Selection of multiple enum value from a list of choices. More...
|
| |
| class | NEML2Object |
| | The base class of all "manufacturable" objects in the NEML2 library. More...
|
| |
| struct | NEML2ObjectInfo |
| | Information on a NEML2Object that is registered in the Registry. More...
|
| |
| class | NEMLException |
| |
| class | Newton |
| | The nonlinear solver solves a nonlinear system of equations. More...
|
| |
| class | NewtonWithLineSearch |
| | The nonlinear solver solves a nonlinear system of equations. More...
|
| |
| class | NewtonWithTrustRegion |
| | The nonlinear solver solves a nonlinear system of equations. More...
|
| |
| struct | NonlinearParameter |
| | Nonlinear parameter. More...
|
| |
| class | NonlinearSolver |
| | The nonlinear solver solves a nonlinear system of equations. More...
|
| |
| class | NonlinearSystem |
| | Definition of a nonlinear system of equations. More...
|
| |
| class | Normality |
| |
| class | OlevskySinteringStress |
| |
| class | Option |
| |
| class | OptionBase |
| |
| class | OptionSet |
| | A custom map-like data structure. The keys are strings, and the values can be nonhomogeneously typed. More...
|
| |
| class | Orientation |
| | Create batch of rotations, with various methods. More...
|
| |
| class | OrientationRate |
| | Calculate the orientation rate from the crystal model kinetics. More...
|
| |
| class | ParameterStore |
| | Interface for object which can store parameters. More...
|
| |
| class | ParameterToState |
| | Convert a parameter to a state variable. More...
|
| |
| class | Parser |
| | A parser is responsible for parsing an input file into a collection of options which can be used by the Factory to manufacture corresponding objects. More...
|
| |
| class | ParserException |
| |
| class | PerzynaPlasticFlowRate |
| |
| class | PhaseTransformationEigenstrain |
| | Define the phase transformation eigenstrain. More...
|
| |
| class | PlasticDeformationRate |
| | Plastic deformation rate with the default kinetics. More...
|
| |
| class | PlasticFlowRate |
| |
| class | PlasticSpatialVelocityGradient |
| | Plastic spatial velocity gradient with the default kinetics. More...
|
| |
| class | PlasticVorticity |
| | Calculate the plastic vorticity with the default crystal kinetics. More...
|
| |
| class | PorosityPermeabilityRelation |
| | Base class for the porosity - permeability relations. More...
|
| |
| class | PowerDegradationFunction |
| |
| class | PowerLawIsotropicHardeningStaticRecovery |
| |
| class | PowerLawKinematicHardeningStaticRecovery |
| |
| class | PowerLawPermeability |
| | power law porosity-permeability relation. More...
|
| |
| class | PowerLawSlipRule |
| | Power law slip rate of the form \(\dot{\gamma}_i = \dot{\gamma}_0 \left| \frac{\tau_i}{\tau_{h,i}} \right| ^ {n-1} \frac{\tau_i}{\tau_{h,i}} \). More...
|
| |
| class | PrimitiveTensor |
| | PrimitiveTensor inherits from TensorBase and additionally templates on the base shape. More...
|
| |
| class | ProjectileAcceleration |
| |
| class | Quaternion |
| | Quaternion. More...
|
| |
| class | R2 |
| | Base class for second order tensor. More...
|
| |
| class | R2Multiplication |
| | Multiplication of two R2 variables. More...
|
| |
| class | R2toSR2 |
| | Get the symmetric part of a full rank two tensor. More...
|
| |
| class | R2toWR2 |
| | Get the skew symmetric part of a full rank two tensor. More...
|
| |
| class | R3 |
| | Third order tensor without symmetry. More...
|
| |
| class | R4 |
| | Fourth order tensor without symmetry. More...
|
| |
| class | RandomTensorImpl |
| | Create a random tensor of type T from the input file. More...
|
| |
| class | RateIndependentPlasticFlowConstraint |
| |
| class | RationalDegradationFunction |
| |
| class | ReactionMechanism |
| | Define the mechanism reaction function. More...
|
| |
| class | Reduction |
| |
| class | Registry |
| |
| class | ResolvedShear |
| | Calculate the resolved shears. More...
|
| |
| class | Rot |
| | Rotation stored as modified Rodrigues parameters. More...
|
| |
| class | RotationMatrix |
| | Convert a Rodrigues vector (Rot) to a second order tensor (R2). More...
|
| |
| class | Scalar |
| | Scalar. More...
|
| |
| class | ScalarMultiplication |
| | Define the multiplication of arbitrary number of state variables. More...
|
| |
| class | ScalarToDiagonalSR2 |
| | Create a diagonal symmetric rank 2 tensor with values filled by a scalar. More...
|
| |
| class | SDTSolidMechanicsDriver |
| | Small deformation total solid mechanics driver. More...
|
| |
| class | Settings |
| |
| class | SetupException |
| |
| class | SFFR4 |
| | The fourth order tensor with minor symmetry in the 1st and 2nd dimensions. More...
|
| |
| class | SFR3 |
| | The third order tensor with symmetry in the first two dimensions. More...
|
| |
| class | SimpleMPIScheduler |
| | A simple MPI scheduler. More...
|
| |
| class | SimpleScheduler |
| | A very simple scheduler. More...
|
| |
| class | SingleSlipHardeningRule |
| | Any slip rule where all systems share the same strength. More...
|
| |
| class | SingleSlipStrengthMap |
| | A map between the internal variables and the slip strength, for the case where all systems share the same strength. More...
|
| |
| class | SliceGenerator |
| |
| class | SlipRule |
| | Parent class of slip rules, mapping from resolved shear and internal state to slip rates. More...
|
| |
| class | SlipStrengthMap |
| | Parent class of maps between internal variables and the slip system strengths. More...
|
| |
| class | SlopeSaturationVoceIsotropicHardening |
| |
| class | SolidMechanicsDriver |
| | The transient driver specialized for solid mechanics problems. More...
|
| |
| class | Solver |
| | The solver solves a system of equations. More...
|
| |
| struct | SolvingNonlinearSystem |
| |
| class | SR2 |
| | The symmetric second order tensor. More...
|
| |
| class | SR2Invariant |
| |
| class | SR2toR2 |
| | Convert symmetric rank two tensor to full. More...
|
| |
| class | SSR4 |
| | The symmetric fourth order tensor, with symmetry in the first two dimensionss as well as in the last two dimensions. More...
|
| |
| class | StaticHybridScheduler |
| | A scheduler for multiple devices with static priority management. More...
|
| |
| class | StrainEnergyDensity |
| |
| class | SumSlipRates |
| | A helper model to calculate the sum of the absolute value of the slip rates. More...
|
| |
| class | SwellingAndPhaseChangeDeformationJacobian |
| |
| class | SWR4 |
| | The symmetric fourth order tensor, with symmetry in the first two dimensionss and skew-symmetry in the second two. More...
|
| |
| class | SymmetricHermiteInterpolation |
| |
| class | SymmetryFromOrbifold |
| | Provide the correct symmetry operators for a given crystal class. More...
|
| |
| class | Tensor |
| |
| class | TensorBase |
| | NEML2's enhanced tensor type. More...
|
| |
| struct | TensorCache |
| |
| class | TensorLoader |
| |
| struct | TensorName |
| | The name of a tensor object that can be referenced in the input files. More...
|
| |
| struct | TensorTypeEnum |
| |
| class | TensorValue |
| | Concrete definition of tensor value. More...
|
| |
| class | TensorValueBase |
| | The base class to allow us to set up a polymorphic container of Tensors. The concrete definitions will be templated on the actual tensor type. More...
|
| |
| class | ThermalDeformationJacobian |
| |
| class | ThermalEigenstrain |
| |
| struct | TimedSection |
| |
| struct | TraceableSize |
| | Traceable size. More...
|
| |
| struct | TraceableTensorShape |
| | Traceable tensor shape. More...
|
| |
| struct | TracerPrivilege |
| | A passkey to allow trusted classes to perform raw assignment to variables and parameters. More...
|
| |
| struct | TraceWriter |
| |
| class | TracingInterface |
| |
| class | Transformable |
| | Mixin class for things that can be transformed by a symmetry operator. More...
|
| |
| class | TransientDriver |
| | The driver for a transient initial-value problem. More...
|
| |
| class | TrustRegionSubProblem |
| |
| class | TwoStageThermalAnnealing |
| |
| class | UserTensorBase |
| |
| class | UserTensorTmpl |
| | Create raw tensor of type T from the input file. More...
|
| |
| class | ValueMapLoader |
| |
| class | VanGenuchtenCapillaryPressure |
| | van Genuchten correlation for capillary pressure More...
|
| |
| class | Variable |
| | Concrete definition of a variable. More...
|
| |
| class | VariableBase |
| | Base class of variable. More...
|
| |
| class | VariableRate |
| |
| class | VariableStore |
| |
| class | Vec |
| | 3-vector. More...
|
| |
| class | VecBase |
| | Base class 3-vector. More...
|
| |
| class | VectorAssembler |
| | Helper to assemble a vector of tensors into a single tensor and also to split a tensor into a map of tensors. More...
|
| |
| class | VoceIsotropicHardening |
| |
| class | VoceSingleSlipHardeningRule |
| | Voce slip hardening when all slip systems share the same hardening value, \(\dot{\bar{\tau}} = \theta_0 \left(1 - \frac{\bar{\tau}}{\tau_{sat}} \right) \sum \left|\dot{\gamma}_i \right|\). More...
|
| |
| class | VolumeAdjustDeformationGradient |
| | Calculate the volume-adjusted deformation gradient. More...
|
| |
| class | VolumeChangeEigenstrain |
| | Define the volume change eigenstrain. More...
|
| |
| class | WFFR4 |
| | The fourth order tensor with skew symmetry in the first two dimensions. More...
|
| |
| class | WorkDispatcher |
| | The work dispatcher who dispatches work to a worker and reduces the results. More...
|
| |
| class | WorkGenerator |
| |
| class | WorkScheduler |
| | Scheduler for work dispatching. More...
|
| |
| class | WR2 |
| | A skew-symmetric second order tensor, represented as an axial vector. More...
|
| |
| class | WR2ExplicitExponentialTimeIntegration |
| | Explicit exponential time integration for rotations. More...
|
| |
| class | WR2ImplicitExponentialTimeIntegration |
| | Implicit exponential time integration for rotations. More...
|
| |
| class | WSR4 |
| | The symmetric fourth order tensor, with skew symmetry in the first two dimensionss and symmetry in the second two. More...
|
| |
| class | WWR4 |
| | The symmetric fourth order tensor, with skew symmetry in the first two dimensions and last two dimensions. More...
|
| |
| class | YieldFunction |
| |
|
| DiagnosticState & | current_diagnostic_state () |
| | Get the current diagnostic state.
|
| |
| std::vector< Diagnosis > & | current_diagnoses () |
| | Get the current diagnoses.
|
| |
| std::vector< Diagnosis > | diagnose (const DiagnosticsInterface &) |
| | A helper function to diagnose common setup errors.
|
| |
| void | diagnose_and_throw (const DiagnosticsInterface &) |
| | A helper function to diagnose common setup errors and throw an exception if any errors are found.
|
| |
| std::ostream & | operator<< (std::ostream &os, const EnumSelection &es) |
| |
| std::stringstream & | operator>> (std::stringstream &ss, EnumSelection &es) |
| |
| std::unique_ptr< Factory > | load_input (const std::filesystem::path &path, const std::string &additional_input="") |
| | A convenient function to parse all options from an input file.
|
| |
| std::map< std::string, std::map< std::string, unsigned long > > & | timed_sections () |
| |
| std::ostream & | operator<< (std::ostream &os, const InputFile &p) |
| |
| std::ostream & | operator<< (std::ostream &os, const LabeledAxis &axis) |
| |
| bool | operator== (const LabeledAxis &a, const LabeledAxis &b) |
| |
| bool | operator!= (const LabeledAxis &a, const LabeledAxis &b) |
| |
| std::vector< std::string > | reserved_subaxis_names () |
| |
| | LabeledAxisAccessor::operator std::vector< std::string > () const |
| |
| bool | operator!= (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b) |
| | Compare for equality between two LabeledAxisAccessor.
|
| |
| bool | operator== (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b) |
| | Compare for equality between two LabeledAxisAccessor.
|
| |
| bool | operator< (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b) |
| | The (strict) smaller than operator is created so as to use LabeledAxisAccessor in sorted data structures.
|
| |
| std::ostream & | operator<< (std::ostream &os, const LabeledAxisAccessor &accessor) |
| | Serialize the accessor into a string. The format is simply the concatenation of all the item names delimited by "/".
|
| |
| std::ostream & | operator<< (std::ostream &os, const MultiEnumSelection &es) |
| |
| std::stringstream & | operator>> (std::stringstream &ss, MultiEnumSelection &es) |
| |
| | FOR_ALL_TENSORBASE (NEML2OBJECT_INSTANTIATE) |
| |
| | FOR_ALL_TENSORBASE (INSTANTIATE_TENSORNAME) |
| |
| std::ostream & | operator<< (std::ostream &os, const OptionBase &opt) |
| |
| bool | options_compatible (const OptionSet &opts, const OptionSet &additional_opts) |
| |
| std::ostream & | operator<< (std::ostream &os, const OptionSet &p) |
| |
| | FOR_ALL_TENSORBASE (INSTANTIATE) |
| |
| std::unordered_map< std::string, std::unique_ptr< TraceWriter > > & | event_trace_writers () |
| | All trace writers.
|
| |
| DerivMap | derivmap_cat_reduce (std::vector< DerivMap > &&results, Size dynamic_dim) |
| | Concatenate the tensors in the DerivMap along the batch dimension.
|
| |
| DerivMap | derivmap_move_device (DerivMap &&x, Device device) |
| | Move all tensors in a DerivMap to a device.
|
| |
| DerivMap | derivmap_no_operation (DerivMap &&x) |
| | No operation.
|
| |
| | register_NEML2_object (SimpleMPIScheduler) |
| |
| | register_NEML2_object (SimpleScheduler) |
| |
| | register_NEML2_object (StaticHybridScheduler) |
| |
| ValueMap | valuemap_cat_reduce (const std::vector< ValueMap > &results, Size dynamic_dim) |
| | Concatenate the tensors in the ValueMap along the batch dimension.
|
| |
| ValueMap | valuemap_move_device (ValueMap &&x, Device device) |
| | Move all tensors in a ValueMap to a device.
|
| |
| ValueMap | valuemap_no_operation (ValueMap &&x) |
| | No operation.
|
| |
| | register_NEML2_object (LDISolidMechanicsDriver) |
| |
| | register_NEML2_object (SDTSolidMechanicsDriver) |
| |
| | register_NEML2_object (TransientDriver) |
| |
| double | machine_precision (Dtype dtype) |
| |
| std::ostream & | operator<< (std::ostream &os, FType f) |
| |
| | register_NEML2_object (ArrheniusParameter) |
| |
| | register_NEML2_object (ScalarBackwardEulerTimeIntegration) |
| |
| | register_NEML2_object (VecBackwardEulerTimeIntegration) |
| |
| | register_NEML2_object (SR2BackwardEulerTimeIntegration) |
| |
| | register_NEML2_object (R2BackwardEulerTimeIntegration) |
| |
| | register_NEML2_object (ScalarBilinearInterpolation) |
| |
| | register_NEML2_object (VecBilinearInterpolation) |
| |
| | register_NEML2_object (SR2BilinearInterpolation) |
| |
| | FOR_ALL_TENSORBASE (BUFFERSTORE_INTANTIATE_TENSORBASE) |
| |
| | register_NEML2_object (AvramiErofeevNucleation) |
| |
| | register_NEML2_object (ContractingGeometry) |
| |
| | register_NEML2_object (CylindricalChannelGeometry) |
| |
| | register_NEML2_object (DiffusionLimitedReaction) |
| |
| | register_NEML2_object (EffectiveVolume) |
| |
| | register_NEML2_object (ComposedModel) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER_CONSTANTPARAMETER) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER_COPYVARIABLE) |
| |
| | register_NEML2_object (R2Determinant) |
| |
| | register_NEML2_object (SR2Determinant) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER_DYNAMICMEAN) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER_DYNAMICSUM) |
| |
| | register_NEML2_object (FischerBurmeister) |
| |
| | register_NEML2_object (ScalarForwardEulerTimeIntegration) |
| |
| | register_NEML2_object (VecForwardEulerTimeIntegration) |
| |
| | register_NEML2_object (SR2ForwardEulerTimeIntegration) |
| |
| | register_NEML2_object (HermiteSmoothStep) |
| |
| | register_NEML2_object (ImplicitUpdate) |
| |
| | register_NEML2_object (ScalarIncrementToRate) |
| |
| | register_NEML2_object (VecIncrementToRate) |
| |
| | register_NEML2_object (SR2IncrementToRate) |
| |
| | register_NEML2_object (R2IncrementToRate) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER_INTERMEDIATEMEAN) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER_INTERMEDIATESUM) |
| |
| std::tuple< Scalar, Scalar, Scalar > | parametric_coordinates (const Scalar &X, const Scalar &x) |
| |
| | FOR_ALL_PRIMITIVETENSOR (INSTANTIATE) |
| |
| | register_NEML2_object (ScalarLinearCombination) |
| |
| | register_NEML2_object (VecLinearCombination) |
| |
| | register_NEML2_object (SR2LinearCombination) |
| |
| | register_NEML2_object (R2LinearCombination) |
| |
| | register_NEML2_object (ScalarLinearInterpolation) |
| |
| | register_NEML2_object (VecLinearInterpolation) |
| |
| | register_NEML2_object (SR2LinearInterpolation) |
| |
| | register_NEML2_object (MixedControlSetup) |
| |
| std::shared_ptr< Model > | load_model (const std::filesystem::path &path, const std::string &mname) |
| | A convenient function to load an input file and get a model.
|
| |
| std::ostream & | operator<< (std::ostream &os, const Model &model) |
| |
| template<typename T > |
| const T & | resolve_tensor_name (const TensorName< T > &tn, Model *caller, const std::string &pname) |
| |
| | FOR_ALL_TENSORBASE (PARAMETERSTORE_INTANTIATE_TENSORBASE) |
| |
| | FOR_ALL_PRIMITIVETENSOR (PARAMETERSTORE_INTANTIATE_PRIMITIVETENSOR) |
| |
| | register_NEML2_object (CrackGeometricFunctionAT1) |
| |
| | register_NEML2_object (CrackGeometricFunctionAT2) |
| |
| | register_NEML2_object (LinearIsotropicStrainEnergyDensity) |
| |
| | register_NEML2_object (PowerDegradationFunction) |
| |
| | register_NEML2_object (RationalDegradationFunction) |
| |
| | register_NEML2_object (AdvectiveStress) |
| |
| | register_NEML2_object (BrooksCoreyCapillaryPressure) |
| |
| | register_NEML2_object (EffectiveSaturation) |
| |
| | register_NEML2_object (ExponentialLawPermeability) |
| |
| | register_NEML2_object (KozenyCarmanPermeability) |
| |
| | register_NEML2_object (PowerLawPermeability) |
| |
| | register_NEML2_object (VanGenuchtenCapillaryPressure) |
| |
| | register_NEML2_object (R2Multiplication) |
| |
| | register_NEML2_object (R2toSR2) |
| |
| | register_NEML2_object (R2toWR2) |
| |
| | FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_REDUCTION) |
| |
| | register_NEML2_object (RotationMatrix) |
| |
| | register_NEML2_object (ScalarMultiplication) |
| |
| | register_NEML2_object (ScalarToDiagonalSR2) |
| |
| | register_NEML2_object (AssociativeIsotropicPlasticHardening) |
| |
| | register_NEML2_object (AssociativeJ2FlowDirection) |
| |
| | register_NEML2_object (AssociativeKinematicPlasticHardening) |
| |
| | register_NEML2_object (AssociativePlasticFlow) |
| |
| | register_NEML2_object (ChabochePlasticHardening) |
| |
| | register_NEML2_object (ElasticStrainRate) |
| |
| | register_NEML2_object (FixOrientation) |
| |
| | register_NEML2_object (LinearSingleSlipHardeningRule) |
| |
| | register_NEML2_object (OrientationRate) |
| |
| | register_NEML2_object (PlasticDeformationRate) |
| |
| | register_NEML2_object (PlasticSpatialVelocityGradient) |
| |
| | register_NEML2_object (PlasticVorticity) |
| |
| | register_NEML2_object (PowerLawSlipRule) |
| |
| | register_NEML2_object (ResolvedShear) |
| |
| | register_NEML2_object (SingleSlipStrengthMap) |
| |
| | register_NEML2_object (SumSlipRates) |
| |
| | register_NEML2_object (VoceSingleSlipHardeningRule) |
| |
| | register_NEML2_object (CubicElasticityTensor) |
| |
| std::string | name (ElasticConstant p) |
| |
| | register_NEML2_object (GeneralElasticity) |
| |
| | register_NEML2_object (GreenLagrangeStrain) |
| |
| | register_NEML2_object (IsotropicElasticityTensor) |
| |
| | register_NEML2_object (LinearIsotropicElasticity) |
| |
| | register_NEML2_object (FredrickArmstrongPlasticHardening) |
| |
| | register_NEML2_object (GTNYieldFunction) |
| |
| | register_NEML2_object (GursonCavitation) |
| |
| | register_NEML2_object (IsotropicMandelStress) |
| |
| | register_NEML2_object (KocksMeckingActivationEnergy) |
| |
| | register_NEML2_object (KocksMeckingFlowSwitch) |
| |
| | register_NEML2_object (KocksMeckingFlowViscosity) |
| |
| | register_NEML2_object (KocksMeckingIntercept) |
| |
| | register_NEML2_object (KocksMeckingRateSensitivity) |
| |
| | register_NEML2_object (KocksMeckingYieldStress) |
| |
| | register_NEML2_object (LinearIsotropicElasticJ2TrialStressUpdate) |
| |
| | register_NEML2_object (LinearIsotropicHardening) |
| |
| | register_NEML2_object (LinearKinematicHardening) |
| |
| | register_NEML2_object (Normality) |
| |
| | register_NEML2_object (OlevskySinteringStress) |
| |
| | register_NEML2_object (PerzynaPlasticFlowRate) |
| |
| | register_NEML2_object (PhaseTransformationEigenstrain) |
| |
| | register_NEML2_object (PowerLawIsotropicHardeningStaticRecovery) |
| |
| | register_NEML2_object (PowerLawKinematicHardeningStaticRecovery) |
| |
| | register_NEML2_object (RateIndependentPlasticFlowConstraint) |
| |
| | register_NEML2_object (SlopeSaturationVoceIsotropicHardening) |
| |
| | register_NEML2_object (SwellingAndPhaseChangeDeformationJacobian) |
| |
| | register_NEML2_object (ThermalDeformationJacobian) |
| |
| | register_NEML2_object (ThermalEigenstrain) |
| |
| | register_NEML2_object (ScalarTwoStageThermalAnnealing) |
| |
| | register_NEML2_object (SR2TwoStageThermalAnnealing) |
| |
| | register_NEML2_object (VoceIsotropicHardening) |
| |
| | register_NEML2_object (VolumeAdjustDeformationGradient) |
| |
| | register_NEML2_object (VolumeChangeEigenstrain) |
| |
| | register_NEML2_object (YieldFunction) |
| |
| | register_NEML2_object (SR2Invariant) |
| |
| | register_NEML2_object (SR2toR2) |
| |
| | register_NEML2_object (SymmetricHermiteInterpolation) |
| |
| | FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_VARIABLE) |
| |
| | register_NEML2_object (ScalarVariableRate) |
| |
| | register_NEML2_object (VecVariableRate) |
| |
| | register_NEML2_object (SR2VariableRate) |
| |
| | FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_DECLARE_INPUT_VARIABLE) |
| |
| | FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_DECLARE_OUTPUT_VARIABLE) |
| |
| | FOR_ALL_PRIMITIVETENSOR (INSTANTIATE_CREATE_VARIABLE) |
| |
| | register_NEML2_object (WR2ExplicitExponentialTimeIntegration) |
| |
| | register_NEML2_object (WR2ImplicitExponentialTimeIntegration) |
| |
| | register_NEML2_object (Newton) |
| |
| | register_NEML2_object (NewtonWithLineSearch) |
| |
| | register_NEML2_object (NewtonWithTrustRegion) |
| |
| bool & | currently_solving_nonlinear_system () |
| |
| | FOR_ALL_TENSORBASE (DEFINE_ABS) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_ARCCOS) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_ARGMAX) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_ARGMIN) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_ARCSIN) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_ARCTAN) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_CAT) |
| |
| Tensor | base_cat (const std::vector< Tensor > &tensors, Size d) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_CBRT) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_CLAMP) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_CLIP) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_COS) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_COSH) |
| |
| Vec | cross (const Vec &u, const Vec &v) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_DEG2RAD) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_DIAGONALIZE) |
| |
| Tensor | base_diagonalize (const Tensor &a, Size d) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_DIFF) |
| |
| Tensor | base_diff (const Tensor &a, Size n, Size dim) |
| |
| Tensor | einsum (c10::string_view equation, TensorList tensors) |
| | Einstein summation along base dimensions.
|
| |
| | FOR_ALL_TENSORBASE (DEFINE_EXP) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_FMOD) |
| |
| template<std::size_t N> |
| Tensor | from_assembly (const Tensor &from, const std::array< TensorShapeRef, N > &intmd_shapes, const std::array< TensorShapeRef, N > &base_shapes, const std::string &debug_name) |
| |
| template Tensor | from_assembly< 1 > (const Tensor &, const std::array< TensorShapeRef, 1 > &, const std::array< TensorShapeRef, 1 > &, const std::string &) |
| |
| template Tensor | from_assembly< 2 > (const Tensor &, const std::array< TensorShapeRef, 2 > &, const std::array< TensorShapeRef, 2 > &, const std::string &) |
| |
| template Tensor | from_assembly< 3 > (const Tensor &, const std::array< TensorShapeRef, 3 > &, const std::array< TensorShapeRef, 3 > &, const std::string &) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_GCD) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_HEAVISIDE) |
| |
| Scalar | inner (const Tensor &a, const Tensor &b) |
| | Inner product.
|
| |
| Tensor | inv (const Tensor &) |
| | Inverse of a second order or fourth order tensor.
|
| |
| Rot | inv (const Rot &) |
| | Inverse of a rotation (MRP)
|
| |
| std::vector< Tensor > | jacrev (const Tensor &y, const std::vector< Tensor > &xs, bool retain_graph=false, bool create_graph=false, bool allow_unused=false) |
| | Use automatic differentiation (AD) to calculate the derivatives of a Tensor w.r.t. another Tensor.
|
| |
| Tensor | jacrev (const Tensor &y, const Tensor &x, bool retain_graph=false, bool create_graph=false, bool allow_unused=false) |
| | Similar to the other jacrev, but for a single input.
|
| |
| | FOR_ALL_TENSORBASE (DEFINE_LINSPACE) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_LOG) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_LOG10) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_LOGICAL_SELF) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_LOGICAL_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_LOGICAL_SYM_CSCALAR) |
| |
| Tensor | operator> (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator< (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator>= (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator<= (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator&& (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator|| (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator== (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator!= (const Tensor &a, const Tensor &b) |
| |
| Tensor | gt (const Tensor &a, const Tensor &b) |
| |
| Tensor | lt (const Tensor &a, const Tensor &b) |
| |
| Tensor | ge (const Tensor &a, const Tensor &b) |
| |
| Tensor | le (const Tensor &a, const Tensor &b) |
| |
| Tensor | logical_and (const Tensor &a, const Tensor &b) |
| |
| Tensor | logical_or (const Tensor &a, const Tensor &b) |
| |
| Tensor | logical_xor (const Tensor &a, const Tensor &b) |
| |
| Tensor | eq (const Tensor &a, const Tensor &b) |
| |
| Tensor | ne (const Tensor &a, const Tensor &b) |
| |
| Tensor | operator! (const Tensor &a) |
| |
| Tensor | logical_not (const Tensor &a) |
| |
| Tensor | operator> (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator> (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator< (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator< (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator>= (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator>= (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator<= (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator<= (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator&& (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator&& (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator|| (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator|| (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator== (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator== (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator!= (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator!= (const Scalar &a, const Tensor &b) |
| |
| Tensor | gt (const Tensor &a, const Scalar &b) |
| |
| Tensor | gt (const Scalar &a, const Tensor &b) |
| |
| Tensor | lt (const Tensor &a, const Scalar &b) |
| |
| Tensor | lt (const Scalar &a, const Tensor &b) |
| |
| Tensor | ge (const Tensor &a, const Scalar &b) |
| |
| Tensor | ge (const Scalar &a, const Tensor &b) |
| |
| Tensor | le (const Tensor &a, const Scalar &b) |
| |
| Tensor | le (const Scalar &a, const Tensor &b) |
| |
| Tensor | logical_and (const Tensor &a, const Scalar &b) |
| |
| Tensor | logical_and (const Scalar &a, const Tensor &b) |
| |
| Tensor | logical_or (const Tensor &a, const Scalar &b) |
| |
| Tensor | logical_or (const Scalar &a, const Tensor &b) |
| |
| Tensor | logical_xor (const Tensor &a, const Scalar &b) |
| |
| Tensor | logical_xor (const Scalar &a, const Tensor &b) |
| |
| Tensor | eq (const Tensor &a, const Scalar &b) |
| |
| Tensor | eq (const Scalar &a, const Tensor &b) |
| |
| Tensor | ne (const Tensor &a, const Scalar &b) |
| |
| Tensor | ne (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator> (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator> (const CScalar &a, const Tensor &b) |
| |
| Tensor | operator< (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator< (const CScalar &a, const Tensor &b) |
| |
| Tensor | operator>= (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator>= (const CScalar &a, const Tensor &b) |
| |
| Tensor | operator<= (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator<= (const CScalar &a, const Tensor &b) |
| |
| Tensor | operator&& (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator&& (const CScalar &a, const Tensor &b) |
| |
| Tensor | operator|| (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator|| (const CScalar &a, const Tensor &b) |
| |
| Tensor | operator== (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator== (const CScalar &a, const Tensor &b) |
| |
| Tensor | operator!= (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator!= (const CScalar &a, const Tensor &b) |
| |
| Tensor | gt (const Tensor &a, const CScalar &b) |
| |
| Tensor | gt (const CScalar &a, const Tensor &b) |
| |
| Tensor | lt (const Tensor &a, const CScalar &b) |
| |
| Tensor | lt (const CScalar &a, const Tensor &b) |
| |
| Tensor | ge (const Tensor &a, const CScalar &b) |
| |
| Tensor | ge (const CScalar &a, const Tensor &b) |
| |
| Tensor | le (const Tensor &a, const CScalar &b) |
| |
| Tensor | le (const CScalar &a, const Tensor &b) |
| |
| Tensor | logical_and (const Tensor &a, const CScalar &b) |
| |
| Tensor | logical_and (const CScalar &a, const Tensor &b) |
| |
| Tensor | logical_or (const Tensor &a, const CScalar &b) |
| |
| Tensor | logical_or (const CScalar &a, const Tensor &b) |
| |
| Tensor | logical_xor (const Tensor &a, const CScalar &b) |
| |
| Tensor | logical_xor (const CScalar &a, const Tensor &b) |
| |
| Tensor | eq (const Tensor &a, const CScalar &b) |
| |
| Tensor | eq (const CScalar &a, const Tensor &b) |
| |
| Tensor | ne (const Tensor &a, const CScalar &b) |
| |
| Tensor | ne (const CScalar &a, const Tensor &b) |
| |
| Scalar | operator> (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator< (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator>= (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator<= (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator&& (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator|| (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator== (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator!= (const Scalar &a, const Scalar &b) |
| |
| Scalar | gt (const Scalar &a, const Scalar &b) |
| |
| Scalar | lt (const Scalar &a, const Scalar &b) |
| |
| Scalar | ge (const Scalar &a, const Scalar &b) |
| |
| Scalar | le (const Scalar &a, const Scalar &b) |
| |
| Scalar | logical_and (const Scalar &a, const Scalar &b) |
| |
| Scalar | logical_or (const Scalar &a, const Scalar &b) |
| |
| Scalar | logical_xor (const Scalar &a, const Scalar &b) |
| |
| Scalar | eq (const Scalar &a, const Scalar &b) |
| |
| Scalar | ne (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator! (const Scalar &a) |
| |
| Scalar | logical_not (const Scalar &a) |
| |
| Scalar | operator> (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator> (const CScalar &a, const Scalar &b) |
| |
| Scalar | operator< (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator< (const CScalar &a, const Scalar &b) |
| |
| Scalar | operator>= (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator>= (const CScalar &a, const Scalar &b) |
| |
| Scalar | operator<= (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator<= (const CScalar &a, const Scalar &b) |
| |
| Scalar | operator&& (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator&& (const CScalar &a, const Scalar &b) |
| |
| Scalar | operator|| (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator|| (const CScalar &a, const Scalar &b) |
| |
| Scalar | operator== (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator== (const CScalar &a, const Scalar &b) |
| |
| Scalar | operator!= (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator!= (const CScalar &a, const Scalar &b) |
| |
| Scalar | gt (const Scalar &a, const CScalar &b) |
| |
| Scalar | gt (const CScalar &a, const Scalar &b) |
| |
| Scalar | lt (const Scalar &a, const CScalar &b) |
| |
| Scalar | lt (const CScalar &a, const Scalar &b) |
| |
| Scalar | ge (const Scalar &a, const CScalar &b) |
| |
| Scalar | ge (const CScalar &a, const Scalar &b) |
| |
| Scalar | le (const Scalar &a, const CScalar &b) |
| |
| Scalar | le (const CScalar &a, const Scalar &b) |
| |
| Scalar | logical_and (const Scalar &a, const CScalar &b) |
| |
| Scalar | logical_and (const CScalar &a, const Scalar &b) |
| |
| Scalar | logical_or (const Scalar &a, const CScalar &b) |
| |
| Scalar | logical_or (const CScalar &a, const Scalar &b) |
| |
| Scalar | logical_xor (const Scalar &a, const CScalar &b) |
| |
| Scalar | logical_xor (const CScalar &a, const Scalar &b) |
| |
| Scalar | eq (const Scalar &a, const CScalar &b) |
| |
| Scalar | eq (const CScalar &a, const Scalar &b) |
| |
| Scalar | ne (const Scalar &a, const CScalar &b) |
| |
| Scalar | ne (const CScalar &a, const Scalar &b) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_LOGSPACE) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_MACAULAY) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_MEAN) |
| |
| Tensor | base_mean (const Tensor &a, Size d) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_MINIMUM) |
| |
| Tensor | mm (const Tensor &a, const Tensor &b) |
| | Batched matrix-matrix product.
|
| |
| Tensor | mv (const Tensor &a, const Tensor &v) |
| | Batched matrix-vector product.
|
| |
| Scalar | norm (const Tensor &a, const std::optional< CScalar > &eps=std::nullopt) |
| | Frobenius norm of a tensor.
|
| |
| Scalar | norm_sq (const Tensor &a) |
| | Squared Frobenius norm of a tensor.
|
| |
| | FOR_ALL_TENSORBASE (DEFINE_NORMALIZE_GCD) |
| |
| Tensor | operator+ (const Tensor &a, const Tensor &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_SELF) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_SYM_CSCALAR) |
| |
| Tensor | operator+ (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator+ (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator+ (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator+ (const CScalar &a, const Tensor &b) |
| |
| Scalar | operator+ (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator+ (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator+ (const CScalar &a, const Scalar &b) |
| |
| Tensor | operator- (const Tensor &a, const Tensor &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_SELF) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_SYM_CSCALAR) |
| |
| Tensor | operator- (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator- (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator- (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator- (const CScalar &a, const Tensor &b) |
| |
| Scalar | operator- (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator- (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator- (const CScalar &a, const Scalar &b) |
| |
| Tensor | operator* (const Tensor &a, const Tensor &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_MUL_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_MUL_SYM_CSCALAR) |
| |
| Tensor | operator* (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator* (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator* (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator* (const CScalar &a, const Tensor &b) |
| |
| Scalar | operator* (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator* (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator* (const CScalar &a, const Scalar &b) |
| |
| Tensor | operator/ (const Tensor &a, const Tensor &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_DIV_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_DIV_SYM_CSCALAR) |
| |
| Tensor | operator/ (const Tensor &a, const Scalar &b) |
| |
| Tensor | operator/ (const Scalar &a, const Tensor &b) |
| |
| Tensor | operator/ (const Tensor &a, const CScalar &b) |
| |
| Tensor | operator/ (const CScalar &a, const Tensor &b) |
| |
| Scalar | operator/ (const Scalar &a, const Scalar &b) |
| |
| Scalar | operator/ (const Scalar &a, const CScalar &b) |
| |
| Scalar | operator/ (const CScalar &a, const Scalar &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_ADD_EQ) |
| |
| Tensor & | operator+= (Tensor &a, const CScalar &b) |
| |
| Scalar & | operator+= (Scalar &a, const CScalar &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_SUB_EQ) |
| |
| Tensor & | operator-= (Tensor &a, const CScalar &b) |
| |
| Scalar & | operator-= (Scalar &a, const CScalar &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_MUL_EQ) |
| |
| Tensor & | operator*= (Tensor &a, const CScalar &b) |
| |
| Scalar & | operator*= (Scalar &a, const CScalar &b) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DEFINE_DIV_EQ) |
| |
| Tensor & | operator/= (Tensor &a, const CScalar &b) |
| |
| Scalar & | operator/= (Scalar &a, const CScalar &b) |
| |
| | FOR_ALL_NONSCALAR_TENSORBASE (DEFINE_POW) |
| |
| Scalar | pow (const Scalar &a, const CScalar &n) |
| |
| Scalar | pow (const Scalar &a, const Scalar &n) |
| |
| Scalar | pow (const CScalar &a, const Scalar &n) |
| |
| Tensor | pow (const Tensor &a, const Tensor &n) |
| | Element-wise pow.
|
| |
| Tensor | pow (const CScalar &a, const Tensor &n) |
| | Element-wise pow.
|
| |
| | FOR_ALL_TENSORBASE (DEFINE_SIGN) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_SIN) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_SINH) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_SQRT) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_STACK) |
| |
| Tensor | base_stack (const std::vector< Tensor > &tensors, Size d) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_SUM) |
| |
| Tensor | base_sum (const Tensor &a, Size d, bool keepdim) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_SUM_TO_SIZE) |
| |
| Tensor | base_sum_to_size (const Tensor &a, TensorShapeRef shape) |
| |
| Tensor | full_to_mandel (const Tensor &full, Size dim=0) |
| | Convert a Tensor from full notation to Mandel notation.
|
| |
| Tensor | mandel_to_full (const Tensor &mandel, Size dim=0) |
| | Convert a Tensor from Mandel notation to full notation.
|
| |
| Tensor | full_to_skew (const Tensor &full, Size dim=0) |
| | Convert a Tensor from full notation to skew vector notation.
|
| |
| Tensor | skew_to_full (const Tensor &skew, Size dim=0) |
| | Convert a Tensor from skew vector notation to full notation.
|
| |
| | FOR_ALL_TENSORBASE (DEFINE_TAN) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_TANH) |
| |
| template<std::size_t N> |
| Tensor | to_assembly (const Tensor &from, const std::array< TensorShapeRef, N > &intmd_shapes, const std::array< TensorShapeRef, N > &base_shapes, const std::string &debug_name) |
| |
| template Tensor | to_assembly< 1 > (const Tensor &, const std::array< TensorShapeRef, 1 > &, const std::array< TensorShapeRef, 1 > &, const std::string &) |
| |
| template Tensor | to_assembly< 2 > (const Tensor &, const std::array< TensorShapeRef, 2 > &, const std::array< TensorShapeRef, 2 > &, const std::string &) |
| |
| template Tensor | to_assembly< 3 > (const Tensor &, const std::array< TensorShapeRef, 3 > &, const std::array< TensorShapeRef, 3 > &, const std::string &) |
| |
| | FOR_ALL_TENSORBASE (DEFINE_UNIT) |
| |
| Scalar | vdot (const Tensor &u, const Tensor &v) |
| | Vector-vector dot product.
|
| |
| | FOR_ALL_TENSORBASE (DEFINE_WHERE) |
| |
| void | neml_assert_tracing () |
| | Assert that we are currently tracing.
|
| |
| void | neml_assert_not_tracing () |
| | Assert that we are currently NOT tracing.
|
| |
| void | neml_assert_tracing_dbg () |
| | Assert that we are currently tracing (only effective in debug mode)
|
| |
| void | neml_assert_not_tracing_dbg () |
| | Assert that we are currently NOT tracing (only effective in debug mode)
|
| |
| R2 | operator* (const R2 &, const R2 &) |
| | matrix-matrix product
|
| |
| Vec | operator* (const R2 &, const Vec &) |
| | matrix-vector product
|
| |
| Rot | operator* (const Rot &r1, const Rot &r2) |
| | Composition of rotations r3 = r1 * r2 (r2 first, then r1)
|
| |
| SSR4 | operator* (const SSR4 &a, const SSR4 &b) |
| |
| SR2 | operator* (const SSR4 &a, const SR2 &b) |
| |
| | FOR_ALL_TENSORBASE (INSTANTIATE_TENSORBASE) |
| |
| std::ostream & | operator<< (std::ostream &os, const TensorType &t) |
| |
| | FOR_ALL_TENSORBASE (INSTANTIATE_TENSORVALUE) |
| |
| std::ostream & | operator<< (std::ostream &os, const TraceableSize &s) |
| | Streaming operator.
|
| |
| R2 | transform_from_quaternion (const Quaternion &q) |
| | Construct from quaternions, useful for comparison to old NEML.
|
| |
| R2 | identity_transform (const TensorOptions &options=default_tensor_options()) |
| | The identity transformation, i.e.e the Rank2 identity tensor.
|
| |
| R2 | proper_rotation_transform (const Rot &rot) |
| | A proper rotation, here provided by a Rot object.
|
| |
| R2 | improper_rotation_transform (const Rot &rot) |
| | An improper rotation (rotation + reflection), here provided by a rot object giving the rotation and reflection axis.
|
| |
| R2 | reflection_transform (const Vec &v) |
| | A reflection, defined by the reflection plane.
|
| |
| R2 | inversion_transform (const TensorOptions &options=default_tensor_options()) |
| | An inversion center.
|
| |
| | FOR_ALL_VECBASE (VECBASE_INSTANTIATE) |
| |
| | FOR_ALL_TENSORBASE (INSTANTIATE_FACTORYMETHODBASE) |
| |
| | register_NEML2_object (FillR2) |
| |
| | register_NEML2_object (FillRot) |
| |
| | register_NEML2_object (FillSR2) |
| |
| | register_NEML2_object (FillWR2) |
| |
| | FOR_ALL_PRIMITIVETENSOR (REGISTER_FROMTORCHSCRIPT) |
| |
| | FOR_ALL_TENSORBASE (FULLTENSOR_REGISTER) |
| |
| | register_NEML2_object (IdentityTensor) |
| |
| | FOR_ALL_TENSORBASE (LINSPACETENSOR_REGISTER) |
| |
| | FOR_ALL_TENSORBASE (LOGSPACETENSOR_REGISTER) |
| |
| | register_NEML2_object (Orientation) |
| |
| | FOR_ALL_TENSORBASE (RANDOMTENSOR_REGISTER) |
| |
| | register_NEML2_object (SymmetryFromOrbifold) |
| |
| | FOR_ALL_TENSORBASE (USERTENSOR_REGISTER) |
| |
| | FOR_ALL_TENSORBASE (INSTANTIATE_USERTENSORBASE) |
| |
| template<typename... Args> |
| void | diagnostic_assert (bool, Args &&...) |
| | Helper assertion function for diagnostics.
|
| |
| template<typename... Args> |
| void | diagnostic_assert (bool assertion, Args &&... args) |
| |
| | FOR_ALL_TENSORBASE (EXPORT_TENSORNAME) |
| |
| template<typename T > |
| std::stringstream & | operator>> (std::stringstream &ss, TensorName< T > &t) |
| | Stream into a TensorName (used by Parsers to extract input options)
|
| |
| template<typename T > |
| std::ostream & | operator<< (std::ostream &os, const TensorName< T > &t) |
| | Stream out a TensorName (used for printing OptionSet)
|
| |
| template<typename... Args> |
| void | neml_assert (bool assertion, Args &&... args) |
| |
| template<typename... Args> |
| void | neml_assert_dbg (bool assertion, Args &&... args) |
| |
| template<typename T > |
| T | apply_mask (const T &a, const Scalar &m, std::size_t mdim) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator+ (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator- (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator* (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator/ (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator> (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator< (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator>= (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator<= (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator&& (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator|| (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator== (const T1 &a, const T2 &b) |
| |
| template<typename T1 , typename T2 , typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator!= (const T1 &a, const T2 &b) |
| |
| template<class... T> |
| void | neml_assert_broadcastable (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_broadcastable_dbg (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_dynamic_broadcastable (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_dynamic_broadcastable_dbg (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_intmd_broadcastable (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_intmd_broadcastable_dbg (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_batch_broadcastable (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_batch_broadcastable_dbg (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_base_broadcastable (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_base_broadcastable_dbg (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_static_broadcastable (const T &... tensors) |
| |
| template<class... T> |
| void | neml_assert_static_broadcastable_dbg (const T &... tensors) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_ABS) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_ACOS) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_ARGMAX) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_ARGMIN) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_ASIN) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_ATAN) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_CAT) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_CBRT) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_CLAMP) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_CLIP) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_COS) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_COSH) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_DEG2RAD) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_DIAG_EMBED) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_DIFF) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_EXP) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_FMOD) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_GCD) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_HEAVISIDE) |
| |
| template<typename T > |
| DTensor< T, T, typename imap_t< T >::type > | imap (const TensorOptions &options=default_tensor_options()) |
| | Identity map.
|
| |
| template<typename T > |
| imap_t< T >::type | imap_v (const TensorOptions &options=default_tensor_options()) |
| | Get the identity map interpreted as the concrete primitive tensor type.
|
| |
| template<> |
| DTensor< Scalar, Scalar, typename imap_t< Scalar >::type > | imap (const TensorOptions &options) |
| |
| template<> |
| DTensor< Vec, Vec, typename imap_t< Vec >::type > | imap (const TensorOptions &options) |
| |
| template<> |
| DTensor< R2, R2, typename imap_t< R2 >::type > | imap (const TensorOptions &options) |
| |
| template<> |
| DTensor< SR2, SR2, typename imap_t< SR2 >::type > | imap (const TensorOptions &options) |
| |
| template<> |
| DTensor< SSR4, SSR4, typename imap_t< SSR4 >::type > | imap (const TensorOptions &options) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_LOG) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_LOG10) |
| |
| | FOR_ALL_TENSORBASE (FORWARD_DECLARATION) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_LOGICAL_SELF) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_LOGICAL_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_LOGICAL_CSCALAR) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_MACAULAY) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_BATCH_MEAN) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_MINIMUM) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_SELF) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_SYM_CSCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_SELF) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_SYM_CSCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_MUL_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_MUL_SYM_CSCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_DIV_SYM_SCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_DIV_SYM_CSCALAR) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_ADD_EQ) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_SUB_EQ) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_MUL_EQ) |
| |
| | FOR_ALL_NONSCALAR_PRIMITIVETENSOR (DECLARE_DIV_EQ) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_POW) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_SIGN) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_SIN) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_SINH) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_SQRT) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_STACK) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_SUM) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_SUM_TO_SIZE) |
| |
| constexpr double | mandel_factor (Size i) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_TAN) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_TANH) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_WHERE) |
| |
| template<class Tuple , std::size_t... I> |
| auto | make_tensors (Tuple &&t, std::index_sequence< I... >, const TensorOptions &options) |
| |
| | FOR_ALL_TENSORBASE (EXPORT_TENSORBASE) |
| |
| | FOR_ALL_TENSORBASE (SPECIALIZE_TENSORTYPEENUM) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_TENSOR) |
| |
| | register_NEML2_object (ProjectileAcceleration) |
| |
|
The factory methods like at::arange, at::ones, at::zeros, at::rand etc. accept a common argument to configure the properties of the tensor being created. We predefine a default tensor configuration in NEML2. This default configuration is consistently used throughout NEML2.
See https://pytorch.org/cppdocs/notes/tensor_creation.html#configuring-properties-of-the-tensor for more details.
|
| void | set_default_dtype (Dtype dtype) |
| |
| Dtype | get_default_dtype () |
| | Get default dtype.
|
| |
| TensorOptions | default_tensor_options () |
| | Default floating point tensor options.
|
| |
| void | set_default_integer_dtype (Dtype dtype) |
| | Set default integer dtype.
|
| |
| Dtype | get_default_integer_dtype () |
| | Get default integer dtype.
|
| |
| TensorOptions | default_integer_tensor_options () |
| | Default integral tensor options.
|
| |
|
| Scalar | det (const Tensor &A) |
| |
| Scalar | det (const R2 &A) |
| |
| Scalar | det (const SR2 &A) |
| |
| Scalar | det (const WR2 &A) |
| |
|
| Tensor | dev (const Tensor &A) |
| |
| R2 | dev (const R2 &A) |
| |
| SR2 | dev (const SR2 &A) |
| |
| WR2 | dev (const WR2 &A) |
| |
|
| R2 | inv (const R2 &A) |
| |
| SR2 | inv (const SR2 &A) |
| |
|
| R4 | inv (const R4 &A) |
| |
| SSR4 | inv (const SSR4 &A) |
| |
|
| Tensor | base_linspace (const Tensor &start, const Tensor &end, Size nstep, Size dim) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_LINSPACE) |
| |
|
| Tensor | base_logspace (const Tensor &start, const Tensor &end, Size nstep, Size dim, const CScalar &base) |
| |
| | FOR_ALL_TENSORBASE (DECLARE_LOGSPACE) |
| |
|
| Tensor | outer (const Tensor &u, const Tensor &v) |
| |
| Tensor | outer (const Tensor &u) |
| |
| R2 | outer (const Vec &u, const Vec &v) |
| |
| R2 | outer (const Vec &u) |
| |
| R4 | outer (const R2 &u, const R2 &v) |
| |
| R4 | outer (const R2 &u) |
| |
| SSR4 | outer (const SR2 &u, const SR2 &v) |
| |
| SSR4 | outer (const SR2 &u) |
| |
|
| Scalar | tr (const Tensor &A) |
| |
| Scalar | tr (const R2 &A) |
| |
| Scalar | tr (const SR2 &A) |
| |
| Scalar | tr (const WR2 &A) |
| |
|
| Tensor | vol (const Tensor &A) |
| |
| R2 | vol (const R2 &A) |
| |
| SR2 | vol (const SR2 &A) |
| |
| WR2 | vol (const WR2 &A) |
| |
|
| TraceableSize | operator* (const TraceableSize &lhs, const TraceableSize &rhs) |
| |
|
| bool | operator== (const TraceableSize &lhs, const TraceableSize &rhs) |
| |
| bool | operator!= (const TraceableSize &lhs, const TraceableSize &rhs) |
| |
|
| bool | operator== (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs) |
| |
| bool | operator!= (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs) |
| |
|
| template<class... T> |
| void | neml_assert_broadcastable (const T &...) |
| |
| template<class... T> |
| void | neml_assert_broadcastable_dbg (const T &...) |
| |
|
| template<class... T> |
| void | neml_assert_dynamic_broadcastable (const T &...) |
| |
| template<class... T> |
| void | neml_assert_dynamic_broadcastable_dbg (const T &...) |
| |
|
| template<class... T> |
| void | neml_assert_intmd_broadcastable (const T &...) |
| |
| template<class... T> |
| void | neml_assert_intmd_broadcastable_dbg (const T &...) |
| |
|
| template<class... T> |
| void | neml_assert_batch_broadcastable (const T &...) |
| |
| template<class... T> |
| void | neml_assert_batch_broadcastable_dbg (const T &...) |
| |
|
| template<class... T> |
| void | neml_assert_base_broadcastable (const T &...) |
| |
| template<class... T> |
| void | neml_assert_base_broadcastable_dbg (const T &...) |
| |
|
| template<class... T> |
| void | neml_assert_static_broadcastable (const T &...) |
| |
| template<class... T> |
| void | neml_assert_static_broadcastable_dbg (const T &...) |
| |
|
| | FOR_ALL_TENSORBASE (DECLARE_NORMALIZE_GCD) |
| | Normalize a tensor by its greatest common denominator.
|
| |
|
| | FOR_ALL_TENSORBASE (DECLARE_UNIT) |
| |
1.12.0