Intranet|
cuiksystem.h File Reference IntroductionDefinition of the TCuikSystem type and the associated functions.
Definition in file cuiksystem.h.
Macro Definition Documentation◆ EQ_MIN_IN_CENTER
Boxes to be reduced can be sorted according to a given equation. If this is set to 1 we evaluate this equation in the center of each box If set to 1 we evaluate the equation interval-wise and take the center of the resulting interval.
Definition at line 41 of file cuiksystem.h. ◆ NEWTON_WITHIN_RANGES
Set to one to avoid Newton to scape from boxes.
Definition at line 49 of file cuiksystem.h. ◆ DEPTH_FIRST_SEARCH
In this mode, boxes to be reduced are sorted so that boxes with a higher level (i.e., resulting from more bisections) are treated first. Definition at line 57 of file cuiksystem.h. ◆ BREADTH_FIRST_SEARCH
In this mode, boxes to be reduced are sorted so that boxes with a smaller level (i.e., resulting from less bisections) are treated first. Definition at line 66 of file cuiksystem.h. ◆ MINIMIZATION_SEARCH
In this mode, boxes to be reduced are sorted so that we tread first boxes whose value with repect to a given equation are minimal (among all boxes pending to be treated). In the current implementation the center of the box is used to evaluate the criterion to be minimized. Definition at line 79 of file cuiksystem.h. ◆ CUT_POINT
Point, relative to the size of the selected box side, where we split a box. Definition at line 91 of file cuiksystem.h. ◆ MPI_TREAT_BOX_TIMEOUT
Maximum time (in seconds) we give a child-process to reduce a box. Only used when cuik is executed in a multi-processor environment. Definition at line 103 of file cuiksystem.h. ◆ DIVERGED
Returned by CuikNewtonInBox when the Newton iteration was repeated for more than CT_MAX_NEWTON_ITERATIONS times without reaching a stationary point. Definition at line 114 of file cuiksystem.h. ◆ CONVERGED_IN_BOX
Returned by CuikNewtonInBox when the Newton iteration converged to a point inside the given box. Note that if the Newton converges in the current box it also converges in the initial box however the more restrictive condition (convergence in local box) is returned. Definition at line 127 of file cuiksystem.h. ◆ CONVERGED_IN_GLOBAL
Returned by CuikNewtonInBox when the Newton iteration converged to a point outside the given box, but inside the initial box. Note that if the Newton converges in the current box it also converges in the initial box however the more restrictive condition (convergence in local box) is returned. Definition at line 141 of file cuiksystem.h. ◆ CONVERGED_OUTSIDE_GLOBAL
Returned by CuikNewtonInBox when the Newton iteration converged but to a point that is outside the initial box. Note that this is only returned if the process converged but outside the global box. Definition at line 153 of file cuiksystem.h. ◆ CONVERGED
The union of all possible convergence cases for Newton iteration. Provide to facilitate the test whether or not a call actually converged (to anywhere) Definition at line 161 of file cuiksystem.h. Function Documentation◆ InitCuikSystem()
Creates an empty cuiksystem.
Definition at line 2187 of file cuiksystem.c. References TCuikSystem::consistent, TCuikSystem::constants, DEPTH_FIRST_SEARCH, TCuikSystem::empty, FALSE, InitConstants(), InitEquation(), InitEquations(), InitVariables(), TCuikSystem::nequations, TCuikSystem::notDummyVar, TCuikSystem::nvariables, TCuikSystem::orig2s, TCuikSystem::orig2sd, TCuikSystem::orig_eqMin, TCuikSystem::orig_equations, TCuikSystem::orig_nequations, TCuikSystem::orig_notDummyVar, TCuikSystem::orig_nvariables, TCuikSystem::orig_systemVar, TCuikSystem::orig_variables, TCuikSystem::scalar, TCuikSystem::searchMode, TCuikSystem::simp_empty, TCuikSystem::simp_tp, TCuikSystem::systemVar, TRUE, TCuikSystem::updated, and TCuikSystem::varType. Referenced by AdjustBioWorldGeometry(), CuikSystemMerge(), InitWorldCS(), and main(). ◆ InitCuikSystemFromFile()
Creates an cuiksystem from the information on a file. Right now we do not have a manual of the syntax of the ".cuik" files so check the examples in the CuikSuite examples directory or in the benchmarks section of our web page
Referenced by InitCSWDFromFile(), and main(). ◆ AddCuikSystemFromFile()
Adds information (constants/variables/equations) to a cuiksystem from another file. This is typically used to build a cuiksystem from a set of files where each file assumes we already loaded the previous ones (when adding contact equations to a cuiksystem or eigengrasp equations or singularity equations or....). This function is exacty the same as InitCuikSystemFromFile but the system is not initialized from scratch but assumed pre-initialized.
Referenced by GenerateWorldEquations(), and main(). ◆ VerifyCuikSystem()
Checks the consistency of the cuiksystem. If the system is inconsistent an error is trigered. Note that if new equations/variables are added to the cuiksystem its consistancy might no longer hold.
Definition at line 2226 of file cuiksystem.c. References Error(), and UpdateCuikSystem(). Referenced by main(). ◆ CopyCuikSystem()
Creates an cuiksystem from another cuiksystem.
Definition at line 2236 of file cuiksystem.c. References TCuikSystem::consistent, TCuikSystem::constants, CopyConstants(), CopyEquation(), CopyEquations(), CopyJacobian(), CopyMapping(), CopyStatistics(), CopyVariables(), TCuikSystem::empty, TCuikSystem::eqMin, TCuikSystem::equations, GetVariableNames(), TCuikSystem::J, MINIMIZATION_SEARCH, TCuikSystem::nequations, NEW, TCuikSystem::notDummyVar, TCuikSystem::nvariables, TCuikSystem::orig2s, TCuikSystem::orig2sd, TCuikSystem::orig_eqMin, TCuikSystem::orig_equations, TCuikSystem::orig_nequations, TCuikSystem::orig_notDummyVar, TCuikSystem::orig_nvariables, TCuikSystem::orig_systemVar, TCuikSystem::orig_variables, TCuikSystem::orig_varNames, TCuikSystem::scalar, TCuikSystem::searchMode, TCuikSystem::simp_empty, TCuikSystem::simp_eqMin, TCuikSystem::simp_equations, TCuikSystem::simp_nee, TCuikSystem::simp_nequations, TCuikSystem::simp_nvariables, TCuikSystem::simp_tp, TCuikSystem::simp_variables, TCuikSystem::st, TCuikSystem::systemVar, TCuikSystem::updated, TCuikSystem::variables, and TCuikSystem::varType. Referenced by AddSimplifiedJacobianEquations(), GenerateWorldSingularityEquations(), and GetSCpSystem(). ◆ CuikSystemMerge()
Defines a new cuiksystem by union of two given cuiksystems. CAUTION!
Definition at line 2355 of file cuiksystem.c. References AccumulateEquations(), AddVariable2CS(), TCuikSystem::consistent, TCuikSystem::constants, CopyEquation(), CopyEquations(), CopyVariables(), TCuikSystem::empty, FALSE, GetVariable(), InitCuikSystem(), MergeConstants(), MergeEquations(), TCuikSystem::nequations, TCuikSystem::notDummyVar, NVariables(), TCuikSystem::nvariables, TCuikSystem::orig2sd, TCuikSystem::orig_eqMin, TCuikSystem::orig_equations, TCuikSystem::orig_nequations, TCuikSystem::orig_notDummyVar, TCuikSystem::orig_nvariables, TCuikSystem::orig_systemVar, TCuikSystem::orig_variables, TCuikSystem::scalar, ScalarEquations(), TCuikSystem::searchMode, TCuikSystem::simp_empty, TCuikSystem::systemVar, TRUE, TCuikSystem::updated, and TCuikSystem::varType. ◆ CmpBoxesEquation()
Determines which box to explore first in minimization mode. In this mode boxes are sorted according to an objective function given by an equation in the problem file. The equation is evaluated at the center of the box and the box with a minimum value is processed first.
Definition at line 2448 of file cuiksystem.c. References EvaluateEqMin(). Referenced by MPI_SolveCuikSystem(), and SolveCuikSystem(). ◆ SetCSSearchMode()
Defines the criterion to be used sorting the boxes to be treated when searching for a solution. Possible critera are
Definition at line 2453 of file cuiksystem.c. References BREADTH_FIRST_SEARCH, CopyEquation(), DeleteEquation(), DEPTH_FIRST_SEARCH, Error(), MINIMIZATION_SEARCH, TCuikSystem::orig_eqMin, TCuikSystem::searchMode, UnUpdateCuikSystem(), and TCuikSystem::updated. Referenced by AddTerm2SearchCriterion(). ◆ AddTerm2SearchCriterion()
Adds the  to the equation guiding the search. This function automatically calls SetCSSearchMode to set the search mode to MINIMIZATION_SEARCH it is is not so.
Definition at line 2476 of file cuiksystem.c. References AccumulateEquations(), AddCt2Monomial(), AddMonomial(), AddVariable2Monomial(), DeleteEquation(), DeleteMonomial(), EQU, InitEquation(), InitMonomial(), MINIMIZATION_SEARCH, NFUN, TCuikSystem::orig_eqMin, ResetMonomial(), TCuikSystem::searchMode, SetCSSearchMode(), SetEquationCmp(), UnUpdateCuikSystem(), and TCuikSystem::updated. Referenced by GenerateJointRangeEquations(). ◆ AddVariable2CS()
Adds a new variable to the system.
Definition at line 2551 of file cuiksystem.c. References AddVariable(), GetVariableID(), GetVariableName(), NO_UINT, TCuikSystem::orig_variables, UnUpdateCuikSystem(), and TCuikSystem::updated. Referenced by AddJacobianEquationsInt(), AddVelocityEquations(), AdjustBioWorldGeometry(), CuikSystemMerge(), GenerateEquationsFromBranch(), GenerateJointEquations(), GenerateJointRangeEquations(), GenerateJointRangeSingularityEquations(), GenerateLinkConf(), GenerateLinkRotAxisX(), GenerateLinkRotFLinks(), GenerateLinkRotLinks(), GenerateLinkRotQLinks(), GenerateWorldSingularityEquations(), and GetSCpSystem(). ◆ AddEquation2CS()
Adds a new equation to the system. The equation must use the variables already added to the system. Repeated equations are not added to the system.
Definition at line 2522 of file cuiksystem.c. References AddEquation(), TCuikSystem::orig_equations, UnUpdateCuikSystem(), and TCuikSystem::updated. Referenced by AddJacobianEquationsInt(), AdjustBioWorldGeometry(), FixLinks(), FixLinkZToZero(), GenerateEquationsFromBranch(), GenerateForceEquilibriumEquations(), GenerateJointEquations(), GenerateJointRangeEquations(), GenerateJointRangeSingularityEquations(), GenerateLinkConf(), GenerateLinkRotAxisX(), GenerateLinkRotFLinks(), GenerateLinkRotLinks(), GenerateLinkRotQLinks(), GenerateWorldSingularityEquations(), GetSCpSystem(), WorldCoupleTensegrityVariable(), and WorldFixTensegrityAddon(). ◆ AddMatrixEquation2CS()
Adds a new matrix equation to the system. The equation must use the variables already added to the system. No check is performed to determine if the matrix equation is repeated.
Definition at line 2531 of file cuiksystem.c. References AddMatrixEquation(), Error(), FALSE, TCuikSystem::orig_equations, TCuikSystem::scalar, SimplifiedMEquation(), UnUpdateCuikSystem(), and TCuikSystem::updated. Referenced by GenerateEquationsFromBranch(). ◆ GetCSVariables()
Returns a copy of the variables stored in the cuiksystem. This can be seen as a Tvariables copy constructor, thus the output variables does not need to be initialized beforehand.
Definition at line 2569 of file cuiksystem.c. References CopyVariables(), and TCuikSystem::orig_variables. Referenced by GenerateWorldEquations(). ◆ GetCSVariableNames()
Initializes an array of pointers to variable names. This is used to print boxes.
Definition at line 2574 of file cuiksystem.c. References GetVariableNames(), and TCuikSystem::orig_variables. Referenced by AdjustBioWorldGeometry(), and GetWorldVarNames(). ◆ GetCSNumVariables()
Returns the number of variables already in the cuiksystem.
Definition at line 2584 of file cuiksystem.c. References NVariables(), and TCuikSystem::orig_variables. Referenced by DealWithCP(), GenerateWorldTWSEquations(), GetSCpSystem(), GetWorldNumVariables(), GetWorldSimpVariableMask(), IncrementalSampleCuikSystemInBox(), main(), MoveWorld(), RegenerateWorldSolutionPoint(), SampleCuikSystemInBox(), and WorldDOF2Sol(). ◆ GetCSNumSystemVariables()
Returns the number of system variables in the cuiksystem. System variables are system+secondary (see GetCSSystemVars).
Definition at line 2589 of file cuiksystem.c. References GetNumNonDynamicVariables(), GetNumSecondaryVariables(), GetNumSystemVariables(), GetNumVelocityVariables(), and TCuikSystem::orig_variables. Referenced by GetSolutionPointFromLinkTransforms(), GetWorldNumSystemVariables(), main(), MoveWorld(), and RegenerateWorldOriginalSystemPoint(). ◆ GetCSNumNonDynamicVariables()
Returns the number of non dynamic variables in the cuiksystem.
Definition at line 2598 of file cuiksystem.c. References GetNumNonDynamicVariables(), and TCuikSystem::orig_variables. ◆ GetCSNumNonDummyVariables()
Returns the number of non-dummy (i.e., the sum of system, secondary and cartesian variables) variables already in the cuiksystem.
Definition at line 2606 of file cuiksystem.c. References GetNumDummyVariables(), NVariables(), and TCuikSystem::orig_variables. Referenced by AnimateWorld(). ◆ CuikHasVelocity()
Determines if a cuiksystem includes velocity information.
Definition at line 2611 of file cuiksystem.c. References Error(), GetNumVelocityVariables(), NVelocityEquations(), TCuikSystem::simp_equations, TCuikSystem::simp_variables, and UpdateCuikSystem(). Referenced by main(), and WorldHasVelocity(). ◆ GetCSVariable()
Returns a copy of one of the variables of the cuiksystem. This can be seen as a Tvariable copy constructor, thus the output variable does not need to be initialized beforehand.
Definition at line 2623 of file cuiksystem.c. References CopyVariable(), GetVariable(), and TCuikSystem::orig_variables. ◆ SetCSVariableRange()
Returns a copy of the range of one of the variables of the cuiksystem. This can be seen as a Tinterval constructor, thus the output interval does not need to be initialized beforehand.
Definition at line 2631 of file cuiksystem.c. References GetVariable(), TCuikSystem::orig_variables, SetVariableInterval(), UnUpdateCuikSystem(), and TCuikSystem::updated. Referenced by GetSCpSystem(), and SampleCuikSystemInBox(). ◆ GetCSVariableID()
Returns the numerical identifier of a variable given its name.
Definition at line 2643 of file cuiksystem.c. References GetVariableID(), and TCuikSystem::orig_variables. Referenced by AdjustBioWorldGeometry(), ApplyLinkRotAxisX(), ApplyLinkRotDeformX(), ApplyLinkRotFLinks(), ApplyLinkRotLinks(), ApplyLinkRotQLinks(), GenerateJointEquationsInBranch(), GenerateJointRangeEquations(), GenerateJointRangeSingularityEquations(), GenerateJointSolution(), GenerateLinkConf(), GenerateLinkRotAxisX(), GenerateLinkRotFLinks(), GenerateLinkRotLinks(), GenerateLinkRotQLinks(), GenerateWorldTWSEquations(), GetJointTransSeq(), GetLinkTransSeq(), GetRotVarIDAxisX(), GetRotVarIDFLinks(), GetRotVarIDLinks(), GetRotVarIDQLinks(), JointForceEquation(), main(), RegenerateJointBox(), RegenerateJointSolution(), SetTransVars(), WorldDOF2Sol(), and WorldFixTensegrityAddon(). ◆ GetCSVariableName()
Gets the name of a particular variable. The returned pointer should not be manipulated.
Definition at line 2648 of file cuiksystem.c. References TCuikSystem::orig_variables, and VariableName(). Referenced by GetLinkPoseSimpVars(). ◆ GetCSSystemVariableName()
Gets the name of a particular system variable. The returned pointer should not be manipulated.
Definition at line 2653 of file cuiksystem.c. References FALSE, IsPositionVariable(), IsSecondaryVariable(), IsSystemVariable(), NVariables(), TCuikSystem::orig_variables, TRUE, and VariableName(). Referenced by GetWorldSystemVarName(). ◆ IsSystemVarInSimpCS()
Identifies system variables that survive in the simplified system.
Definition at line 2678 of file cuiksystem.c. References Error(), GetVariableID(), IsPositionVariable(), IsSecondaryVariable(), IsSystemVariable(), NO_UINT, TCuikSystem::simp_variables, and UpdateCuikSystem(). Referenced by GetLinkPoseSimpVars(). ◆ GetCSSystemVars()
Creates an array of booleans with the size of the number of variables in the cuiksystem and set to TRUE the entries corresponding to system, secondary, and velocity variables. In coherence with the definition of the orig_systemVar field of TCuikSystem, here we identify system, secondary, and velocity varibles. Internally, though, we differentiate between them (for instance, secondary varibles are not used when splitting boxes).
Definition at line 2697 of file cuiksystem.c. References IsPositionVariable(), IsSecondaryVariable(), IsSystemVariable(), NEW, NVariables(), and TCuikSystem::orig_variables. Referenced by AdjustBioWorldGeometry(), GenerateWorldEquations(), GetSCpSystem(), GetWorldSystemVars(), IncrementalSampleCuikSystemInBox(), main(), NewtonInWorld(), and SampleCuikSystemInBox(). ◆ GetCSPositionVars()
Creates an array of booleans with the size of the number of variables in the cuiksystem and set to TRUE the entries corresponding to position, i.e., to non-velocity variables.
Definition at line 2711 of file cuiksystem.c. References IsPositionVariable(), NEW, NVariables(), and TCuikSystem::orig_variables. Referenced by GetWorldPositionVars(). ◆ GetCSPositionEqs()
Creates an array of booleans with the size of the number of variables in the cuiksystem and set to TRUE the entries corresponding to position, i.e., to non-velocity variables.
Definition at line 2724 of file cuiksystem.c. References IsPositionEquation(), NEquations(), NEW, and TCuikSystem::orig_equations. Referenced by GetWorldPositionEqs(). ◆ GetCSPositionVelocityVars()
Creates an array of booleans with the size of the number of variables in the cuiksystem and set to TRUE the entries corresponding to position or velocity, i.e., the variables relevant for the dynamics. We essentially rule out discriminant variables.
Definition at line 2743 of file cuiksystem.c. References IsNonDynamicVariable(), NEW, NVariables(), and TCuikSystem::orig_variables. Referenced by GetWorldPositionVelocityVars(). ◆ GetCSPositionVelocityEqs()
Creates an array of booleans with the size of the number of variables in the cuiksystem and set to TRUE the entries corresponding to position or velocity, i.e., the equations relevant for the dynamics. We essentially rule out discriminant equations.
Definition at line 2756 of file cuiksystem.c. References IsNonDynamicEquation(), NEquations(), NEW, and TCuikSystem::orig_equations. Referenced by GetWorldPositionVelocityEqs(). ◆ GetCSVarTopology()
Determines the topology of a given variable (of the original variable set).
Definition at line 2774 of file cuiksystem.c. References GetVariable(), GetVariableTopology(), and TCuikSystem::orig_variables. Referenced by GetWorldVarTopology(). ◆ GetCSEquations()
Returns a copy of the system equations. This is a Tequations copy constructor.
Definition at line 2782 of file cuiksystem.c. References CopyEquations(), and TCuikSystem::orig_equations. ◆ GetCSNumEquations()
Returns the number of equations already in the cuiksystem.
Definition at line 2811 of file cuiksystem.c. References NEquations(), and TCuikSystem::orig_equations. Referenced by GetSCpSystem(), IncrementalSampleCuikSystemInBox(), and SampleCuikSystemInBox(). ◆ GetCSEquation()
Returns a copy of one of the equations of the cuiksystem. This can be seen as a Tequation copy constructor.
Definition at line 2790 of file cuiksystem.c. References CopyEquation(), Error(), GetEquation(), TCuikSystem::orig_equations, and TCuikSystem::scalar. ◆ IsCSPolynomial()
Returns TRUE if the cuiksystem is fully polynomial. We check if the original cuiksystem is polynomial since if this system is polynomial, so are the rest of systems (simplified, simplified+dummified).
Definition at line 2798 of file cuiksystem.c. References TCuikSystem::orig_equations, and PolynomialEquations(). Referenced by IsWorldPolynomial(). ◆ IsCSScalar()
Returns TRUE if the cuiksystem is fully scalar.
Definition at line 2803 of file cuiksystem.c. References TCuikSystem::scalar. ◆ GetCSJacobian()
Defines the Jacobian of a CuikSystem considering each equation as a function. Defines an array with as many rows as equations and as many columns as variables where each entry (i,j) is de derivative of equation i (considered as a function) with repect to variable j.
Definition at line 2816 of file cuiksystem.c. References InitJacobian(), TCuikSystem::orig_equations, and TCuikSystem::orig_variables. Referenced by AddJacobianEquations(), GetSCpSystem(), and GetWorldJacobian(). ◆ GetSimpCSTopology()
Creates an array with the topology information for the variables in the simplified system. The topology gives information on the type of range for each variable (either real or spherical). This is relevant when searching for nearest neighbours (in the case of spherical topology pi is close to -pi but not in the case of real topology).
Definition at line 2821 of file cuiksystem.c. References Error(), GetVariablesTopology(), TCuikSystem::simp_variables, and UpdateCuikSystem(). Referenced by GetWorldSimpTopology(). ◆ GetCSTopology()
Creates an array with the topology information for the variables in the system. The topology gives information on the type of range for each variable (either real or spherical). This is relevant when searching for nearest neighbours (in the case of spherical topology pi is close to -pi but not in the case of real topology).
Definition at line 2830 of file cuiksystem.c. References GetVariablesTopology(), and TCuikSystem::orig_variables. Referenced by GetWorldTopology(). ◆ GetSimpCSJacobian()
The same as GetCSJacobian but for the simplified system.
Definition at line 2836 of file cuiksystem.c. References Error(), InitJacobian(), TCuikSystem::simp_equations, TCuikSystem::simp_variables, and UpdateCuikSystem(). Referenced by GetWorldSimpJacobian(). ◆ GetSimpCSNJacobian()
Defines the data necessary to numerically evaluate the Jacobian of the position variables/equations of the problem. Such structure is only defined in particular systems (systems including only matrix equations) and it is used to speed up the evaluation of the Jacobian (the evaluation of the symbolic Jacobian is slow since many matrix products are repated).
Definition at line 2843 of file cuiksystem.c. References Error(), InitNJacobian(), TCuikSystem::simp_equations, TCuikSystem::simp_variables, and UpdateCuikSystem(). Referenced by GetWorldSimpNJacobian(). ◆ GetSimpCSNHessian()
Defines the data necessary to numerically evaluate the Hessian of the position variables/equations of the problem. Such structure is only defined in particular systems (systems including only matrix equations) and it is used to speed up the evaluation of the Hessian (the evaluation of the symbolic Hessian is slow since many matrix products are repated).
Definition at line 2851 of file cuiksystem.c. References Error(), InitNHessian(), TCuikSystem::simp_equations, TCuikSystem::simp_variables, and UpdateCuikSystem(). Referenced by GetWorldSimpNHessian(). ◆ AddJacobianEquations()
Adds linear a linear combination of the Jacobian to the system. Generates a new variable for each equation in the system and creates a linear combination of the Jacobian rows using the new variables. Those new variables are normalized to avoid getting redudant solutions. Only the Jacobian columns corresponding to the selectedVars is used. This functions is used when looking for singularities.
Definition at line 2916 of file cuiksystem.c. References AddJacobianEquationsInt(), DeleteJacobian(), Error(), GetCSJacobian(), TCuikSystem::orig_nequations, TCuikSystem::orig_nvariables, TCuikSystem::scalar, UnUpdateCuikSystem(), and UpdateCuikSystem(). Referenced by main(). ◆ AddVelocityEquations()
Generates the velocity variables and equations. We have as many velocity variables as variables in the simplified cuiksystem and the equations are defined as the product of the position Jacobian and the velocity variables. Note that if the input cuiksystem already includes velocity variables and equations nothing is actually added. Otherwise we will be generating acceleration equations and this requires some code modifications (specially with the matrix equations).
Definition at line 2946 of file cuiksystem.c. References AddVariable2CS(), ChangeParameter(), CT_DEFAULT_MAX_VELOCITY, CT_DUMMIFY, DeleteJacobian(), DeleteVariable(), Error(), GetNumVelocityVariables(), GetParameter(), GetVarIDInOriginal(), InitPositionJacobian(), IsPositionVariable(), JacobianLinearCombination(), NEW, NewInterval(), NewVariable(), TCuikSystem::orig2s, TCuikSystem::orig_equations, TCuikSystem::orig_variables, RewriteJacobian2Orig(), SetVariableInterval(), TCuikSystem::simp_equations, TCuikSystem::simp_nee, TCuikSystem::simp_nvariables, TCuikSystem::simp_variables, UnUpdateCuikSystem(), UpdateCuikSystem(), VariableName(), and VELOCITY_VAR. Referenced by GenerateWorldEquations(). ◆ AddSimplifiedJacobianEquations()
This is the same as AddJacobianEquations but the we use the Jacobian of the simplified system instead of that of the original system. Note that the selectedVars refer to the original system and they can be missing from the original system. We try to translate variables from original to simple. Original variables assigned to constants are unselected and variables assigned to other variables are replaced accordingly.
Definition at line 3045 of file cuiksystem.c. References AddJacobianEquationsInt(), CopyCuikSystem(), DeleteCuikSystem(), DeleteJacobian(), DeleteLinearConstraint(), Error(), FALSE, GetJacobianEquation(), GetLinearConstraintVariable(), GetNumTermsInLinearConstraint(), GetOriginalVarRelation(), GetVariableNames(), InitJacobian(), NEW, TCuikSystem::orig2s, TCuikSystem::orig_nvariables, TCuikSystem::orig_variables, TCuikSystem::orig_varNames, PrintEquation(), RewriteJacobian2Orig(), TCuikSystem::scalar, TCuikSystem::simp_equations, TCuikSystem::simp_nee, TCuikSystem::simp_nvariables, TCuikSystem::simp_variables, TRUE, UnUpdateCuikSystem(), UpdateCuikSystem(), and VariableName(). Referenced by GenerateWorldTWSEquations(). ◆ MaxReduction()
Reduces a box using the constraints included in the cuiksystem and using the algorithms described in our papers.
Definition at line 3156 of file cuiksystem.c. References DeleteBox(), DUMMY_VAR, EMPTY_BOX, Error(), GetBoxSize(), TCuikSystem::orig2sd, ReduceBox(), TCuikSystem::scalar, SimpleFromOriginal(), TCuikSystem::systemVar, UpdateCuikSystem(), and UpdateOriginalFromSimple(). Referenced by IncrementalSampleCuikSystemInBox(), MaxWorldReduction(), and SampleCuikSystemInBox(). ◆ SampleCuikSystem()
Determine points for which all the equations in the cuiksystem hold. Actually it determines tiny boxes (boxes with size below EPSILON) and the center of the box is taken as the solution point. Since, in general, EPSILON is very small (1e-6) the error of the given solutions is also tiny (order of 1e-12).
Definition at line 3189 of file cuiksystem.c. References DeleteBox(), Error(), GenerateInitialBox(), SampleCuikSystemInBox(), and TCuikSystem::scalar. Referenced by main(). ◆ SampleCuikSystemInBox()
This like function SampleCuikSystem but the samples are generated only in the given box. Morover, this function can store the (tiny) solution boxes in a list of boxes.
Definition at line 3208 of file cuiksystem.c. References AddLastElement(), Advance(), ChangeParameter(), ComputeSplitDim(), CopyBox(), CreateFileName(), CT_EPSILON, CT_N_SOLUTIONS, CT_SMALL_SIGMA, CT_SPLIT_TYPE, DeleteBox(), DeleteFileName(), DeleteListOfBoxes(), DUMMY_VAR, EMPTY_BOX, EndOfList(), Error(), FALSE, First(), GenerateInitialBox(), GetBoxInterval(), GetCSNumEquations(), GetCSNumVariables(), GetCSSystemVars(), GetCurrent(), GetFileFullName(), GetParameter(), GetVariable(), GetVariableTypeN(), InitIterator(), InitListOfBoxes(), IntervalCenter(), LINKS_EXT, MaxReduction(), NEW, NewInterval(), NO_UINT, NVariables(), TCuikSystem::orig_equations, TCuikSystem::orig_variables, PrintBox(), randomInInterval(), TCuikSystem::scalar, SetCSVariableRange(), SetVariableInterval(), SOL_EXT, SolveCuikSystem(), SYSTEM_VAR, TRUE, UnUpdateCuikSystem(), TCuikSystem::updated, and UsedVarInEquations(). Referenced by SampleCuikSystem(). ◆ IncrementalSampleCuikSystem()
This function is very similar to SampleCuikSystem but degrees of freedom are progressively fixed instead of fixed all simultaneously.
Definition at line 3466 of file cuiksystem.c. References DeleteBox(), Error(), GenerateInitialBox(), IncrementalSampleCuikSystemInBox(), and TCuikSystem::scalar. ◆ IncrementalSampleCuikSystemInBox()
This function is very similar to SampleCuikSystemInBox but degrees of freedom are progressively fixed instead of fixed all simultaneously.
Definition at line 3486 of file cuiksystem.c. References AddLastElement(), Advance(), BoxFromVariables(), ChangeParameter(), CONVERGED_IN_BOX, CONVERGED_IN_GLOBAL, CopyBox(), CreateFileName(), CT_EPSILON, CT_MAX_NEWTON_ITERATIONS, CT_N_SOLUTIONS, CT_SMALL_SIGMA, CuikNewtonInBox(), DeleteBox(), DeleteFileName(), DeleteListOfBoxes(), DUMMY_VAR, EMPTY_BOX, EndOfList(), Error(), ErrorInSolution(), FALSE, First(), GetBoxInterval(), GetBoxSumSide(), GetCSNumEquations(), GetCSNumVariables(), GetCSSystemVars(), GetCurrent(), GetFileFullName(), GetParameter(), InitIterator(), InitListOfBoxes(), IntervalCenter(), IntervalSize(), IsInSimple(), IsSystemVariable(), LINKS_EXT, MaxReduction(), NEW, NewInterval(), NO_UINT, NVariables(), TCuikSystem::orig2sd, TCuikSystem::orig_notDummyVar, TCuikSystem::orig_variables, TCuikSystem::orig_varNames, PrintBox(), PrintBoxSubset(), randomInInterval(), randomMax(), TCuikSystem::scalar, SetBoxInterval(), SOL_EXT, SolveCuikSystem(), TRUE, UnUpdateCuikSystem(), UpdateCuikSystem(), and VariablesFromBox(). Referenced by IncrementalSampleCuikSystem(). ◆ CuikNewtonSimp()
This is simplified a version of CuikNewtonInBox since
This used when defining a RRT: we sample points in ambient space (of the simplified system) and we want to converge to the manifold (if possible). If you want to understand what is done in CuikNewtonInBox it is better to start by this function.
Definition at line 3819 of file cuiksystem.c. References ArrayPi2Pi(), CONVERGED_IN_BOX, CONVERGED_IN_GLOBAL, CT_EPSILON, CT_MAX_NEWTON_ITERATIONS, DeleteNewton(), DIVERGED, Error(), ErrorInSimpCSEquations(), EvaluateEqualityEquations(), EvaluateJacobianInVector(), FALSE, GetNewtonMatrixBuffer(), GetNewtonRHBuffer(), GetParameter(), InitNewton(), TCuikSystem::J, NewtonStep(), TCuikSystem::simp_equations, TCuikSystem::simp_nee, TCuikSystem::simp_nequations, TCuikSystem::simp_nvariables, TCuikSystem::simp_tp, TRUE, and UpdateCuikSystem(). Referenced by WorldSimpCuikNewton(). ◆ CuikNewtonInBox()
Find a solution of a cuiksystem set of equations using the Newton-Rhapson method. The initial point is sampled form the given box.
Definition at line 3917 of file cuiksystem.c. References ArrayPi2Pi(), CONVERGED_IN_BOX, CONVERGED_IN_GLOBAL, CONVERGED_OUTSIDE_GLOBAL, CopyBox(), CT_EPSILON, CT_MAX_NEWTON_ITERATIONS, DeleteBox(), DeleteNewton(), DIVERGED, Error(), ErrorInInequalities(), EvaluateEqualityEquations(), EvaluateJacobianInVector(), FALSE, GenerateInitialBox(), GetBoxInterval(), GetBoxNIntervals(), GetNewtonMatrixBuffer(), GetNewtonRHBuffer(), GetNumDummyVariables(), GetParameter(), InitBoxFromPoint(), InitNewton(), IntervalCenter(), IntervalSize(), TCuikSystem::J, NEW, NewInterval(), NewtonSetMatrix(), NewtonSetRH(), NewtonStep(), Norm(), TCuikSystem::orig2s, TCuikSystem::orig_notDummyVar, TCuikSystem::orig_nvariables, TCuikSystem::orig_systemVar, TCuikSystem::orig_variables, PointInBox(), randomInInterval(), RegenerateSolution(), SetBoxInterval(), SetBoxSubset(), TCuikSystem::simp_equations, TCuikSystem::simp_nee, TCuikSystem::simp_nequations, TCuikSystem::simp_nvariables, TCuikSystem::simp_tp, SimpleFromOriginal(), UpdateCuikSystem(), and UpdateOriginalFromSimple(). Referenced by CuikNewton(), IncrementalSampleCuikSystemInBox(), main(), and PostProcessBox(). ◆ CuikNewton()
Find a solution of a cuiksystem set of equations using the Newton-Rhapson method. This function is only a wrapper of CuikNewtonInBox using the initial box (i.e., the one defined form the variable ranges) to sample the initial point.
Definition at line 4150 of file cuiksystem.c. References CONVERGED_IN_BOX, CONVERGED_IN_GLOBAL, CuikNewtonInBox(), DeleteBox(), and GenerateInitialBox(). Referenced by main(), and NewtonInWorld(). ◆ CuikGradientInBox()
Find a solution of a cuiksystem set of equations using the gradient descent method. The initial point is sampled form the given box.
Definition at line 4164 of file cuiksystem.c. References ArrayPi2Pi(), CONVERGED_IN_BOX, CONVERGED_IN_GLOBAL, CONVERGED_OUTSIDE_GLOBAL, CopyBox(), Crop2Box(), CT_EPSILON, DeleteBox(), DistanceToInterval(), DIVERGED, Error(), ErrorInInequalities(), EvaluateEqualitySparseEquations(), EvaluateJacobianInVector(), FALSE, GenerateInitialBox(), GetBoxInterval(), GetBoxIntervals(), GetBoxNIntervals(), GetNumDummyVariables(), GetParameter(), InitBoxFromPoint(), IntervalCenter(), TCuikSystem::J, NEW, NewInterval(), NEWZ, Norm(), TCuikSystem::orig2s, TCuikSystem::orig_notDummyVar, TCuikSystem::orig_nvariables, TCuikSystem::orig_systemVar, TCuikSystem::orig_variables, PointInBox(), randomInInterval(), RC2INDEX, RegenerateSolution(), SetBoxInterval(), SetBoxSubset(), TCuikSystem::simp_equations, TCuikSystem::simp_nee, TCuikSystem::simp_nequations, TCuikSystem::simp_nvariables, TCuikSystem::simp_tp, SimpleFromOriginal(), SumVectorScale(), TMatrixVectorProduct(), TRUE, UpdateCuikSystem(), and UpdateOriginalFromSimple(). Referenced by CuikGradient(), and main(). ◆ CuikGradient()
Find a solution of a cuiksystem set of equations using gradient descent method. This function is only a wrapper of CuikGradientInBox using the initial box (i.e., the one defined form the variable ranges) to sample the initial point.
Definition at line 4374 of file cuiksystem.c. References CONVERGED_IN_BOX, CONVERGED_IN_GLOBAL, CuikGradientInBox(), DeleteBox(), and GenerateInitialBox(). Referenced by main(). ◆ SolveCuikSystem()
This is the entry function for the Cuik solver. It takes as input a cuiksystem and returns a set of boxes bounding the solution set. If the solutions are isolated (zero-dimensional) the output is a set of isolated boxes. If the solution is continuous the output is a set of boxes bounding the solution space. Be aware that isolating solution sets with high dimensionality can be expensive. To this end it is recommended to use the parallel version of cuik
Definition at line 4395 of file cuiksystem.c. References AddBox2HeapOfBoxes(), AddList2Heap(), BoxFromVariables(), BREADTH_FIRST_SEARCH, CmpBoxBreadthFirst(), CmpBoxDepthFirst(), CmpBoxesEquation(), CT_N_SOLUTIONS, CT_STATE_PERIOD, DeleteBox(), DeleteHeap(), DeleteListOfBoxes(), DEPTH_FIRST_SEARCH, DUMMY_VAR, Error(), EvaluateEqMin(), ExtractMinElement(), FALSE, GetBoxLevel(), GetBoxSize(), GetBoxVolume(), GetNSolutionBoxes(), GetParameter(), Heap2List(), HeapEmpty(), HeapOfBoxesVolume(), InitBox(), InitHeapOfBoxes(), InitStatistics(), LoadCSState(), MINIMIZATION_SEARCH, NewBoxProcessed(), NewMaxLevel(), TCuikSystem::orig2sd, PostProcessBox(), PrintBox(), PrintStatistics(), ReduceBox(), REDUCED_BOX_WITH_SOLUTION, SaveCSState(), TCuikSystem::scalar, TCuikSystem::searchMode, TCuikSystem::simp_empty, TCuikSystem::simp_nvariables, SimpleFromOriginal(), TCuikSystem::st, TCuikSystem::systemVar, UpdateCuikSystem(), and TCuikSystem::variables. Referenced by DealWithCP(), IncrementalSampleCuikSystemInBox(), main(), and SampleCuikSystemInBox(). ◆ MPI_SolveCuikSystem()
This is the parallel version of SolveCuikSystem. Actually this function is the main scheduler, i.e., the one in charge of managing the boxes to be processes to send them to the child processors. to collec the result, and to deal with them accordingly (bisect, consider solutions, discard if they are empty,...).
Definition at line 4572 of file cuiksystem.c. References AddBox2HeapOfBoxes(), AddFirstElement(), AddList2Heap(), AddNBoxReductions(), Box2Buffer(), BoxFromVariables(), BREADTH_FIRST_SEARCH, Buffer2Box(), CmpBoxBreadthFirst(), CmpBoxDepthFirst(), CmpBoxesEquation(), CT_N_SOLUTIONS, CT_STATE_PERIOD, DeleteBox(), DeleteHeap(), DeleteListOfBoxes(), DeleteStatistics(), DEPTH_FIRST_SEARCH, Error(), ERROR_IN_PROCESS, ExtractMinElement(), FALSE, GetBoxBufferSize(), GetBoxLevel(), GetBoxSize(), GetBoxVolume(), GetNSolutionBoxes(), GetParameter(), Heap2List(), HeapEmpty(), HeapOfBoxesVolume(), HeapSize(), InitBox(), InitHeapOfBoxes(), InitStatistics(), LoadCSState(), MINIMIZATION_SEARCH, MPI_TREAT_BOX_TIMEOUT, NEW, NewBoxProcessed(), NewLostBox(), NewMaxLevel(), TCuikSystem::nvariables, TCuikSystem::orig2sd, PostProcessBox(), PrintBox(), PrintStatistics(), REDUCED_BOX, SaveCSState(), TCuikSystem::scalar, TCuikSystem::searchMode, SimpleFromOriginal(), TCuikSystem::st, TCuikSystem::systemVar, TRUE, UpdateCuikSystem(), and TCuikSystem::variables. Referenced by main(). ◆ MPI_TreatBox()
This is the function executed by the child processors when solving a problem in a multi-processor environment.
Definition at line 4959 of file cuiksystem.c. References Box2Buffer(), Buffer2Box(), DeleteBox(), DUMMY_VAR, Error(), FALSE, GetBoxBufferSize(), GetNBoxReductions(), InitBox(), NEW, TCuikSystem::nvariables, PrintBox(), ReduceBox(), ResetNBoxReductions(), TCuikSystem::scalar, TCuikSystem::st, TRUE, and UpdateCuikSystem(). Referenced by main(). ◆ GenerateInitialBox()
Determines the search space for the solutions of a cuiksystem in the form of a box defined from the variable ranges.
Definition at line 5052 of file cuiksystem.c. References BoxFromVariables(), and TCuikSystem::orig_variables. Referenced by CuikGradient(), CuikGradientInBox(), CuikNewton(), CuikNewtonInBox(), GetWorldInitialBox(), IncrementalSampleCuikSystem(), SampleCuikSystem(), and SampleCuikSystemInBox(). ◆ GenerateSimpInitialBox()
The same as GenerateInitialBox but for the simplified system.
Definition at line 5057 of file cuiksystem.c. References BoxFromVariables(), Error(), TCuikSystem::simp_variables, and UpdateCuikSystem(). Referenced by GetWorldSimpInitialBox(). ◆ RegenerateSolution()
Generates values for all variables in the box (including dummies and cartesian ones) from the values of the system variables. In general, solutions only include system variables and for many operations the cartesian/dummy ones are also needed (for plotting, for refining a solution,...). This functions reverses the removal of the non-system variables in a box. Observe that the box must be given in the original system and with values only for the system variables. This is different of what happens with RegenerateOriginalBox where the input box has values for all variables in the simplified system.
Definition at line 5065 of file cuiksystem.c. References CARTESIAN_VAR, CropEquation(), CT_EPSILON, CT_RHO, DUMMY_VAR, EMPTY_BOX, FALSE, GetParameter(), INF, IsCartesianVariable(), IsCoordEquation(), IsDummyEquation(), IsDummyVariable(), NewInterval(), TCuikSystem::orig_equations, TCuikSystem::orig_nvariables, TCuikSystem::orig_variables, SetBoxInterval(), TRUE, and UpdateCuikSystem(). Referenced by CuikGradientInBox(), CuikNewtonInBox(), and RegenerateSolutionPoint(). ◆ RegenerateSolutionPoint()
Defines a solution point including the dummy and cartesian variables from an array with only values for the system variables. This function is based on RegenerateSolution.
Definition at line 5125 of file cuiksystem.c. References DeleteBox(), Error(), GetBoxInterval(), InitBoxFromPoint(), IntervalCenter(), NEW, TCuikSystem::orig_nvariables, TCuikSystem::orig_systemVar, RegenerateSolution(), and UpdateCuikSystem(). Referenced by ManifoldDimension(). ◆ RegenerateOriginalBox()
Generates a box in the original cuiksystem from a box of the simplified one. You can generate a simplified cuiksystem using cuiksimplify and then solve it. To obtain the solution boxes in the un-simplified (or original) system using the cuikunsimplify application that basically relies on this function.
Definition at line 5166 of file cuiksystem.c. References BoxFromVariables(), Error(), TCuikSystem::orig2s, TCuikSystem::orig_variables, UpdateCuikSystem(), and UpdateOriginalFromSimple(). Referenced by main(). ◆ RegenerateOriginalPoint()
Defines a point in the original system from a point in the simplified system. It is like RegenerateOriginalBox but on points and not on boxes and taking points from the simplified system and not the simplified+dummified. This is basically used from cuikatlas that operates on the simplified system.
Definition at line 5177 of file cuiksystem.c. References Error(), TCuikSystem::orig2s, TCuikSystem::orig_nvariables, TCuikSystem::orig_variables, PointFromVariables(), UpdateCuikSystem(), and UpdateOriginalPointFromSimple(). Referenced by GetLinkTransformsFromSolutionPoint(), RegenerateWorldOriginalPoint(), WorldForceField(), and WorldPotentialEnergy(). ◆ GenerateSimplifiedPoint()
Generates a simplified point from an original one. This is the inverse mapping of RegenerateOriginalPoint.
Definition at line 5191 of file cuiksystem.c. References Error(), TCuikSystem::orig2s, TCuikSystem::simp_nvariables, SimplePointFromOriginal(), and UpdateCuikSystem(). Referenced by ManifoldDimension(), WorldForceField(), WorldGenerateSimplifiedPoint(), and WorldGenerateSimplifiedPointFromSystem(). ◆ SimplifyBooleanArray()
Transforms an array of booleans that selects a subset of the variables in the original system to a subset of variables in the simplified system. Only the entries for the variables of the original system also used in the simplified system are preserved.
Definition at line 5201 of file cuiksystem.c. References Error(), IsInSimple(), NEW, TCuikSystem::orig2s, TCuikSystem::orig_nvariables, TCuikSystem::simp_nvariables, and UpdateCuikSystem(). Referenced by WorldSimpKinematicVars(). ◆ ComputeSplitDim()
Determines the dimension for which it is more advisable to split a box. The criterion to determine the split dimension can be selected through the parameters.
Definition at line 5235 of file cuiksystem.c. References ComputeSplitDimInt(), DeleteBox(), Error(), GetVarIDInOriginal(), NO_UINT, TCuikSystem::orig2sd, TCuikSystem::scalar, SimpleFromOriginal(), and UpdateCuikSystem(). Referenced by SampleCuikSystemInBox(). ◆ PointInSystemBox()
Determines if a given point is fully included in the system sub-box (i.e., the sub-box fot the system variables). The point is typically one obtained via sampling.
Definition at line 5259 of file cuiksystem.c. References Error(), GetBoxInterval(), GetBoxNIntervals(), GetVectorElement(), IsDummyVariable(), IsInside(), NVariables(), TCuikSystem::orig_variables, and TRUE. ◆ EvaluateCSEquations()
Evaluates the equation set on a point. Only equalities are evaluated and thus only space for as many ouputs as equalities is needed in r.
Definition at line 5286 of file cuiksystem.c. References EvaluateEqualityEquations(), FALSE, and TCuikSystem::orig_equations. Referenced by WorldEvaluateEquations(). ◆ EvaluateSimpCSEquations()
The same as EvaluateCSEquations but on the simplified system. The direct access to the simplified equations is needed to obtain an efficient cuikatlas (and associated utilities). If defined on the original systems they will include too many (trivial) equations and fixed variables. Note that in this case the input point p must be defined on the simplified space.
Definition at line 5291 of file cuiksystem.c. References Error(), EvaluateEqualityEquations(), FALSE, TCuikSystem::simp_equations, and UpdateCuikSystem(). Referenced by WorldEvaluateSimpEquations(). ◆ EvaluateSubSetSimpCSEquations()
The same as EvaluateSimpCSEquations but on a subset of equations. This is used to evaluate the independent subset of equations during the atlas construction.
Definition at line 5299 of file cuiksystem.c. References Error(), EvaluateSubSetEqualityEquations(), TCuikSystem::simp_equations, and UpdateCuikSystem(). Referenced by WorldEvaluateSubSetSimpEquations(). ◆ ErrorInCSEquations()
Evaluates the equations on a point and returns the norm of the error. Recall that solution points should have zero error. This is similar to ErrorInSolution but works on points and not on boxes and takes into account all equations and not only system ones.
Definition at line 5319 of file cuiksystem.c. References EvaluateEqualityEquations(), FALSE, NEqualityEquations(), NEW, Norm(), and TCuikSystem::orig_equations. Referenced by main(), and WorldErrorInEquations(). ◆ ErrorInSimpCSEquations()
The same as ErrorInCSEquations but in the simplified set of equations. The direct access to the simplified equations is needed to obtain an efficient cuikatlas (and associated utilities). If defined on the original systems they will include too many (trivial) equations and fixed variables. Note that in this case the input point p must be defined on the simplified space.
Definition at line 5341 of file cuiksystem.c. References Error(), EvaluateEqualityEquations(), FALSE, NEqualityEquations(), NEW, Norm(), TCuikSystem::simp_equations, and UpdateCuikSystem(). Referenced by CuikNewtonSimp(), ManifoldDimension(), and WorldErrorInSimpEquations(). ◆ EvaluateCSCost()
This interface is provided to use it form T-RRT. The same interface is used for other cost function.
Definition at line 5363 of file cuiksystem.c. References EvaluateWholeEquation(). Referenced by EvaluateWorldCost(). ◆ EvaluateCSJacobian()
Returns the matrix resulting from evaluationg the Jacobian of the system in a given point. The Jacobian is defined on the original cuiksystem (without simplification nor dummyfications).
Definition at line 5307 of file cuiksystem.c. References AllocateJacobianEvaluation(), DeleteJacobian(), EvaluateJacobian(), InitJacobian(), TCuikSystem::orig_equations, and TCuikSystem::orig_variables. Referenced by EvaluateWorldJacobian(). ◆ ErrorInSolution()
Computes the error for the solution represented by a box. The error is computed taking the central point of the box and replacing the values in the equation set. Only system equality equations are taken into account in the error.
Definition at line 5381 of file cuiksystem.c. References Error(), EvaluateEqualityEquations(), GetBoxInterval(), GetBoxNIntervals(), IntervalCenter(), NEqualityEquations(), NEW, Norm(), NVariables(), TCuikSystem::orig_equations, TCuikSystem::orig_variables, and TRUE. Referenced by IncrementalSampleCuikSystemInBox(), main(), and PostProcessBox(). ◆ ErrorInInequalities()
Computes the error for the solution represented by a box as far as inequalities is concerned. The error is computed taking the central point of the box and replacing the values in the equation set. This can be seen as a complement of ErrorInSolution when inequalities are also to be taken into account.
Definition at line 5420 of file cuiksystem.c. References Error(), EvaluateInequalityEquations(), GetBoxInterval(), GetBoxNIntervals(), IntervalCenter(), MaxVector(), NEW, NInequalityEquations(), NVariables(), TCuikSystem::orig_equations, TCuikSystem::orig_nvariables, and TCuikSystem::orig_variables. Referenced by CuikGradientInBox(), and CuikNewtonInBox(). ◆ InequalitiesHoldOnPoint()
Checks if all inqualities hold for a given point. For many processes (i.e., continuation, etc) only the equalities are taken into account. Thus, we need a function to check if the inequalities hold.
Definition at line 5449 of file cuiksystem.c. References EvaluateInequalityEquations(), MaxVector(), NEW, NInequalityEquations(), TCuikSystem::orig_equations, and TRUE. Referenced by WorldInequalitiesHold(). ◆ SimpInequalitiesHoldOnPoint()
Checks if all inqualities hold for a given point for the simplified system.
Definition at line 5469 of file cuiksystem.c. References Error(), EvaluateInequalityEquations(), MaxVector(), NEW, NInequalityEquations(), TCuikSystem::simp_equations, TRUE, and UpdateCuikSystem(). Referenced by WorldSimpInequalitiesHold(). ◆ ErrorInSimpInequalitiesOnPoint()
Determines the maximum error in the inequalities in the simplified system.
Definition at line 5492 of file cuiksystem.c. References Error(), EvaluateInequalityEquations(), MaxVector(), NEW, NInequalityEquations(), TCuikSystem::simp_equations, and UpdateCuikSystem(). Referenced by WorldErrorInSimpInequalities(). ◆ ManifoldDimension()
Computes the dimension of the solution space assuming that the given point 'p' is a regular point.
Definition at line 5513 of file cuiksystem.c. References CT_EPSILON, Error(), ErrorInSimpCSEquations(), EvaluateTransposedJacobianInVector(), FindRank(), GenerateSimplifiedPoint(), GetJacobianSize(), GetParameter(), TCuikSystem::J, NEW, RegenerateSolutionPoint(), TCuikSystem::simp_nequations, and UpdateCuikSystem(). Referenced by WorldManifoldDimension(). ◆ PrintCuikSystem()
Writes the cuiksystem in a file that can be stdout.
Definition at line 5560 of file cuiksystem.c. References GetVariableNames(), MINIMIZATION_SEARCH, NEW, NVariables(), TCuikSystem::orig_eqMin, TCuikSystem::orig_equations, TCuikSystem::orig_variables, PrintEquations(), PrintMonomials(), PrintVariables(), and TCuikSystem::searchMode. Referenced by AdjustBioWorldGeometry(), main(), and PrintWorldCS(). ◆ PrintCuikSystemWithSimplification()
Writes the simplified cuiksystem in a file that can be stdout. If the DEBUG mode is above 1 it first print the original system and then the simplified one (in the same file)
Definition at line 5585 of file cuiksystem.c. References CT_SIMPLIFICATION_LEVEL, TCuikSystem::eqMin, TCuikSystem::equations, GetNumNonDynamicVariables(), GetNumSecondaryVariables(), GetNumSystemVariables(), GetNumVelocityVariables(), GetParameter(), GetVariableNames(), MINIMIZATION_SEARCH, NEW, NVariables(), TCuikSystem::orig2sd, TCuikSystem::orig_nvariables, TCuikSystem::orig_variables, PrintEquations(), PrintMapping(), PrintMonomials(), PrintVariables(), TCuikSystem::searchMode, TCuikSystem::simp_nvariables, TCuikSystem::simp_variables, UpdateCuikSystem(), and TCuikSystem::variables. Referenced by DealWithCP(), and main(). ◆ SaveCuikSystemSimplification()
Saves the simplification information associated with a cuiksystem.
Definition at line 5626 of file cuiksystem.c. References TCuikSystem::orig2sd, SaveMapping(), and UpdateCuikSystem(). ◆ DeleteCuikSystem()
Deletes a cuiksystem.
Definition at line 5637 of file cuiksystem.c. References TCuikSystem::constants, DeleteConstants(), DeleteEquation(), DeleteEquations(), DeleteStatistics(), DeleteVariables(), TCuikSystem::empty, TCuikSystem::orig_eqMin, TCuikSystem::orig_equations, TCuikSystem::orig_variables, TCuikSystem::simp_empty, TCuikSystem::st, TRUE, and UnUpdateCuikSystem(). Referenced by AddSimplifiedJacobianEquations(), AdjustBioWorldGeometry(), DealWithCP(), DeleteWorldCS(), and main(). | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Follow us!