colamd.c File Reference

#include <math.h>
#include "colamd.h"
#include <limits.h>
#include <stdio.h>
#include <assert.h>

Include dependency graph for colamd.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	PUBLIC
#define	PRIVATE   static
#define	MAX(a, b)   (((a) > (b)) ? (a) : (b))
#define	MIN(a, b)   (((a) < (b)) ? (a) : (b))
#define	ONES_COMPLEMENT(r)   (-(r)-1)
#define	TRUE   (1)
#define	FALSE   (0)
#define	EMPTY   (-1)
#define	ALIVE   (0)
#define	DEAD   (-1)
#define	DEAD_PRINCIPAL   (-1)
#define	DEAD_NON_PRINCIPAL   (-2)
#define	ROW_IS_DEAD(r)   ROW_IS_MARKED_DEAD (Row[r].shared2.mark)
#define	ROW_IS_MARKED_DEAD(row_mark)   (row_mark < ALIVE)
#define	ROW_IS_ALIVE(r)   (Row [r].shared2.mark >= ALIVE)
#define	COL_IS_DEAD(c)   (Col [c].start < ALIVE)
#define	COL_IS_ALIVE(c)   (Col [c].start >= ALIVE)
#define	COL_IS_DEAD_PRINCIPAL(c)   (Col [c].start == DEAD_PRINCIPAL)
#define	KILL_ROW(r)   { Row [r].shared2.mark = DEAD ; }
#define	KILL_PRINCIPAL_COL(c)   { Col [c].start = DEAD_PRINCIPAL ; }
#define	KILL_NON_PRINCIPAL_COL(c)   { Col [c].start = DEAD_NON_PRINCIPAL ; }
#define	PRINTF   printf
#define	INDEX(i)   (i)
#define	DEBUG0(params)   ;
#define	DEBUG1(params)   ;
#define	DEBUG2(params)   ;
#define	DEBUG3(params)   ;
#define	DEBUG4(params)   ;
#define	ASSERT(expression)   ((void) 0)

Typedefs
typedef long int	integer
typedef double	doublereal

Functions
static integer	init_rows_cols (integer n_row, integer n_col, mbdyn_Colamd_Row Row[], mbdyn_Colamd_Col Col[], integer A[], integer p[], integer stats[20])
static void	init_scoring (integer n_row, integer n_col, mbdyn_Colamd_Row Row[], mbdyn_Colamd_Col Col[], integer A[], integer head[], double knobs[20], integer *p_n_row2, integer *p_n_col2, integer *p_max_deg)
static integer	find_ordering (integer n_row, integer n_col, integer Alen, mbdyn_Colamd_Row Row[], mbdyn_Colamd_Col Col[], integer A[], integer head[], integer n_col2, integer max_deg, integer pfree)
static void	order_children (integer n_col, mbdyn_Colamd_Col Col[], integer p[])
static void	detect_super_cols (mbdyn_Colamd_Col Col[], integer A[], integer head[], integer row_start, integer row_length)
static integer	garbage_collection (integer n_row, integer n_col, mbdyn_Colamd_Row Row[], mbdyn_Colamd_Col Col[], integer A[], integer *pfree)
static integer	clear_mark (integer n_row, mbdyn_Colamd_Row Row[])
static void	print_report (char *method, integer stats[20])
integer	mbdyn_colamd_recommended (integer nnz, integer n_row, integer n_col)
void	mbdyn_colamd_set_defaults (double knobs[20])
integer	mbdyn_symamd (integer n, integer A[], integer p[], integer perm[], double knobs[20], integer stats[20], void *(*allocate)(size_t, size_t), void(*release)(void *))
integer	mbdyn_colamd (integer n_row, integer n_col, integer Alen, integer A[], integer p[], double knobs[20], integer stats[20])
void	mbdyn_colamd_report (integer stats[20])
void	mbdyn_symamd_report (integer stats[20])

Macro Definition Documentation

#define ALIVE   (0)

Definition at line 771 of file colamd.c.

#define ASSERT

(

expression

)

((void) 0)

Definition at line 977 of file colamd.c.

Referenced by FileName::_sPutExt(), OutputHandler::Abstract(), Accumulator::Accumulator(), Actuator::Actuator(), STLVectorHandler::Add(), VectorHandler::Add(), VecN::Add(), MyVectorHandler::Add(), Mat3xN::Add(), FullMatrixHandler::Add(), MatNx3::Add(), MatNxN::Add(), Mat6x6::AddMat(), Mat3xN::AddMat3x3(), InducedVelocity::AddSectionalForce(), FullMatrixHandler::AddT(), NonlinearSolver::AddTimeCPU(), Vec3::AddTo(), FullSubMatrixHandler::AddTo(), Mat3x3::AddTo(), SparseSubMatrixHandler::AddTo(), FullSubMatrixHandler::AddToT(), SparseSubMatrixHandler::AddToT(), CompactSparseMatrixHandler::AddUnchecked(), Mat3xN::AddVec(), MatNx3::AddVec(), Mat3x3::AddVec(), ThirdOrderIntegrator::Advance(), DerivativeSolver::Advance(), Step1Integrator::Advance(), Step2Integrator::Advance(), InverseDynamicsStepSolver::Advance(), OutputHandler::Aerodynamic(), Aerodynamic2DElem< iNN >::Aerodynamic2DElem(), AerodynamicBeam::AerodynamicBeam(), AerodynamicBeam2::AerodynamicBeam2(), AerodynamicBody::AerodynamicBody(), AerodynamicModal::AerodynamicModal(), OutputHandler::AeroModals(), NestedElem::AfterConvergence(), DrivenElem::AfterConvergence(), InducedVelocity::AfterConvergence(), LoadableElem::AfterConvergence(), ConstitutiveLawOwner< T, Tder >::AfterConvergence(), DiscreteControlElem::AfterConvergence(), DataManager::AfterConvergence(), DynamicStructDispNode::AfterConvergence(), DynamicStructNode::AfterConvergence(), DrivenElem::AfterPredict(), NestedElem::AfterPredict(), LoadableElem::AfterPredict(), OutputHandler::AirProps(), MatrixScale< T >::Allocate(), NamedValue::AllocName(), amul(), angle(), anglerel(), AngularAccelerationJoint::AngularAccelerationJoint(), angvel(), angvrel(), ArrayTplDriveCaller< T >::ArrayTplDriveCaller(), ArrayTplDriveCaller< doublereal >::ArrayTplDriveCaller(), DataManager::AssConstrJac(), DataManager::AssConstrRes(), DistanceJoint::AssJac(), DrivenElem::AssJac(), NestedElem::AssJac(), ThreeWayMinorLoss::AssJac(), RodBezier::AssJac(), Rod::AssJac(), ModuleNonsmoothNode::AssJac(), DistanceJointWithOffset::AssJac(), ElasticAxialJoint::AssJac(), ElasticDispJoint::AssJac(), ElasticHingeJoint::AssJac(), LoadableElem::AssJac(), ElasticJoint::AssJac(), Beam2::AssJac(), DataManager::AssJac(), LoadIncForce::AssJac(), DrivenElem::AssMats(), NestedElem::AssMats(), LoadableElem::AssMats(), DataManager::AssMats(), InLineJoint::AssRes(), DistanceJoint::AssRes(), UniversalHingeJoint::AssRes(), PrismaticJoint::AssRes(), SphericalHingeJoint::AssRes(), InPlaneJoint::AssRes(), DrivenElem::AssRes(), StructMappingExtForce::AssRes(), GenelDistance::AssRes(), NestedElem::AssRes(), RodBezier::AssRes(), PlaneHingeJoint::AssRes(), ViscousBody::AssRes(), DynamicMass::AssRes(), DynamicVariableBody::AssRes(), Rod::AssRes(), InLineWithOffsetJoint::AssRes(), TotalEquation::AssRes(), TotalJoint::AssRes(), DistanceJointWithOffset::AssRes(), UniversalRotationJoint::AssRes(), PinJoint::AssRes(), AeroDynModule::AssRes(), DeformableJoint::AssRes(), ElasticAxialJoint::AssRes(), ElasticDispJoint::AssRes(), StaticMass::AssRes(), ElasticHingeJoint::AssRes(), StaticVariableBody::AssRes(), LoadableElem::AssRes(), Beam2::AssRes(), UniversalPinJoint::AssRes(), PlaneRotationJoint::AssRes(), Modal::AssRes(), ClampJoint::AssRes(), ElasticDispJointInv::AssRes(), ViscousAxialJoint::AssRes(), DynamicBody::AssRes(), TotalPinJoint::AssRes(), ViscousHingeJoint::AssRes(), ViscousDispJoint::AssRes(), ViscoElasticAxialJoint::AssRes(), ModalBody::AssRes(), AxialRotationJoint::AssRes(), StaticBody::AssRes(), ViscoElasticDispJoint::AssRes(), TotalForce::AssRes(), LoadIncForce::AssRes(), PlanePinJoint::AssRes(), ViscoElasticHingeJoint::AssRes(), DriveDisplacementJoint::AssVec(), DriveHingeJoint::AssVec(), GenericAerodynamicForce::AssVec(), DriveDisplacementPinJoint::AssVec(), SparseSubMatrixHandler::Attach(), AutomaticStructElem::AutomaticStructElem(), NaiveSparsePermSolutionManager< T >::BackPerm(), Beam::Beam(), Beam2::Beam2(), OutputHandler::Beams(), BeamSliderJoint::BeamSliderJoint(), DrivenElem::BeforePredict(), NestedElem::BeforePredict(), LoadableElem::BeforePredict(), VecIter< Elem * >::bGetCurr(), VecIter< Elem * >::bGetFirst(), VecIter< Elem * >::bGetNext(), StrainGageParam::Bind(), NestedElem::bInverseDynamics(), DriveArrayCaller::bIsDifferentiable(), BiStopCLWrapper< T, Tder >::BiStopCLWrapper(), NonlinearSolverTestRange::bIsValid(), bmul(), Body::Body(), BufferStreamDrive_base::BufferStreamDrive_base(), c81_data_merge(), C81AeroData::C81AeroData(), C81InterpolatedAeroData::C81InterpolatedAeroData(), C81MultipleAeroData::C81MultipleAeroData(), MinMaxDriveDCR::c_str(), DataManager::Cast(), Solver::CheckTimeStepLimit(), IncludeParser::Close(), CenterOfMass::Collect_int(), SchurMatrixHandler::CompNewf(), SchurMatrixHandlerUm::CompNewf(), SchurMatrixHandler::CompNewg(), AutomaticStructElem::ComputeAccelerations(), IterativeMatrixScale< T >::ComputeScaleFactors(), MatrixHandler::ConditionNumber(), ConstitutiveLawOwner< T, Tder >::ConstitutiveLawOwner(), ContactJoint::ContactJoint(), Control_valve::Control_valve(), Control_valve2::Control_valve2(), DataManager::ConvergedSet(), VecN::Copy(), MatNxN::Copy(), FullMatrixHandler::CopyMatrixBlock(), FullMatrixHandler::CopyMatrixRow(), VecN::Create_(), Mat3xN::Create_(), MatNx3::Create_(), MatNxN::Create_(), FullMatrixHandler::CreateColRow(), IdentProcess::CreateIdent(), d_get_priv_data(), DAC_Process_Debug::DAC_Process_Debug(), STLVectorHandler::DecCoef(), MyVectorHandler::DecCoef(), FullMatrixHandler::DecCoef(), SparseSubMatrixHandler::DecCoef(), DeformableAxialJoint::DeformableAxialJoint(), DeformableDispJoint::DeformableDispJoint(), DeformableHingeJoint::DeformableHingeJoint(), DeformableJoint::DeformableJoint(), NestedElem::DescribeDof(), Node::DescribeDof(), TotalJoint::DescribeDof(), ConstitutiveLaw< doublereal, doublereal >::DescribeDof(), Elem::DescribeDof(), ModLugreFriction::DescribeDof(), Aerodynamic2DElem< iNN >::DescribeDof(), DiscreteCoulombFriction::DescribeDof(), ConstitutiveLawOwner< T, Tder >::DescribeDof(), TotalPinJoint::DescribeDof(), NestedElem::DescribeEq(), Node::DescribeEq(), TotalJoint::DescribeEq(), Elem::DescribeEq(), ConstitutiveLaw< doublereal, doublereal >::DescribeEq(), ModLugreFriction::DescribeEq(), Aerodynamic2DElem< iNN >::DescribeEq(), DiscreteCoulombFriction::DescribeEq(), ConstitutiveLawOwner< T, Tder >::DescribeEq(), TotalPinJoint::DescribeEq(), detect_super_cols(), FileDrive::dGet(), MultiStepDrive::dGet(), VecN::dGet(), Vec6::dGet(), Mat3xN::dGet(), Vec3::dGet(), MatNx3::dGet(), Mat6x6::dGet(), MatNxN::dGet(), Mat3x3::dGet(), DriveArrayCaller::dGet(), STLVectorHandler::dGetCoef(), MyVectorHandler::dGetCoef(), FullMatrixHandler::dGetCoef(), SparseSubMatrixHandler::dGetCoef(), AeroDynModule::dGetCurrBladeNodeBuiltinTwist(), AeroDynModule::dGetCurrBladeNodePITNOW(), GaussDataIterator::dGetCurrPnt(), NumIntIterator::dGetCurrPnt(), GaussDataIterator::dGetCurrWght(), NumIntIterator::dGetCurrWght(), Elem2Param::dGetDofValue(), StrainGageParam::dGetDofValue(), StructDispNode::dGetDofValue(), ScalarDifferentialNode::dGetDofValue(), ScalarAlgebraicNode::dGetDofValue(), DynamicStructDispNode::dGetDofValue(), StructNode::dGetDofValue(), DynamicStructNode::dGetDofValue(), StructDispNode::dGetDofValuePrev(), ScalarDifferentialNode::dGetDofValuePrev(), ScalarAlgebraicNode::dGetDofValuePrev(), DynamicStructDispNode::dGetDofValuePrev(), StructNode::dGetDofValuePrev(), DynamicStructNode::dGetDofValuePrev(), GaussDataIterator::dGetFirst(), NumIntIterator::dGetFirst(), IdentProcess::dGetForgettingFactor(), NestedElem::dGetM(), Factor::dGetNewStepTime(), DriveArrayCaller::dGetP(), Motor::dGetPhiElectric(), GaussData::dGetPnt(), TrapezoidData::dGetPnt(), HydraulicFluid::dGetPres0(), ModuleIMU::dGetPrivData(), LinearVelocityJoint::dGetPrivData(), ViscousBody::dGetPrivData(), DistanceJoint::dGetPrivData(), InducedVelocity::dGetPrivData(), DeformableAxialJoint::dGetPrivData(), DeformableDispJoint::dGetPrivData(), DeformableJoint::dGetPrivData(), DeformableHingeJoint::dGetPrivData(), Brake::dGetPrivData(), DriveDisplacementJoint::dGetPrivData(), DriveHingeJoint::dGetPrivData(), RodBezier::dGetPrivData(), PlaneHingeJoint::dGetPrivData(), Rod::dGetPrivData(), AngularVelocityJoint::dGetPrivData(), DistanceJointWithOffset::dGetPrivData(), TotalEquation::dGetPrivData(), TotalJoint::dGetPrivData(), HBeam::dGetPrivData(), StructDispNode::dGetPrivData(), LoadableElem::dGetPrivData(), DriveDisplacementPinJoint::dGetPrivData(), PlaneRotationJoint::dGetPrivData(), Beam2::dGetPrivData(), Wheel4::dGetPrivData(), Modal::dGetPrivData(), TotalReaction::dGetPrivData(), TimeStep::dGetPrivData(), Beam::dGetPrivData(), ViscoElasticBeam2::dGetPrivData(), TotalPinJoint::dGetPrivData(), AxialRotationJoint::dGetPrivData(), ViscoElasticBeam::dGetPrivData(), ShockAbsorberConstitutiveLaw< doublereal, doublereal >::dGetPrivData(), PlanePinJoint::dGetPrivData(), StructNode::dGetPrivData(), DeformableHingeJoint::dGetPrivDataInv(), HydraulicFluid::dGetTemp0(), DriveHandler::dGetTime(), NonlinearSolver::dGetTimeCPU(), DriveHandler::dGetTimeStep(), GaussData::dGetWght(), TrapezoidData::dGetWght(), DiscreteControlARXProcess_Debug::DiscreteControlARXProcess_Debug(), DiscreteControlElem::DiscreteControlElem(), DiscreteIdentProcess_Debug::DiscreteIdentProcess_Debug(), DispMeasure::DispMeasure(), distance(), DistanceJointWithOffset::DistanceJointWithOffset(), DataManager::DofOwnerInit(), DofOwnerOwner::DofOwnerOwner(), DofPlugIn::DofPlugIn(), OutputHandler::DofStats(), drive(), DriveArrayCaller::DriveArrayCaller(), OutputHandler::DriveCallers(), DriveDisplacementJoint::DriveDisplacementJoint(), DriveDisplacementPinJoint::DriveDisplacementPinJoint(), DriveHingeJoint::DriveHingeJoint(), DrivenElem::DrivenElem(), Beam::DsDxi(), DummyPlugIn::DummyPlugIn(), DummyStructNode::DummyStructNode(), Dynamic_control_valve::Dynamic_control_valve(), Dynamic_pipe::Dynamic_pipe(), DynamicForgettingFactor::DynamicForgettingFactor(), DynamicForgettingFactor2::DynamicForgettingFactor2(), DynamicPipe::DynamicPipe(), EE_Eval(), OutputHandler::Eigenanalysis(), OutputHandler::Electric(), DataManager::ElemAssInit(), DataManager::ElemOutputPrepare(), EE_Modulus::Eval(), EE_Divide::Eval(), EE_StmtList::Eval(), ImplicitStepIntegrator::EvalProd(), InverseDynamicsStepSolver::EvalProd(), OutputHandler::Externals(), IncludeParser::fCheckStack(), GaussDataIterator::fGetNext(), NumIntIterator::fGetNext(), FileDrive::FileDrive(), FileDriveCaller::FileDriveCaller(), find_ordering(), FixedStepFileDrive::FixedStepFileDrive(), Flow_valve::Flow_valve(), OutputHandler::Forces(), ForgettingFactor::ForgettingFactor(), FourierSeriesDriveCaller::FourierSeriesDriveCaller(), FreqSweepDriveCaller::FreqSweepDriveCaller(), FullMatrixHandler::FullMatrixHandler(), FullSubMatrixHandler::FullSubMatrixHandler(), garbage_collection(), GaussData::GaussData(), GenelCrossSpringDamperSupport::GenelCrossSpringDamperSupport(), GenelCrossSpringSupport::GenelCrossSpringSupport(), OutputHandler::Genels(), GenelSpringDamperSupport::GenelSpringDamperSupport(), GenelSpringSupport::GenelSpringSupport(), GenelStateSpaceMIMO::GenelStateSpaceMIMO(), GenelStateSpaceSISO::GenelStateSpaceSISO(), Eu2PhiWrap::Get(), GaussData::Get(), TrapezoidData::Get(), OutputHandler::Get(), NestedElem::GetAerodynamicElemType(), NestedElem::GetB_int(), BufferStreamElem::GetBuf(), BufferStreamDrive::GetBuf(), BufferStreamElem::GetBufRaw(), BufferStreamDrive::GetBufRaw(), BufferStreamDriveRaw::GetBufRaw(), Mat3x3::GetCol(), SolverDiagnostics::GetCondMatNorm(), MatrixScaleBase::GetCondNumNorm(), NestedElem::GetConnectedNodes(), LoadableElem::GetConnectedNodes(), DiscreteControlElem::GetConnectedNodes(), AeroDynModule::GetCurrBladeNodeRa(), AeroDynModule::GetCurrBladeR(), DataManager::GetDofDescription(), GenelClamp::GetDofType(), Accelerometer::GetDofType(), InlineFriction::GetDofType(), InLineJoint::GetDofType(), LinearAccelerationJoint::GetDofType(), DistanceJoint::GetDofType(), LinearVelocityJoint::GetDofType(), GenelStateSpaceSISO::GetDofType(), PrismaticJoint::GetDofType(), UniversalHingeJoint::GetDofType(), Pipe::GetDofType(), InPlaneContactJoint::GetDofType(), SphericalHingeJoint::GetDofType(), InPlaneJoint::GetDofType(), GimbalRotationJoint::GetDofType(), ContactJoint::GetDofType(), LoadIncNorm::GetDofType(), Accumulator::GetDofType(), NestedElem::GetDofType(), Brake::GetDofType(), DriveDisplacementJoint::GetDofType(), GenelDistance::GetDofType(), DriveHingeJoint::GetDofType(), TranslAccel::GetDofType(), PlaneHingeJoint::GetDofType(), TotalEquation::GetDofType(), AngularAccelerationJoint::GetDofType(), AerodynamicModal::GetDofType(), TotalJoint::GetDofType(), BeamSliderJoint::GetDofType(), GenelStateSpaceMIMO::GetDofType(), InLineWithOffsetJoint::GetDofType(), Dynamic_pipe::GetDofType(), AngularVelocityJoint::GetDofType(), DistanceJointWithOffset::GetDofType(), Tank::GetDofType(), UniversalRotationJoint::GetDofType(), PinJoint::GetDofType(), RotAccel::GetDofType(), Control_valve2::GetDofType(), InPlaneWithOffsetJoint::GetDofType(), StructDispNode::GetDofType(), Aerodynamic2DElem< iNN >::GetDofType(), Membrane4EAS::GetDofType(), LoadableElem::GetDofType(), DynamicPipe::GetDofType(), DriveDisplacementPinJoint::GetDofType(), PlaneRotationJoint::GetDofType(), UniversalPinJoint::GetDofType(), ClampJoint::GetDofType(), Dynamic_control_valve::GetDofType(), InducedVelocityElem::GetDofType(), Modal::GetDofType(), Shell4EAS::GetDofType(), ScalarDifferentialNode::GetDofType(), TotalReaction::GetDofType(), Shell4EASANS::GetDofType(), ConstitutiveLawOwner< T, Tder >::GetDofType(), ModuleIMUConstraint::GetDofType(), TotalPinJoint::GetDofType(), Pressure_flow_control_valve::GetDofType(), ScalarAlgebraicNode::GetDofType(), AxialRotationJoint::GetDofType(), GenelMass::GetDofType(), Pressure_valve::GetDofType(), Flow_valve::GetDofType(), PlanePinJoint::GetDofType(), Node2Scalar::GetDofType(), DataManager::GetDofType(), NestedElem::GetElemType(), DataManager::GetEqDescription(), GenelClamp::GetEqType(), InlineFriction::GetEqType(), GimbalRotationJoint::GetEqType(), LoadIncNorm::GetEqType(), NestedElem::GetEqType(), Membrane4EAS::GetEqType(), DynamicPipe::GetEqType(), ClampJoint::GetEqType(), Modal::GetEqType(), Shell4EAS::GetEqType(), Shell4EASANS::GetEqType(), DataManager::GetEqType(), BeamConn::Getf(), ConstitutiveLawOwner< T, Tder >::GetF(), ConstitutiveLawOwner< T, Tder >::GetFDE(), ConstitutiveLawOwner< T, Tder >::GetFDEPrime(), C81MultipleAeroData::GetForces(), Vec3::GetFrom(), Mat3x3::GetFrom(), NestedElem::GetG_int(), NaivePermMatrixHandler::GetInvPerm(), NestedElem::GetJ(), NestedElem::GetJ_int(), MathParser::GetLineNumber(), Mat6x6::GetMat(), Mat3xN::GetMat3x3(), Mat3xN::GetMat3x3ScalarMult(), MBDynParser::GetMat6xN(), NamedValue::GetName(), InitialAssemblyIterator::GetNext(), NestedElem::GetNumConnectedNodes(), LoadableElem::GetNumConnectedNodes(), NaivePermMatrixHandler::GetPerm(), Rotor::GetPos(), BeamConn::GetR(), Mat3x3::GetRow(), NestedElem::GetS(), NestedElem::GetS_int(), LinSol::GetSolutionManager(), MathParser::GetToken(), Vec6::GetVec(), Mat3xN::GetVec(), MatNx3::GetVec(), Mat3x3::GetVec(), GimbalRotationJoint::GimbalRotationJoint(), gpc_addmul(), GPC_LAPACK_pinv::GPC_LAPACK_pinv(), gpc_mul(), GPCDesigner::GPCDesigner(), OutputHandler::Gravity(), Gust1D::Gust1D(), HBeam::HBeam(), HopeSolver::HopeSolver(), OutputHandler::Hydraulic(), HydraulicElem::HydraulicElem(), HydrodynamicPlainBearing::HydrodynamicPlainBearing(), DataManager::IDDofInit(), Ident::Ident(), IdentProcess::IdentProcess(), FullSubMatrixHandler::iGetColIndex(), SparseSubMatrixHandler::iGetColIndex(), AeroDynModule::iGetCurrBlade(), AeroDynModule::iGetCurrBladeElem(), NestedElem::iGetFirstIndex(), NestedElem::iGetInitialNumDof(), LoadableElem::iGetInitialNumDof(), NestedElem::iGetNumDof(), ModuleNonsmoothNode::iGetNumDof(), LoadableElem::iGetNumDof(), ConstitutiveLawOwner< T, Tder >::iGetNumDof(), LoadableElem::iGetNumPrivData(), LinearAccelerationJoint::iGetPrivDataIdx(), LinearVelocityJoint::iGetPrivDataIdx(), AircraftInstruments::iGetPrivDataIdx(), ViscousBody::iGetPrivDataIdx(), DistanceJoint::iGetPrivDataIdx(), InducedVelocity::iGetPrivDataIdx(), DeformableAxialJoint::iGetPrivDataIdx(), DeformableDispJoint::iGetPrivDataIdx(), DeformableJoint::iGetPrivDataIdx(), Brake::iGetPrivDataIdx(), DeformableHingeJoint::iGetPrivDataIdx(), DriveDisplacementJoint::iGetPrivDataIdx(), DriveHingeJoint::iGetPrivDataIdx(), RodBezier::iGetPrivDataIdx(), AngularAccelerationJoint::iGetPrivDataIdx(), PlaneHingeJoint::iGetPrivDataIdx(), AirProperties::iGetPrivDataIdx(), Rod::iGetPrivDataIdx(), AngularVelocityJoint::iGetPrivDataIdx(), DistanceJointWithOffset::iGetPrivDataIdx(), TotalEquation::iGetPrivDataIdx(), TotalJoint::iGetPrivDataIdx(), HBeam::iGetPrivDataIdx(), LoadableElem::iGetPrivDataIdx(), DriveDisplacementPinJoint::iGetPrivDataIdx(), PlaneRotationJoint::iGetPrivDataIdx(), Wheel4::iGetPrivDataIdx(), Modal::iGetPrivDataIdx(), ClampJoint::iGetPrivDataIdx(), ScalarDifferentialNode::iGetPrivDataIdx(), TotalReaction::iGetPrivDataIdx(), TimeStep::iGetPrivDataIdx(), Beam::iGetPrivDataIdx(), TotalPinJoint::iGetPrivDataIdx(), ScalarAlgebraicNode::iGetPrivDataIdx(), AxialRotationJoint::iGetPrivDataIdx(), ShockAbsorberConstitutiveLaw< doublereal, doublereal >::iGetPrivDataIdx(), PlanePinJoint::iGetPrivDataIdx(), Beam::iGetPrivDataIdx_int(), FullSubMatrixHandler::iGetRowIndex(), SparseSubMatrixHandler::iGetRowIndex(), MySubVectorHandler::iGetRowIndex(), DriveHandler::iGetStep(), DataManager::iIDGetTotNumDofs(), FileName::iInit(), STLVectorHandler::IncCoef(), MyVectorHandler::IncCoef(), FullMatrixHandler::IncCoef(), SparseSubMatrixHandler::IncCoef(), IncludeParser::IncludeParser(), OutputHandler::Inertia(), RTAISolver::Init(), VecIter< Elem * >::Init(), UniformRotor::Init(), GlauertRotor::Init(), ManglerRotor::Init(), DynamicInflowRotor::Init(), PetersHeRotor::Init(), init_rows_cols(), init_scoring(), InitialAssemblyIterator::InitialAssemblyIterator(), ModuleTemplate::InitialAssJac(), ModuleMDS::InitialAssJac(), ModuleIMU::InitialAssJac(), DistanceJoint::InitialAssJac(), LoadIncNorm::InitialAssJac(), ModuleFMU::InitialAssJac(), CyclocopterInflow::InitialAssJac(), ModuleNonsmoothNode::InitialAssJac(), DistanceJointWithOffset::InitialAssJac(), AeroDynModule::InitialAssJac(), NestedElem::InitialAssJac(), LoadableElem::InitialAssJac(), Wheel4::InitialAssJac(), ModuleIMUConstraint::InitialAssJac(), TimeStep::InitialAssJac(), LoadIncForce::InitialAssJac(), ModuleTemplate::InitialAssRes(), ModuleMDS::InitialAssRes(), ModuleIMU::InitialAssRes(), DistanceJoint::InitialAssRes(), LoadIncNorm::InitialAssRes(), ModuleFMU::InitialAssRes(), CyclocopterInflow::InitialAssRes(), ModuleNonsmoothNode::InitialAssRes(), AeroDynModule::InitialAssRes(), DistanceJointWithOffset::InitialAssRes(), NestedElem::InitialAssRes(), LoadableElem::InitialAssRes(), Wheel4::InitialAssRes(), ModuleIMUConstraint::InitialAssRes(), TimeStep::InitialAssRes(), LoadIncForce::InitialAssRes(), DataManager::InitialJointAssembly(), NestedElem::InitialWorkSpaceDim(), LoadableElem::InitialWorkSpaceDim(), Rotor::InitParam(), InitSF(), InitUDE(), STLVectorHandler::InnerProd(), VectorHandler::InnerProd(), GPC_LAPACK_pinv::Inv(), Mat3x3::Inv(), is_abs_path(), Mat3x3::IsDiag(), OutputHandler::IsOpen(), IsotropicHardeningConstitutiveLaw< T, Tder >::IsotropicHardeningConstitutiveLaw(), Mat3x3::IsSymmetric(), ThirdOrderIntegrator::Jacobian(), DerivativeSolver::Jacobian(), StepNIntegrator::Jacobian(), InverseDynamicsStepSolver::Jacobian(), OutputHandler::Joints(), LabelSearch(), Mat3x3::LDLSolve(), LinearAccelerationJoint::LinearAccelerationJoint(), LineSearchSolver::LineSearch(), OutputHandler::Loadable(), LoadableElem::LoadableElem(), LoadIncForce::LoadIncForce(), LoadIncNorm::LoadIncNorm(), OutputHandler::Log(), LogarithmicWindProfile::LogarithmicWindProfile(), LogConstitutiveLaw< doublereal, doublereal >::LogConstitutiveLaw(), OutputHandler::LogOpen(), NonlinearSolverTest::MakeTest(), Mass::Mass(), Mat3x3::Mat3x3(), Mat3xN::Mat3xN(), Mat6x6::Mat6x6(), NaiveMatrixHandler::MatMatMul_base(), CompactSparseMatrixHandler_tpl< off >::MatMatMul_base(), NaivePermMatrixHandler::MatMatMul_base(), MatR2vec(), NaiveMatrixHandler::MatTMatMul_base(), CompactSparseMatrixHandler_tpl< off >::MatTMatMul_base(), NaivePermMatrixHandler::MatTMatMul_base(), NaiveMatrixHandler::MatTVecMul_base(), CompactSparseMatrixHandler_tpl< off >::MatTVecMul_base(), FullMatrixHandler::MatTVecMul_base(), NaivePermMatrixHandler::MatTVecMul_base(), NaiveMatrixHandler::MatVecMul_base(), CompactSparseMatrixHandler_tpl< off >::MatVecMul_base(), FullMatrixHandler::MatVecMul_base(), NaivePermMatrixHandler::MatVecMul_base(), mbdyn_make_salt(), mbdyn_parse_arguments(), mbdyn_program(), mbdyn_symamd(), mbedge_eat_field(), mbedge_eat_sep(), MinorLoss::MinorLoss(), Modal::Modal(), OutputHandler::Modal(), ModalExt::ModalExt(), ModalForce::ModalForce(), ModalMappingExt::ModalMappingExt(), model_curr(), model_elem(), model_node(), model_sf(), StreamContentCopyCast::Modify(), mp_acos_t(), mp_acosh_t(), mp_actg(), mp_actg2(), mp_asin_t(), mp_atanh_t(), mp_cast(), mp_ctg(), mp_ctg_t(), mp_ctgh(), mp_ctgh_t(), mp_func_1(), mp_func_2(), mp_greater_than_0_t(), mp_greater_than_or_equal_to_0_t(), mp_in(), mp_max(), mp_min(), mp_par(), mp_print(), mp_ramp(), mp_rand(), mp_rndm(), mp_sign(), mp_sprintf(), mp_sramp(), mp_srnd(), mp_step(), mp_stop(), mp_tan_t(), VecN::Mult(), Mat3xN::Mult(), MatNxN::Mult(), MultistepSolver::MultistepSolver(), MySubVectorHandler::MySubVectorHandler(), MyVectorHandler::MyVectorHandler(), NaiveMatrixHandler::NaiveMatrixHandler(), NaivePermMatrixHandler::NaivePermMatrixHandler(), NestedElem::NeedsAirProperties(), NestedElem::NestedElem(), DataManager::NodeOutputPrepare(), Beam::Omega0(), STLVectorHandler::operator()(), NaiveMatrixHandler::operator()(), VecN::operator()(), Vec6::operator()(), MyVectorHandler::operator()(), FullMatrixHandler::operator()(), NaivePermMatrixHandler::operator()(), Vec3::operator()(), Mat3xN::operator()(), MatNx3::operator()(), Mat6x6::operator()(), MatNxN::operator()(), Mat3x3::operator()(), SparseSubMatrixHandler::operator()(), Mat3xN::operator*(), STLVectorHandler::operator+=(), VectorHandler::operator+=(), MyVectorHandler::operator+=(), STLVectorHandler::operator-=(), VectorHandler::operator-=(), MyVectorHandler::operator-=(), Vec6::operator/(), VecExp::operator/(), MatExp::operator/(), Vec3::operator/(), Mat6x6::operator/(), Mat3x3::operator/(), Vec3::operator/=(), Mat6x6::operator/=(), Mat3x3::operator/=(), operator<<(), STLVectorHandler::operator=(), MyVectorHandler::operator=(), Vec3::operator[](), order_children(), Orifice::Orifice(), NestedElem::Output(), DrivenElem::Output(), RodBezier::Output(), Rod::Output(), Joint::Output(), OutputHandler::Output(), LoadableElem::Output(), AerodynamicBody::Output(), AerodynamicBeam::Output(), DriveCaller::Output(), AerodynamicBeam2::Output(), DataManager::OutputEigenvectors(), DataManager::OutputEigGeometry(), DataManager::OutputEigOpen(), NestedElem::OutputPrepare(), AbsoluteDispForce::OutputPrepare(), AbsoluteInternalDispForce::OutputPrepare(), AutomaticStructDispElem::OutputPrepare(), Aerodynamic2DElem< iNN >::OutputPrepare(), StructDispNode::OutputPrepare(), Beam2::OutputPrepare(), AbsoluteForce::OutputPrepare(), AutomaticStructElem::OutputPrepare(), Wheel4::OutputPrepare(), FollowerForce::OutputPrepare(), Beam::OutputPrepare(), AbsoluteCouple::OutputPrepare(), DataManager::OutputPrepare(), FollowerCouple::OutputPrepare(), AbsoluteInternalForce::OutputPrepare(), FollowerInternalForce::OutputPrepare(), AbsoluteInternalCouple::OutputPrepare(), FollowerInternalCouple::OutputPrepare(), StructNode::OutputPrepare(), Joint::OutputPrepare_int(), Inertia::OutputPrepare_int(), OutputHandler::Parameters(), OutputHandler::Partition(), OutputHandler::PartitionOpen(), DataManager::pChooseElem(), DriveArrayCaller::pCopy(), FullMatrixHandler::pdGetMat(), FullMatrixHandler::pdGetVec(), SolutionManager::pdSetResVec(), SolutionManager::pdSetSolVec(), DataManager::pFindDrive(), DataManager::pFindElem(), ConstitutiveLawOwner< T, Tder >::pGetConstLaw(), AeroDynModule::pGetCurrBladeNode(), DofOwnerOwner::pGetDofOwner(), NestedElem::pGetDofOwner(), SwitchDriveCaller::pGetDrive(), NestedElem::pGetInducedVelocity(), Mat6x6::pGetMat(), HBeam::pGetNode(), Membrane4EAS::pGetNode(), Beam2::pGetNode(), Shell4EAS::pGetNode(), Beam::pGetNode(), Shell4EASANS::pGetNode(), Solver::pGetStepIntegrator(), Vec6::pGetVec(), PiecewiseConstShape1D::PiecewiseConstShape1D(), PiecewiseLinearDriveCaller::PiecewiseLinearDriveCaller(), PiecewiseLinearShape1D::PiecewiseLinearShape1D(), PiezoActuatorBeam::PiezoActuatorBeam(), PiezoActuatorBeam2::PiezoActuatorBeam2(), PiezoActuatorVEBeam::PiezoActuatorVEBeam(), PiezoActuatorVEBeam2::PiezoActuatorVEBeam2(), Pipe::Pipe(), PivotRelFrameDummyStructNode::PivotRelFrameDummyStructNode(), pLabelSearch(), OutputHandler::Plates(), PointSurfaceContact::PointSurfaceContact(), NodeResForces::Pole(), position(), PowerLawWindProfile::PowerLawWindProfile(), DataManager::ppFindElem(), AeroMemory::Predict(), ThirdOrderIntegrator::Predict(), Step1Integrator::Predict(), Step2Integrator::Predict(), StreamContentMotion::Prepare(), InverseSolver::Prepare(), Solver::Prepare(), OutputHandler::PresNodes(), Pressure_flow_control_valve::Pressure_flow_control_valve(), Pressure_valve::Pressure_valve(), PrismaticJoint::PrismaticJoint(), PrivPlugIn::PrivPlugIn(), STLVectorHandler::Put(), VectorHandler::Put(), VecN::Put(), Vec6::Put(), MyVectorHandler::Put(), Mat3xN::Put(), Vec3::Put(), FullMatrixHandler::Put(), MatNx3::Put(), MatNxN::Put(), Mat6x6::Put(), Mat3x3::Put(), AirPropOwner::PutAirProperties(), NestedElem::PutAirProperties(), STLVectorHandler::PutCoef(), FullMatrixHandler::PutCoef(), MyVectorHandler::PutCoef(), SparseSubMatrixHandler::PutCoef(), FullSubMatrixHandler::PutColIndex(), SparseSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutCross(), SparseSubMatrixHandler::PutCross(), FullSubMatrixHandler::PutDiag(), SparseSubMatrixHandler::PutDiag(), GravityOwner::PutGravity(), SparseSubMatrixHandler::PutItem(), MySubVectorHandler::PutItem(), Mat6x6::PutMat(), Mat3xN::PutMat3x3(), SparseSubMatrixHandler::PutMat3x3(), DAC_Process_Debug::PutOutput(), FullSubMatrixHandler::PutRowIndex(), SparseSubMatrixHandler::PutRowIndex(), MySubVectorHandler::PutRowIndex(), FullMatrixHandler::PutT(), Vec6::PutTo(), Vec3::PutTo(), Mat3x3::PutTo(), Mat3xN::PutVec(), MatNx3::PutVec(), Mat3x3::PutVec(), DofPlugIn::Read(), IncludeDR::Read(), RefFrameDR::Read(), ChDirDR::Read(), HFluidDR::Read(), C81DataDR::Read(), ConstLawDR::Read(), MinMaxDriveDCR::Read(), DriveCallerDR::Read(), TplDriveCallerDR::Read(), SFuncDR::Read(), ModuleLoadDR::Read(), SymbolicCLR< T, Tder >::Read(), ReadAerodynamicBeam(), ReadAirstreamData(), ReadBufferStreamDrive(), ReadBufferStreamElem(), DataManager::ReadControl(), InverseSolver::ReadData(), Solver::ReadData(), ReadElectric(), DataManager::ReadElem(), DataManager::ReadElems(), ReadFF(), ReadGenel(), ReadHydraulicElem(), ReadInducedVelocity(), ReadLoadable(), ReadMembraneConstLaw(), ReadModal(), ReadModalExtForce(), ReadModalMappingExtForce(), DataManager::ReadNode(), DataManager::ReadNodes(), ReadOneBufCast(), ReadPX(), ReadRotor(), ReadShape(), ReadShellConstLaw(), ReadStructMappingExtForce(), ReadStructNode(), ReadTimeStepData(), ExtRigidForceEDGE::Recv(), ExtModalForceEDGE::Recv(), StructExtForce::RecvFromFileDes(), StructExtEDGEForce::RecvFromStream(), StructExtForce::RecvFromStream(), ReferenceFrame::ReferenceFrame(), OutputHandler::ReferenceFrames(), Converged::Register(), MathParser::RegisterNameSpace(), RelFrameDummyStructNode::RelFrameDummyStructNode(), MyVectorHandler::Reset(), SparseSubMatrixHandler::Reset(), AerodynamicOutput::ResetIterator(), ResForceSet::ResForceSet(), ThirdOrderIntegrator::Residual(), DerivativeSolver::Residual(), StepNIntegrator::Residual(), InverseDynamicsStepSolver::Residual(), STLVectorHandler::Resize(), VecN::Resize(), Mat3xN::Resize(), FullSubMatrixHandler::Resize(), MatNx3::Resize(), SparseSubMatrixHandler::Resize(), MySubVectorHandler::Resize(), DrivenElem::Restart(), InverseSolver::Restart(), OutputHandler::Restart(), LoadableElem::Restart(), Solver::Restart(), DriveArrayCaller::Restart(), OutputHandler::RestartOpen(), OutputHandler::RestartXSol(), Rod::Rod(), RodBezier::RodBezier(), RodWithOffset::RodWithOffset(), RotAccel::RotAccel(), OutputHandler::Rotors(), RotorTrim::RotorTrim(), RotorTrimBase::RotorTrimBase(), RTAISolver::RTAISolver(), RTMBDynInDrive::RTMBDynInDrive(), RTMBDynOutElem::RTMBDynOutElem(), RTSolverBase::RTSolverBase(), RunMBDyn(), SampleAndHold::SampleAndHold(), STLVectorHandler::ScalarAddMul(), VectorHandler::ScalarAddMul(), MyVectorHandler::ScalarAddMul(), ScalarFunctionOrthotropicCL< T, Tder >::ScalarFunctionOrthotropicCL(), ScalarFuncWindProfile::ScalarFuncWindProfile(), STLVectorHandler::ScalarMul(), VectorHandler::ScalarMul(), MyVectorHandler::ScalarMul(), ScalarPX::ScalarPX(), NaiveSparseSolutionManager::ScaleSolution(), MatrixScaleBase::ScaleVector(), ExtRigidForceEDGE::Send(), ExtModalForceEDGE::Send(), VariableStepFileDrive::ServePending(), TplDriveOwner< Vec6 >::Set(), DriveOwner::Set(), StreamContentCopyCast::Set(), Gust::SetAirProperties(), HopeSolver::SetCoef(), AeroDynModule::SetCurrBladeNodePITNOW(), AerodynamicOutput::SetData(), MBDynParser::SetDataManager(), StructDispNode::SetDofValue(), ScalarDifferentialNode::SetDofValue(), ScalarAlgebraicNode::SetDofValue(), DynamicStructDispNode::SetDofValue(), Node2Scalar::SetDofValue(), StructNode::SetDofValue(), DynamicStructNode::SetDofValue(), NestedElem::SetInitialValue(), LoadableElem::SetInitialValue(), NestedElem::SetOutputFlag(), ToBeOutput::SetOutputFlag(), OutputHandler::SetPrecision(), C81MultipleAeroData::SetSectionData(), C81InterpolatedAeroData::SetSectionData(), DriveHandler::SetTime(), Traceable::SetTraceFlag(), RTAISolver::Setup(), NestedElem::SetValue(), DrivenElem::SetValue(), LoadableElem::SetValue(), ViscoElasticBeam2::SetValue(), ViscoElasticBeam::SetValue(), DriveHandler::SetVar(), OutputHandler::SetWidth(), ShapeFunc2N(), ShapeFunc3N(), ShapeOwner::ShapeOwner(), BiCGStab::Solve(), Gmres::Solve(), NewtonRaphsonSolver::Solve(), LineSearchSolver::Solve(), NaiveSparsePermSolutionManager< T >::Solve(), Mat3x3::Solve(), Solver::Solver(), SparseSubMatrixHandler::SparseSubMatrixHandler(), STAHRAeroData::STAHRAeroData(), Solver::Start(), StdAirProperties::StdAirProperties(), STLVectorHandler::STLVectorHandler(), StreamContentCopyCast::StreamContentCopyCast(), StreamContentMotion::StreamContentMotion(), StreamContentValue::StreamContentValue(), StreamDrive::StreamDrive(), StreamDriveCopyCast::StreamDriveCopyCast(), StreamOutElem::StreamOutElem(), StringDriveCaller::StringDriveCaller(), OutputHandler::StrNodes(), StructExtEDGEForce::StructExtEDGEForce(), StructExtForce::StructExtForce(), StructMappingExtForce::StructMappingExtForce(), StructuralForce::StructuralForce(), StructuralInternalForce::StructuralInternalForce(), STLVectorHandler::Sub(), VectorHandler::Sub(), VecN::Sub(), MyVectorHandler::Sub(), Mat3xN::Sub(), FullMatrixHandler::Sub(), MatNx3::Sub(), MatNxN::Sub(), Vec3::SubFrom(), FullSubMatrixHandler::SubFrom(), SparseSubMatrixHandler::SubFrom(), FullSubMatrixHandler::SubFromT(), SparseSubMatrixHandler::SubFromT(), Mat6x6::SubMat(), Mat3xN::SubMat3x3(), FullMatrixHandler::SubT(), Mat3xN::SubVec(), MatNx3::SubVec(), Mat3x3::SubVec(), SwashPlate::SwashPlate(), Tank::Tank(), NonlinearSolverTestMinMax::TestMerge(), ImplicitStepIntegrator::TestScale(), InverseDynamicsStepSolver::TestScale(), TheodorsenAeroData::TheodorsenAeroData(), OutputHandler::ThermalElements(), OutputHandler::ThermalNodes(), ThreeWayMinorLoss::ThreeWayMinorLoss(), TotalEquation::TotalEquation(), TotalJoint::TotalJoint(), TotalPinJoint::TotalPinJoint(), DriveCaller::Trace(), OutputHandler::Traces(), TranslAccel::TranslAccel(), TypedValue::TypedValue(), unit_convert(), unitvec(), AeroMemory::Update(), ThirdOrderIntegrator::Update(), DrivenElem::Update(), NestedElem::Update(), DerivativeSolver::Update(), StepNIntegrator::Update(), StructDispNode::Update(), LoadableElem::Update(), ConstitutiveLawOwner< T, Tder >::Update(), ClampJoint::Update(), TotalPinJoint::Update(), DataManager::Update(), DynamicStructDispNode::Update(), InverseDynamicsStepSolver::Update(), LogConstitutiveLaw< doublereal, doublereal >::Update(), StructNode::Update(), DynamicStructNode::Update(), OutputHandler::UseDefaultPrecision(), OutputHandler::UseNetCDF(), OutputHandler::UseScientific(), OutputHandler::UseText(), VariableBody::VariableBody(), VariableStepFileDrive::VariableStepFileDrive(), Vec3::Vec3(), VecIter< Elem * >::VecIter(), VecN::VecN(), VectorPX::VectorPX(), velocity(), ViscousBody::ViscousBody(), vrel(), NestedElem::WorkSpaceDim(), ModuleNonsmoothNode::WorkSpaceDim(), LoadableElem::WorkSpaceDim(), Beam::~Beam(), Beam2::~Beam2(), ConstitutiveLawOwner< T, Tder >::~ConstitutiveLawOwner(), DriveArrayCaller::~DriveArrayCaller(), DrivenElem::~DrivenElem(), HBeam::~HBeam(), HighParser::~HighParser(), LoadableElem::~LoadableElem(), Membrane4EAS::~Membrane4EAS(), NamedValue::~NamedValue(), NestedElem::~NestedElem(), PiezoActuatorBeam2::~PiezoActuatorBeam2(), PiezoActuatorVEBeam2::~PiezoActuatorVEBeam2(), ShapeOwner::~ShapeOwner(), Shell4EAS::~Shell4EAS(), and Shell4EASANS::~Shell4EASANS().

#define COL_IS_ALIVE

(

c

)

(Col [c].start >= ALIVE)

Definition at line 783 of file colamd.c.

Referenced by detect_super_cols(), find_ordering(), garbage_collection(), and init_scoring().

#define COL_IS_DEAD

(

c

)

(Col [c].start < ALIVE)

Definition at line 782 of file colamd.c.

Referenced by detect_super_cols(), find_ordering(), init_scoring(), and order_children().

#define COL_IS_DEAD_PRINCIPAL

(

c

)

(Col [c].start == DEAD_PRINCIPAL)

Definition at line 784 of file colamd.c.

Referenced by order_children().

#define DEAD   (-1)

Definition at line 772 of file colamd.c.

#define DEAD_NON_PRINCIPAL   (-2)

Definition at line 776 of file colamd.c.

#define DEAD_PRINCIPAL   (-1)

Definition at line 775 of file colamd.c.

#define DEBUG0

(

params

)

;

Definition at line 971 of file colamd.c.

Referenced by init_rows_cols(), mbdyn_colamd(), and mbdyn_symamd().

#define DEBUG1

(

params

)

;

Definition at line 972 of file colamd.c.

Referenced by find_ordering(), init_rows_cols(), init_scoring(), and mbdyn_symamd().

#define DEBUG2

(

params

)

;

Definition at line 973 of file colamd.c.

Referenced by find_ordering(), garbage_collection(), and init_scoring().

#define DEBUG3

(

params

)

;

Definition at line 974 of file colamd.c.

Referenced by find_ordering(), and garbage_collection().

#define DEBUG4

(

params

)

;

Definition at line 975 of file colamd.c.

Referenced by find_ordering(), and init_scoring().

#define EMPTY   (-1)

Definition at line 768 of file colamd.c.

Referenced by detect_super_cols(), find_ordering(), init_rows_cols(), init_scoring(), order_children(), InverseSolver::Prepare(), Solver::Prepare(), and ReadLinSol().

#define FALSE   (0)

Definition at line 763 of file colamd.c.

Referenced by init_rows_cols(), mbdyn_colamd(), and mbdyn_symamd().

#define INDEX

(

i

)

(i)

Definition at line 809 of file colamd.c.

Referenced by print_report().

#define KILL_NON_PRINCIPAL_COL

(

c

)

{ Col [c].start = DEAD_NON_PRINCIPAL ; }

Definition at line 787 of file colamd.c.

Referenced by detect_super_cols().

#define KILL_PRINCIPAL_COL

(

c

)

{ Col [c].start = DEAD_PRINCIPAL ; }

Definition at line 786 of file colamd.c.

Referenced by find_ordering(), and init_scoring().

#define KILL_ROW

(

r

)

{ Row [r].shared2.mark = DEAD ; }

Definition at line 785 of file colamd.c.

Referenced by find_ordering(), garbage_collection(), and init_scoring().

#define MAX	(		a,
			b
	)		(((a) > (b)) ? (a) : (b))

Definition at line 749 of file colamd.c.

Referenced by find_ordering(), and init_scoring().

#define MIN	(		a,
			b
	)		(((a) < (b)) ? (a) : (b))

Definition at line 750 of file colamd.c.

Referenced by find_ordering(), and init_scoring().

#define NDEBUG

Definition at line 692 of file colamd.c.

Referenced by find_ordering().

#define ONES_COMPLEMENT

(

r

)

(-(r)-1)

Definition at line 752 of file colamd.c.

Referenced by garbage_collection().

#define PRINTF   printf

Definition at line 806 of file colamd.c.

Referenced by print_report().

#define PRIVATE   static

Definition at line 747 of file colamd.c.

#define PUBLIC

Definition at line 746 of file colamd.c.

#define ROW_IS_ALIVE

(

r

)

(Row [r].shared2.mark >= ALIVE)

Definition at line 781 of file colamd.c.

Referenced by clear_mark(), detect_super_cols(), find_ordering(), and garbage_collection().

#define ROW_IS_DEAD

(

r

)

ROW_IS_MARKED_DEAD (Row[r].shared2.mark)

Definition at line 779 of file colamd.c.

Referenced by find_ordering(), and init_scoring().

#define ROW_IS_MARKED_DEAD

(

row_mark

)

(row_mark < ALIVE)

Definition at line 780 of file colamd.c.

Referenced by find_ordering().

#define TRUE   (1)

Definition at line 759 of file colamd.c.

Referenced by init_rows_cols(), mbdyn_colamd(), and mbdyn_symamd().

Typedef Documentation

typedef double doublereal

Definition at line 52 of file colamd.c.

typedef long int integer

Definition at line 51 of file colamd.c.

Function Documentation

static integer clear_mark ( integer  n_row, mbdyn_Colamd_Row  Row[]  )

static

Definition at line 3064 of file colamd.c.

References ROW_IS_ALIVE.

Referenced by find_ordering().

{
    /* === Local variables ================================================== */

    integer r ;

    for (r = 0 ; r < n_row ; r++)
    {
        if (ROW_IS_ALIVE (r))
        {
            Row [r].shared2.mark = 0 ;
        }
    }
    return (1) ;
}

static void detect_super_cols ( mbdyn_Colamd_Col  Col[], integer  A[], integer  head[], integer  row_start, integer  row_length  )

static

Definition at line 2771 of file colamd.c.

References ASSERT, c, COL_IS_ALIVE, COL_IS_DEAD, EMPTY, KILL_NON_PRINCIPAL_COL, and ROW_IS_ALIVE.

Referenced by find_ordering().

{
    /* === Local variables ================================================== */

    integer hash ;                      /* hash value for a column */
    integer *rp ;                       /* pointer to a row */
    integer c ;                 /* a column index */
    integer super_c ;           /* column index of the column to absorb into */
    integer *cp1 ;                      /* column pointer for column super_c */
    integer *cp2 ;                      /* column pointer for column c */
    integer length ;            /* length of column super_c */
    integer prev_c ;            /* column preceding c in hash bucket */
    integer i ;                 /* loop counter */
    integer *rp_end ;           /* pointer to the end of the row */
    integer col ;                       /* a column index in the row to check */
    integer head_column ;               /* first column in hash bucket or degree list */
    integer first_col ;         /* first column in hash bucket */

    /* === Consider each column in the row ================================== */

    rp = &A [row_start] ;
    rp_end = rp + row_length ;
    while (rp < rp_end)
    {
        col = *rp++ ;
        if (COL_IS_DEAD (col))
        {
            continue ;
        }

        /* get hash number for this column */
        hash = Col [col].shared3.hash ;
        ASSERT (hash <= n_col) ;

        /* === Get the first column in this hash bucket ===================== */

        head_column = head [hash] ;
        if (head_column > EMPTY)
        {
            first_col = Col [head_column].shared3.headhash ;
        }
        else
        {
            first_col = - (head_column + 2) ;
        }

        /* === Consider each column in the hash bucket ====================== */

        for (super_c = first_col ; super_c != EMPTY ;
            super_c = Col [super_c].shared4.hash_next)
        {
            ASSERT (COL_IS_ALIVE (super_c)) ;
            ASSERT (Col [super_c].shared3.hash == hash) ;
            length = Col [super_c].length ;

            /* prev_c is the column preceding column c in the hash bucket */
            prev_c = super_c ;

            /* === Compare super_c with all columns after it ================ */

            for (c = Col [super_c].shared4.hash_next ;
                 c != EMPTY ; c = Col [c].shared4.hash_next)
            {
                ASSERT (c != super_c) ;
                ASSERT (COL_IS_ALIVE (c)) ;
                ASSERT (Col [c].shared3.hash == hash) ;

                /* not identical if lengths or scores are different */
                if (Col [c].length != length ||
                    Col [c].shared2.score != Col [super_c].shared2.score)
                {
                    prev_c = c ;
                    continue ;
                }

                /* compare the two columns */
                cp1 = &A [Col [super_c].start] ;
                cp2 = &A [Col [c].start] ;

                for (i = 0 ; i < length ; i++)
                {
                    /* the columns are "clean" (no dead rows) */
                    ASSERT (ROW_IS_ALIVE (*cp1))  ;
                    ASSERT (ROW_IS_ALIVE (*cp2))  ;
                    /* row indices will same order for both supercols, */
                    /* no gather scatter nessasary */
                    if (*cp1++ != *cp2++)
                    {
                        break ;
                    }
                }

                /* the two columns are different if the for-loop "broke" */
                if (i != length)
                {
                    prev_c = c ;
                    continue ;
                }

                /* === Got it!  two columns are identical =================== */

                ASSERT (Col [c].shared2.score == Col [super_c].shared2.score) ;

                Col [super_c].shared1.thickness += Col [c].shared1.thickness ;
                Col [c].shared1.parent = super_c ;
                KILL_NON_PRINCIPAL_COL (c) ;
                /* order c later, in order_children() */
                Col [c].shared2.order = EMPTY ;
                /* remove c from hash bucket */
                Col [prev_c].shared4.hash_next = Col [c].shared4.hash_next ;
            }
        }

        /* === Empty this hash bucket ======================================= */

        if (head_column > EMPTY)
        {
            /* corresponding degree list "hash" is not empty */
            Col [head_column].shared3.headhash = EMPTY ;
        }
        else
        {
            /* corresponding degree list "hash" is empty */
            head [hash] = EMPTY ;
        }
    }
}

static integer find_ordering ( integer  n_row, integer  n_col, integer  Alen, mbdyn_Colamd_Row  Row[], mbdyn_Colamd_Col  Col[], integer  A[], integer  head[], integer  n_col2, integer  max_deg, integer  pfree  )

static

Definition at line 2106 of file colamd.c.

References ASSERT, clear_mark(), COL_IS_ALIVE, COL_IS_DEAD, DEBUG1, DEBUG2, DEBUG3, DEBUG4, detect_super_cols(), EMPTY, garbage_collection(), KILL_PRINCIPAL_COL, KILL_ROW, MAX, MIN, NDEBUG, ROW_IS_ALIVE, ROW_IS_DEAD, and ROW_IS_MARKED_DEAD.

Referenced by mbdyn_colamd().

{
    /* === Local variables ================================================== */

    integer k ;                 /* current pivot ordering step */
    integer pivot_col ;         /* current pivot column */
    integer *cp ;                       /* a column pointer */
    integer *rp ;                       /* a row pointer */
    integer pivot_row ;         /* current pivot row */
    integer *new_cp ;           /* modified column pointer */
    integer *new_rp ;           /* modified row pointer */
    integer pivot_row_start ;   /* pointer to start of pivot row */
    integer pivot_row_degree ;  /* number of columns in pivot row */
    integer pivot_row_length ;  /* number of supercolumns in pivot row */
    integer pivot_col_score ;   /* score of pivot column */
    integer needed_memory ;             /* free space needed for pivot row */
    integer *cp_end ;           /* pointer to the end of a column */
    integer *rp_end ;           /* pointer to the end of a row */
    integer row ;                       /* a row index */
    integer col ;                       /* a column index */
    integer max_score ;         /* maximum possible score */
    integer cur_score ;         /* score of current column */
    unsigned int hash ;         /* hash value for supernode detection */
    integer head_column ;               /* head of hash bucket */
    integer first_col ;         /* first column in hash bucket */
    integer tag_mark ;          /* marker value for mark array */
    integer row_mark ;          /* Row [row].shared2.mark */
    integer set_difference ;    /* set difference size of row with pivot row */
    integer min_score ;         /* smallest column score */
    integer col_thickness ;             /* "thickness" (no. of columns in a supercol) */
    integer max_mark ;          /* maximum value of tag_mark */
    integer pivot_col_thickness ;       /* number of columns represented by pivot col */
    integer prev_col ;          /* Used by Dlist operations. */
    integer next_col ;          /* Used by Dlist operations. */
    integer ngarbage ;          /* number of garbage collections performed */

#ifndef NDEBUG
    integer debug_d ;           /* debug loop counter */
    integer debug_step = 0 ;    /* debug loop counter */
#endif /* NDEBUG */

    /* === Initialization and clear mark ==================================== */

    max_mark = INT_MAX - n_col ;        /* INT_MAX defined in <limits.h> */
    tag_mark = clear_mark (n_row, Row) ;
    min_score = 0 ;
    ngarbage = 0 ;
    DEBUG1 (("colamd: Ordering, n_col2=%d\n", n_col2)) ;

    /* === Order the columns ================================================ */

    for (k = 0 ; k < n_col2 ; /* 'k' is incremented below */)
    {

#ifndef NDEBUG
        if (debug_step % 100 == 0)
        {
            DEBUG2 (("\n...       Step k: %d out of n_col2: %d\n", k, n_col2)) ;
        }
        else
        {
            DEBUG3 (("\n----------Step k: %d out of n_col2: %d\n", k, n_col2)) ;
        }
        debug_step++ ;
        debug_deg_lists (n_row, n_col, Row, Col, head,
                min_score, n_col2-k, max_deg) ;
        debug_matrix (n_row, n_col, Row, Col, A) ;
#endif /* NDEBUG */

        /* === Select pivot column, and order it ============================ */

        /* make sure degree list isn't empty */
        ASSERT (min_score >= 0) ;
        ASSERT (min_score <= n_col) ;
        ASSERT (head [min_score] >= EMPTY) ;

#ifndef NDEBUG
        for (debug_d = 0 ; debug_d < min_score ; debug_d++)
        {
            ASSERT (head [debug_d] == EMPTY) ;
        }
#endif /* NDEBUG */

        /* get pivot column from head of minimum degree list */
        while (head [min_score] == EMPTY && min_score < n_col)
        {
            min_score++ ;
        }
        pivot_col = head [min_score] ;
        ASSERT (pivot_col >= 0 && pivot_col <= n_col) ;
        next_col = Col [pivot_col].shared4.degree_next ;
        head [min_score] = next_col ;
        if (next_col != EMPTY)
        {
            Col [next_col].shared3.prev = EMPTY ;
        }

        ASSERT (COL_IS_ALIVE (pivot_col)) ;
        DEBUG3 (("Pivot col: %d\n", pivot_col)) ;

        /* remember score for defrag check */
        pivot_col_score = Col [pivot_col].shared2.score ;

        /* the pivot column is the kth column in the pivot order */
        Col [pivot_col].shared2.order = k ;

        /* increment order count by column thickness */
        pivot_col_thickness = Col [pivot_col].shared1.thickness ;
        k += pivot_col_thickness ;
        ASSERT (pivot_col_thickness > 0) ;

        /* === Garbage_collection, if necessary ============================= */

        needed_memory = MIN (pivot_col_score, n_col - k) ;
        if (pfree + needed_memory >= Alen)
        {
            pfree = garbage_collection (n_row, n_col, Row, Col, A, &A [pfree]) ;
            ngarbage++ ;
            /* after garbage collection we will have enough */
            ASSERT (pfree + needed_memory < Alen) ;
            /* garbage collection has wiped out the Row[].shared2.mark array */
            tag_mark = clear_mark (n_row, Row) ;

#ifndef NDEBUG
            debug_matrix (n_row, n_col, Row, Col, A) ;
#endif /* NDEBUG */
        }

        /* === Compute pivot row pattern ==================================== */

        /* get starting location for this new merged row */
        pivot_row_start = pfree ;

        /* initialize new row counts to zero */
        pivot_row_degree = 0 ;

        /* tag pivot column as having been visited so it isn't included */
        /* in merged pivot row */
        Col [pivot_col].shared1.thickness = -pivot_col_thickness ;

        /* pivot row is the union of all rows in the pivot column pattern */
        cp = &A [Col [pivot_col].start] ;
        cp_end = cp + Col [pivot_col].length ;
        while (cp < cp_end)
        {
            /* get a row */
            row = *cp++ ;
            DEBUG4 (("Pivot col pattern %d %d\n", ROW_IS_ALIVE (row), row)) ;
            /* skip if row is dead */
            if (ROW_IS_DEAD (row))
            {
                continue ;
            }
            rp = &A [Row [row].start] ;
            rp_end = rp + Row [row].length ;
            while (rp < rp_end)
            {
                /* get a column */
                col = *rp++ ;
                /* add the column, if alive and untagged */
                col_thickness = Col [col].shared1.thickness ;
                if (col_thickness > 0 && COL_IS_ALIVE (col))
                {
                    /* tag column in pivot row */
                    Col [col].shared1.thickness = -col_thickness ;
                    ASSERT (pfree < Alen) ;
                    /* place column in pivot row */
                    A [pfree++] = col ;
                    pivot_row_degree += col_thickness ;
                }
            }
        }

        /* clear tag on pivot column */
        Col [pivot_col].shared1.thickness = pivot_col_thickness ;
        max_deg = MAX (max_deg, pivot_row_degree) ;

#ifndef NDEBUG
        DEBUG3 (("check2\n")) ;
        debug_mark (n_row, Row, tag_mark, max_mark) ;
#endif /* NDEBUG */

        /* === Kill all rows used to construct pivot row ==================== */

        /* also kill pivot row, temporarily */
        cp = &A [Col [pivot_col].start] ;
        cp_end = cp + Col [pivot_col].length ;
        while (cp < cp_end)
        {
            /* may be killing an already dead row */
            row = *cp++ ;
            DEBUG3 (("Kill row in pivot col: %d\n", row)) ;
            KILL_ROW (row) ;
        }

        /* === Select a row index to use as the new pivot row =============== */

        pivot_row_length = pfree - pivot_row_start ;
        if (pivot_row_length > 0)
        {
            /* pick the "pivot" row arbitrarily (first row in col) */
            pivot_row = A [Col [pivot_col].start] ;
            DEBUG3 (("Pivotal row is %d\n", pivot_row)) ;
        }
        else
        {
            /* there is no pivot row, since it is of zero length */
            pivot_row = EMPTY ;
            ASSERT (pivot_row_length == 0) ;
        }
        ASSERT (Col [pivot_col].length > 0 || pivot_row_length == 0) ;

        /* === Approximate degree computation =============================== */

        /* Here begins the computation of the approximate degree.  The column */
        /* score is the sum of the pivot row "length", plus the size of the */
        /* set differences of each row in the column minus the pattern of the */
        /* pivot row itself.  The column ("thickness") itself is also */
        /* excluded from the column score (we thus use an approximate */
        /* external degree). */

        /* The time taken by the following code (compute set differences, and */
        /* add them up) is proportional to the size of the data structure */
        /* being scanned - that is, the sum of the sizes of each column in */
        /* the pivot row.  Thus, the amortized time to compute a column score */
        /* is proportional to the size of that column (where size, in this */
        /* context, is the column "length", or the number of row indices */
        /* in that column).  The number of row indices in a column is */
        /* monotonically non-decreasing, from the length of the original */
        /* column on input to colamd. */

        /* === Compute set differences ====================================== */

        DEBUG3 (("** Computing set differences phase. **\n")) ;

        /* pivot row is currently dead - it will be revived later. */

        DEBUG3 (("Pivot row: ")) ;
        /* for each column in pivot row */
        rp = &A [pivot_row_start] ;
        rp_end = rp + pivot_row_length ;
        while (rp < rp_end)
        {
            col = *rp++ ;
            ASSERT (COL_IS_ALIVE (col) && col != pivot_col) ;
            DEBUG3 (("Col: %d\n", col)) ;

            /* clear tags used to construct pivot row pattern */
            col_thickness = -Col [col].shared1.thickness ;
            ASSERT (col_thickness > 0) ;
            Col [col].shared1.thickness = col_thickness ;

            /* === Remove column from degree list =========================== */

            cur_score = Col [col].shared2.score ;
            prev_col = Col [col].shared3.prev ;
            next_col = Col [col].shared4.degree_next ;
            ASSERT (cur_score >= 0) ;
            ASSERT (cur_score <= n_col) ;
            ASSERT (cur_score >= EMPTY) ;
            if (prev_col == EMPTY)
            {
                head [cur_score] = next_col ;
            }
            else
            {
                Col [prev_col].shared4.degree_next = next_col ;
            }
            if (next_col != EMPTY)
            {
                Col [next_col].shared3.prev = prev_col ;
            }

            /* === Scan the column ========================================== */

            cp = &A [Col [col].start] ;
            cp_end = cp + Col [col].length ;
            while (cp < cp_end)
            {
                /* get a row */
                row = *cp++ ;
                row_mark = Row [row].shared2.mark ;
                /* skip if dead */
                if (ROW_IS_MARKED_DEAD (row_mark))
                {
                    continue ;
                }
                ASSERT (row != pivot_row) ;
                set_difference = row_mark - tag_mark ;
                /* check if the row has been seen yet */
                if (set_difference < 0)
                {
                    ASSERT (Row [row].shared1.degree <= max_deg) ;
                    set_difference = Row [row].shared1.degree ;
                }
                /* subtract column thickness from this row's set difference */
                set_difference -= col_thickness ;
                ASSERT (set_difference >= 0) ;
                /* absorb this row if the set difference becomes zero */
                if (set_difference == 0)
                {
                    DEBUG3 (("aggressive absorption. Row: %d\n", row)) ;
                    KILL_ROW (row) ;
                }
                else
                {
                    /* save the new mark */
                    Row [row].shared2.mark = set_difference + tag_mark ;
                }
            }
        }

#ifndef NDEBUG
        debug_deg_lists (n_row, n_col, Row, Col, head,
                min_score, n_col2-k-pivot_row_degree, max_deg) ;
#endif /* NDEBUG */

        /* === Add up set differences for each column ======================= */

        DEBUG3 (("** Adding set differences phase. **\n")) ;

        /* for each column in pivot row */
        rp = &A [pivot_row_start] ;
        rp_end = rp + pivot_row_length ;
        while (rp < rp_end)
        {
            /* get a column */
            col = *rp++ ;
            ASSERT (COL_IS_ALIVE (col) && col != pivot_col) ;
            hash = 0 ;
            cur_score = 0 ;
            cp = &A [Col [col].start] ;
            /* compact the column */
            new_cp = cp ;
            cp_end = cp + Col [col].length ;

            DEBUG4 (("Adding set diffs for Col: %d.\n", col)) ;

            while (cp < cp_end)
            {
                /* get a row */
                row = *cp++ ;
                ASSERT(row >= 0 && row < n_row) ;
                row_mark = Row [row].shared2.mark ;
                /* skip if dead */
                if (ROW_IS_MARKED_DEAD (row_mark))
                {
                    continue ;
                }
                ASSERT (row_mark > tag_mark) ;
                /* compact the column */
                *new_cp++ = row ;
                /* compute hash function */
                hash += row ;
                /* add set difference */
                cur_score += row_mark - tag_mark ;
                /* integer overflow... */
                cur_score = MIN (cur_score, n_col) ;
            }

            /* recompute the column's length */
            Col [col].length = (int) (new_cp - &A [Col [col].start]) ;

            /* === Further mass elimination ================================= */

            if (Col [col].length == 0)
            {
                DEBUG4 (("further mass elimination. Col: %d\n", col)) ;
                /* nothing left but the pivot row in this column */
                KILL_PRINCIPAL_COL (col) ;
                pivot_row_degree -= Col [col].shared1.thickness ;
                ASSERT (pivot_row_degree >= 0) ;
                /* order it */
                Col [col].shared2.order = k ;
                /* increment order count by column thickness */
                k += Col [col].shared1.thickness ;
            }
            else
            {
                /* === Prepare for supercolumn detection ==================== */

                DEBUG4 (("Preparing supercol detection for Col: %d.\n", col)) ;

                /* save score so far */
                Col [col].shared2.score = cur_score ;

                /* add column to hash table, for supercolumn detection */
                hash %= n_col + 1 ;

                DEBUG4 ((" Hash = %d, n_col = %d.\n", hash, n_col)) ;
                ASSERT (hash <= n_col) ;

                head_column = head [hash] ;
                if (head_column > EMPTY)
                {
                    /* degree list "hash" is non-empty, use prev (shared3) of */
                    /* first column in degree list as head of hash bucket */
                    first_col = Col [head_column].shared3.headhash ;
                    Col [head_column].shared3.headhash = col ;
                }
                else
                {
                    /* degree list "hash" is empty, use head as hash bucket */
                    first_col = - (head_column + 2) ;
                    head [hash] = - (col + 2) ;
                }
                Col [col].shared4.hash_next = first_col ;

                /* save hash function in Col [col].shared3.hash */
                Col [col].shared3.hash = (int) hash ;
                ASSERT (COL_IS_ALIVE (col)) ;
            }
        }

        /* The approximate external column degree is now computed.  */

        /* === Supercolumn detection ======================================== */

        DEBUG3 (("** Supercolumn detection phase. **\n")) ;

        detect_super_cols (

#ifndef NDEBUG
                n_col, Row,
#endif /* NDEBUG */

                Col, A, head, pivot_row_start, pivot_row_length) ;

        /* === Kill the pivotal column ====================================== */

        KILL_PRINCIPAL_COL (pivot_col) ;

        /* === Clear mark =================================================== */

        tag_mark += (max_deg + 1) ;
        if (tag_mark >= max_mark)
        {
            DEBUG2 (("clearing tag_mark\n")) ;
            tag_mark = clear_mark (n_row, Row) ;
        }

#ifndef NDEBUG
        DEBUG3 (("check3\n")) ;
        debug_mark (n_row, Row, tag_mark, max_mark) ;
#endif /* NDEBUG */

        /* === Finalize the new pivot row, and column scores ================ */

        DEBUG3 (("** Finalize scores phase. **\n")) ;

        /* for each column in pivot row */
        rp = &A [pivot_row_start] ;
        /* compact the pivot row */
        new_rp = rp ;
        rp_end = rp + pivot_row_length ;
        while (rp < rp_end)
        {
            col = *rp++ ;
            /* skip dead columns */
            if (COL_IS_DEAD (col))
            {
                continue ;
            }
            *new_rp++ = col ;
            /* add new pivot row to column */
            A [Col [col].start + (Col [col].length++)] = pivot_row ;

            /* retrieve score so far and add on pivot row's degree. */
            /* (we wait until here for this in case the pivot */
            /* row's degree was reduced due to mass elimination). */
            cur_score = Col [col].shared2.score + pivot_row_degree ;

            /* calculate the max possible score as the number of */
            /* external columns minus the 'k' value minus the */
            /* columns thickness */
            max_score = n_col - k - Col [col].shared1.thickness ;

            /* make the score the external degree of the union-of-rows */
            cur_score -= Col [col].shared1.thickness ;

            /* make sure score is less or equal than the max score */
            cur_score = MIN (cur_score, max_score) ;
            ASSERT (cur_score >= 0) ;

            /* store updated score */
            Col [col].shared2.score = cur_score ;

            /* === Place column back in degree list ========================= */

            ASSERT (min_score >= 0) ;
            ASSERT (min_score <= n_col) ;
            ASSERT (cur_score >= 0) ;
            ASSERT (cur_score <= n_col) ;
            ASSERT (head [cur_score] >= EMPTY) ;
            next_col = head [cur_score] ;
            Col [col].shared4.degree_next = next_col ;
            Col [col].shared3.prev = EMPTY ;
            if (next_col != EMPTY)
            {
                Col [next_col].shared3.prev = col ;
            }
            head [cur_score] = col ;

            /* see if this score is less than current min */
            min_score = MIN (min_score, cur_score) ;

        }

#ifndef NDEBUG
        debug_deg_lists (n_row, n_col, Row, Col, head,
                min_score, n_col2-k, max_deg) ;
#endif /* NDEBUG */

        /* === Resurrect the new pivot row ================================== */

        if (pivot_row_degree > 0)
        {
            /* update pivot row length to reflect any cols that were killed */
            /* during super-col detection and mass elimination */
            Row [pivot_row].start  = pivot_row_start ;
            Row [pivot_row].length = (int) (new_rp - &A[pivot_row_start]) ;
            Row [pivot_row].shared1.degree = pivot_row_degree ;
            Row [pivot_row].shared2.mark = 0 ;
            /* pivot row is no longer dead */
        }
    }

    /* === All principal columns have now been ordered ====================== */

    return (ngarbage) ;
}

Here is the call graph for this function:

static integer garbage_collection ( integer  n_row, integer  n_col, mbdyn_Colamd_Row  Row[], mbdyn_Colamd_Col  Col[], integer  A[], integer *  pfree  )

static

Definition at line 2928 of file colamd.c.

References ASSERT, c, COL_IS_ALIVE, DEBUG2, DEBUG3, KILL_ROW, ONES_COMPLEMENT, and ROW_IS_ALIVE.

Referenced by find_ordering().

{
    /* === Local variables ================================================== */

    integer *psrc ;                     /* source pointer */
    integer *pdest ;            /* destination pointer */
    integer j ;                 /* counter */
    integer r ;                 /* a row index */
    integer c ;                 /* a column index */
    integer length ;            /* length of a row or column */

#ifndef NDEBUG
    integer debug_rows ;
    DEBUG2 (("Defrag..\n")) ;
    for (psrc = &A[0] ; psrc < pfree ; psrc++) ASSERT (*psrc >= 0) ;
    debug_rows = 0 ;
#endif /* NDEBUG */

    /* === Defragment the columns =========================================== */

    pdest = &A[0] ;
    for (c = 0 ; c < n_col ; c++)
    {
        if (COL_IS_ALIVE (c))
        {
            psrc = &A [Col [c].start] ;

            /* move and compact the column */
            ASSERT (pdest <= psrc) ;
            Col [c].start = (int) (pdest - &A [0]) ;
            length = Col [c].length ;
            for (j = 0 ; j < length ; j++)
            {
                r = *psrc++ ;
                if (ROW_IS_ALIVE (r))
                {
                    *pdest++ = r ;
                }
            }
            Col [c].length = (int) (pdest - &A [Col [c].start]) ;
        }
    }

    /* === Prepare to defragment the rows =================================== */

    for (r = 0 ; r < n_row ; r++)
    {
        if (ROW_IS_ALIVE (r))
        {
            if (Row [r].length == 0)
            {
                /* this row is of zero length.  cannot compact it, so kill it */
                DEBUG3 (("Defrag row kill\n")) ;
                KILL_ROW (r) ;
            }
            else
            {
                /* save first column index in Row [r].shared2.first_column */
                psrc = &A [Row [r].start] ;
                Row [r].shared2.first_column = *psrc ;
                ASSERT (ROW_IS_ALIVE (r)) ;
                /* flag the start of the row with the one's complement of row */
                *psrc = ONES_COMPLEMENT (r) ;

#ifndef NDEBUG
                debug_rows++ ;
#endif /* NDEBUG */

            }
        }
    }

    /* === Defragment the rows ============================================== */

    psrc = pdest ;
    while (psrc < pfree)
    {
        /* find a negative number ... the start of a row */
        if (*psrc++ < 0)
        {
            psrc-- ;
            /* get the row index */
            r = ONES_COMPLEMENT (*psrc) ;
            ASSERT (r >= 0 && r < n_row) ;
            /* restore first column index */
            *psrc = Row [r].shared2.first_column ;
            ASSERT (ROW_IS_ALIVE (r)) ;

            /* move and compact the row */
            ASSERT (pdest <= psrc) ;
            Row [r].start = (int) (pdest - &A [0]) ;
            length = Row [r].length ;
            for (j = 0 ; j < length ; j++)
            {
                c = *psrc++ ;
                if (COL_IS_ALIVE (c))
                {
                    *pdest++ = c ;
                }
            }
            Row [r].length = (int) (pdest - &A [Row [r].start]) ;

#ifndef NDEBUG
            debug_rows-- ;
#endif /* NDEBUG */

        }
    }
    /* ensure we found all the rows */
    ASSERT (debug_rows == 0) ;

    /* === Return the new value of pfree ==================================== */

    return ((int) (pdest - &A [0])) ;
}

static integer init_rows_cols ( integer  n_row, integer  n_col, mbdyn_Colamd_Row  Row[], mbdyn_Colamd_Col  Col[], integer  A[], integer  p[], integer  stats[20]  )

static

Definition at line 1613 of file colamd.c.

References ASSERT, COLAMD_ERROR_col_length_negative, COLAMD_ERROR_row_index_out_of_bounds, COLAMD_INFO1, COLAMD_INFO2, COLAMD_INFO3, COLAMD_OK_BUT_JUMBLED, COLAMD_STATUS, DEBUG0, DEBUG1, EMPTY, FALSE, and TRUE.

Referenced by mbdyn_colamd().

{
    /* === Local variables ================================================== */

    integer col ;                       /* a column index */
    integer row ;                       /* a row index */
    integer *cp ;                       /* a column pointer */
    integer *cp_end ;           /* a pointer to the end of a column */
    integer *rp ;                       /* a row pointer */
    integer *rp_end ;           /* a pointer to the end of a row */
    integer last_row ;          /* previous row */

    /* === Initialize columns, and check column pointers ==================== */

    for (col = 0 ; col < n_col ; col++)
    {
        Col [col].start = p [col] ;
        Col [col].length = p [col+1] - p [col] ;

        if (Col [col].length < 0)
        {
            /* column pointers must be non-decreasing */
            stats [COLAMD_STATUS] = COLAMD_ERROR_col_length_negative ;
            stats [COLAMD_INFO1] = col ;
            stats [COLAMD_INFO2] = Col [col].length ;
            DEBUG0 (("colamd: col %d length %d < 0\n", col, Col [col].length)) ;
            return (FALSE) ;
        }

        Col [col].shared1.thickness = 1 ;
        Col [col].shared2.score = 0 ;
        Col [col].shared3.prev = EMPTY ;
        Col [col].shared4.degree_next = EMPTY ;
    }

    /* p [0..n_col] no longer needed, used as "head" in subsequent routines */

    /* === Scan columns, compute row degrees, and check row indices ========= */

    stats [COLAMD_INFO3] = 0 ;  /* number of duplicate or unsorted row indices*/

    for (row = 0 ; row < n_row ; row++)
    {
        Row [row].length = 0 ;
        Row [row].shared2.mark = -1 ;
    }

    for (col = 0 ; col < n_col ; col++)
    {
        last_row = -1 ;

        cp = &A [p [col]] ;
        cp_end = &A [p [col+1]] ;

        while (cp < cp_end)
        {
            row = *cp++ ;

            /* make sure row indices within range */
            if (row < 0 || row >= n_row)
            {
                stats [COLAMD_STATUS] = COLAMD_ERROR_row_index_out_of_bounds ;
                stats [COLAMD_INFO1] = col ;
                stats [COLAMD_INFO2] = row ;
                stats [COLAMD_INFO3] = n_row ;
                DEBUG0 (("colamd: row %d col %d out of bounds\n", row, col)) ;
                return (FALSE) ;
            }

            if (row <= last_row || Row [row].shared2.mark == col)
            {
                /* row index are unsorted or repeated (or both), thus col */
                /* is jumbled.  This is a notice, not an error condition. */
                stats [COLAMD_STATUS] = COLAMD_OK_BUT_JUMBLED ;
                stats [COLAMD_INFO1] = col ;
                stats [COLAMD_INFO2] = row ;
                (stats [COLAMD_INFO3]) ++ ;
                DEBUG1 (("colamd: row %d col %d unsorted/duplicate\n",row,col));
            }

            if (Row [row].shared2.mark != col)
            {
                Row [row].length++ ;
            }
            else
            {
                /* this is a repeated entry in the column, */
                /* it will be removed */
                Col [col].length-- ;
            }

            /* mark the row as having been seen in this column */
            Row [row].shared2.mark = col ;

            last_row = row ;
        }
    }

    /* === Compute row pointers ============================================= */

    /* row form of the matrix starts directly after the column */
    /* form of matrix in A */
    Row [0].start = p [n_col] ;
    Row [0].shared1.p = Row [0].start ;
    Row [0].shared2.mark = -1 ;
    for (row = 1 ; row < n_row ; row++)
    {
        Row [row].start = Row [row-1].start + Row [row-1].length ;
        Row [row].shared1.p = Row [row].start ;
        Row [row].shared2.mark = -1 ;
    }

    /* === Create row form ================================================== */

    if (stats [COLAMD_STATUS] == COLAMD_OK_BUT_JUMBLED)
    {
        /* if cols jumbled, watch for repeated row indices */
        for (col = 0 ; col < n_col ; col++)
        {
            cp = &A [p [col]] ;
            cp_end = &A [p [col+1]] ;
            while (cp < cp_end)
            {
                row = *cp++ ;
                if (Row [row].shared2.mark != col)
                {
                    A [(Row [row].shared1.p)++] = col ;
                    Row [row].shared2.mark = col ;
                }
            }
        }
    }
    else
    {
        /* if cols not jumbled, we don't need the mark (this is faster) */
        for (col = 0 ; col < n_col ; col++)
        {
            cp = &A [p [col]] ;
            cp_end = &A [p [col+1]] ;
            while (cp < cp_end)
            {
                A [(Row [*cp++].shared1.p)++] = col ;
            }
        }
    }

    /* === Clear the row marks and set row degrees ========================== */

    for (row = 0 ; row < n_row ; row++)
    {
        Row [row].shared2.mark = 0 ;
        Row [row].shared1.degree = Row [row].length ;
    }

    /* === See if we need to re-create columns ============================== */

    if (stats [COLAMD_STATUS] == COLAMD_OK_BUT_JUMBLED)
    {
        DEBUG0 (("colamd: reconstructing column form, matrix jumbled\n")) ;

#ifndef NDEBUG
        /* make sure column lengths are correct */
        for (col = 0 ; col < n_col ; col++)
        {
            p [col] = Col [col].length ;
        }
        for (row = 0 ; row < n_row ; row++)
        {
            rp = &A [Row [row].start] ;
            rp_end = rp + Row [row].length ;
            while (rp < rp_end)
            {
                p [*rp++]-- ;
            }
        }
        for (col = 0 ; col < n_col ; col++)
        {
            ASSERT (p [col] == 0) ;
        }
        /* now p is all zero (different than when debugging is turned off) */
#endif /* NDEBUG */

        /* === Compute col pointers ========================================= */

        /* col form of the matrix starts at A [0]. */
        /* Note, we may have a gap between the col form and the row */
        /* form if there were duplicate entries, if so, it will be */
        /* removed upon the first garbage collection */
        Col [0].start = 0 ;
        p [0] = Col [0].start ;
        for (col = 1 ; col < n_col ; col++)
        {
            /* note that the lengths here are for pruned columns, i.e. */
            /* no duplicate row indices will exist for these columns */
            Col [col].start = Col [col-1].start + Col [col-1].length ;
            p [col] = Col [col].start ;
        }

        /* === Re-create col form =========================================== */

        for (row = 0 ; row < n_row ; row++)
        {
            rp = &A [Row [row].start] ;
            rp_end = rp + Row [row].length ;
            while (rp < rp_end)
            {
                A [(p [*rp++])++] = row ;
            }
        }
    }

    /* === Done.  Matrix is not (or no longer) jumbled ====================== */

    return (TRUE) ;
}

static void init_scoring ( integer  n_row, integer  n_col, mbdyn_Colamd_Row  Row[], mbdyn_Colamd_Col  Col[], integer  A[], integer  head[], double  knobs[20], integer *  p_n_row2, integer *  p_n_col2, integer *  p_max_deg  )

static

Definition at line 1850 of file colamd.c.

References ASSERT, c, COL_IS_ALIVE, COL_IS_DEAD, COLAMD_DENSE_COL, COLAMD_DENSE_ROW, DEBUG1, DEBUG2, DEBUG4, mbdyn_Colamd_Row::degree, mbdyn_Colamd_Col::degree_next, EMPTY, KILL_PRINCIPAL_COL, KILL_ROW, mbdyn_Colamd_Col::length, MAX, MIN, mbdyn_Colamd_Col::order, mbdyn_Colamd_Col::prev, ROW_IS_DEAD, mbdyn_Colamd_Col::score, mbdyn_Colamd_Row::shared1, mbdyn_Colamd_Col::shared2, mbdyn_Colamd_Col::shared3, mbdyn_Colamd_Col::shared4, and mbdyn_Colamd_Col::start.

Referenced by mbdyn_colamd().

{
    /* === Local variables ================================================== */

    integer c ;                 /* a column index */
    integer r, row ;            /* a row index */
    integer *cp ;                       /* a column pointer */
    integer deg ;                       /* degree of a row or column */
    integer *cp_end ;           /* a pointer to the end of a column */
    integer *new_cp ;           /* new column pointer */
    integer col_length ;                /* length of pruned column */
    integer score ;                     /* current column score */
    integer n_col2 ;            /* number of non-dense, non-empty columns */
    integer n_row2 ;            /* number of non-dense, non-empty rows */
    integer dense_row_count ;   /* remove rows with more entries than this */
    integer dense_col_count ;   /* remove cols with more entries than this */
    integer min_score ;         /* smallest column score */
    integer max_deg ;           /* maximum row degree */
    integer next_col ;          /* Used to add to degree list.*/

#ifndef NDEBUG
    integer debug_count ;               /* debug only. */
#endif /* NDEBUG */

    /* === Extract knobs ==================================================== */

    dense_row_count = MAX (0, MIN (knobs [COLAMD_DENSE_ROW] * n_col, n_col)) ;
    dense_col_count = MAX (0, MIN (knobs [COLAMD_DENSE_COL] * n_row, n_row)) ;
    DEBUG1 (("colamd: densecount: %d %d\n", dense_row_count, dense_col_count)) ;
    max_deg = 0 ;
    n_col2 = n_col ;
    n_row2 = n_row ;

    /* === Kill empty columns =============================================== */

    /* Put the empty columns at the end in their natural order, so that LU */
    /* factorization can proceed as far as possible. */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        deg = Col [c].length ;
        if (deg == 0)
        {
            /* this is a empty column, kill and order it last */
            Col [c].shared2.order = --n_col2 ;
            KILL_PRINCIPAL_COL (c) ;
        }
    }
    DEBUG1 (("colamd: null columns killed: %d\n", n_col - n_col2)) ;

    /* === Kill dense columns =============================================== */

    /* Put the dense columns at the end, in their natural order */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        /* skip any dead columns */
        if (COL_IS_DEAD (c))
        {
            continue ;
        }
        deg = Col [c].length ;
        if (deg > dense_col_count)
        {
            /* this is a dense column, kill and order it last */
            Col [c].shared2.order = --n_col2 ;
            /* decrement the row degrees */
            cp = &A [Col [c].start] ;
            cp_end = cp + Col [c].length ;
            while (cp < cp_end)
            {
                Row [*cp++].shared1.degree-- ;
            }
            KILL_PRINCIPAL_COL (c) ;
        }
    }
    DEBUG1 (("colamd: Dense and null columns killed: %d\n", n_col - n_col2)) ;

    /* === Kill dense and empty rows ======================================== */

    for (r = 0 ; r < n_row ; r++)
    {
        deg = Row [r].shared1.degree ;
        ASSERT (deg >= 0 && deg <= n_col) ;
        if (deg > dense_row_count || deg == 0)
        {
            /* kill a dense or empty row */
            KILL_ROW (r) ;
            --n_row2 ;
        }
        else
        {
            /* keep track of max degree of remaining rows */
            max_deg = MAX (max_deg, deg) ;
        }
    }
    DEBUG1 (("colamd: Dense and null rows killed: %d\n", n_row - n_row2)) ;

    /* === Compute initial column scores ==================================== */

    /* At this point the row degrees are accurate.  They reflect the number */
    /* of "live" (non-dense) columns in each row.  No empty rows exist. */
    /* Some "live" columns may contain only dead rows, however.  These are */
    /* pruned in the code below. */

    /* now find the initial matlab score for each column */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        /* skip dead column */
        if (COL_IS_DEAD (c))
        {
            continue ;
        }
        score = 0 ;
        cp = &A [Col [c].start] ;
        new_cp = cp ;
        cp_end = cp + Col [c].length ;
        while (cp < cp_end)
        {
            /* get a row */
            row = *cp++ ;
            /* skip if dead */
            if (ROW_IS_DEAD (row))
            {
                continue ;
            }
            /* compact the column */
            *new_cp++ = row ;
            /* add row's external degree */
            score += Row [row].shared1.degree - 1 ;
            /* guard against integer overflow */
            score = MIN (score, n_col) ;
        }
        /* determine pruned column length */
        col_length = (int) (new_cp - &A [Col [c].start]) ;
        if (col_length == 0)
        {
            /* a newly-made null column (all rows in this col are "dense" */
            /* and have already been killed) */
            DEBUG2 (("Newly null killed: %d\n", c)) ;
            Col [c].shared2.order = --n_col2 ;
            KILL_PRINCIPAL_COL (c) ;
        }
        else
        {
            /* set column length and set score */
            ASSERT (score >= 0) ;
            ASSERT (score <= n_col) ;
            Col [c].length = col_length ;
            Col [c].shared2.score = score ;
        }
    }
    DEBUG1 (("colamd: Dense, null, and newly-null columns killed: %d\n",
        n_col-n_col2)) ;

    /* At this point, all empty rows and columns are dead.  All live columns */
    /* are "clean" (containing no dead rows) and simplicial (no supercolumns */
    /* yet).  Rows may contain dead columns, but all live rows contain at */
    /* least one live column. */

#ifndef NDEBUG
    debug_structures (n_row, n_col, Row, Col, A, n_col2) ;
#endif /* NDEBUG */

    /* === Initialize degree lists ========================================== */

#ifndef NDEBUG
    debug_count = 0 ;
#endif /* NDEBUG */

    /* clear the hash buckets */
    for (c = 0 ; c <= n_col ; c++)
    {
        head [c] = EMPTY ;
    }
    min_score = n_col ;
    /* place in reverse order, so low column indices are at the front */
    /* of the lists.  This is to encourage natural tie-breaking */
    for (c = n_col-1 ; c >= 0 ; c--)
    {
        /* only add principal columns to degree lists */
        if (COL_IS_ALIVE (c))
        {
            DEBUG4 (("place %d score %d minscore %d ncol %d\n",
                c, Col [c].shared2.score, min_score, n_col)) ;

            /* === Add columns score to DList =============================== */

            score = Col [c].shared2.score ;

            ASSERT (min_score >= 0) ;
            ASSERT (min_score <= n_col) ;
            ASSERT (score >= 0) ;
            ASSERT (score <= n_col) ;
            ASSERT (head [score] >= EMPTY) ;

            /* now add this column to dList at proper score location */
            next_col = head [score] ;
            Col [c].shared3.prev = EMPTY ;
            Col [c].shared4.degree_next = next_col ;

            /* if there already was a column with the same score, set its */
            /* previous pointer to this new column */
            if (next_col != EMPTY)
            {
                Col [next_col].shared3.prev = c ;
            }
            head [score] = c ;

            /* see if this score is less than current min */
            min_score = MIN (min_score, score) ;

#ifndef NDEBUG
            debug_count++ ;
#endif /* NDEBUG */

        }
    }

#ifndef NDEBUG
    DEBUG1 (("colamd: Live cols %d out of %d, non-princ: %d\n",
        debug_count, n_col, n_col-debug_count)) ;
    ASSERT (debug_count == n_col2) ;
    debug_deg_lists (n_row, n_col, Row, Col, head, min_score, n_col2, max_deg) ;
#endif /* NDEBUG */

    /* === Return number of remaining columns, and max row degree =========== */

    *p_n_col2 = n_col2 ;
    *p_n_row2 = n_row2 ;
    *p_max_deg = max_deg ;
}

integer mbdyn_colamd	(	integer	n_row,
		integer	n_col,
		integer	Alen,
		integer	A[],
		integer	p[],
		double	knobs[20],
		integer	stats[20]
	)

Definition at line 1411 of file colamd.c.

References COLAMD_C, COLAMD_DEFRAG_COUNT, COLAMD_DENSE_COL, COLAMD_DENSE_ROW, COLAMD_ERROR_A_not_present, COLAMD_ERROR_A_too_small, COLAMD_ERROR_ncol_negative, COLAMD_ERROR_nnz_negative, COLAMD_ERROR_nrow_negative, COLAMD_ERROR_p0_nonzero, COLAMD_ERROR_p_not_present, COLAMD_INFO1, COLAMD_INFO2, COLAMD_KNOBS, COLAMD_OK, COLAMD_R, COLAMD_STATS, COLAMD_STATUS, DEBUG0, FALSE, find_ordering(), init_rows_cols(), init_scoring(), mbdyn_colamd_set_defaults(), order_children(), and TRUE.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), and mbdyn_symamd().

{
    /* === Local variables ================================================== */

    integer i ;                 /* loop index */
    integer nnz ;                       /* nonzeros in A */
    integer Row_size ;          /* size of Row [], in integers */
    integer Col_size ;          /* size of Col [], in integers */
    integer need ;                      /* minimum required length of A */
    mbdyn_Colamd_Row *Row ;             /* pointer into A of Row [0..n_row] array */
    mbdyn_Colamd_Col *Col ;             /* pointer into A of Col [0..n_col] array */
    integer n_col2 ;            /* number of non-dense, non-empty columns */
    integer n_row2 ;            /* number of non-dense, non-empty rows */
    integer ngarbage ;          /* number of garbage collections performed */
    integer max_deg ;           /* maximum row degree */
    double default_knobs [COLAMD_KNOBS] ;       /* default knobs array */

#ifndef NDEBUG
    colamd_get_debug ("colamd") ;
#endif /* NDEBUG */

    /* === Check the input arguments ======================================== */

    if (!stats)
    {
        DEBUG0 (("colamd: stats not present\n")) ;
        return (FALSE) ;
    }
    for (i = 0 ; i < COLAMD_STATS ; i++)
    {
        stats [i] = 0 ;
    }
    stats [COLAMD_STATUS] = COLAMD_OK ;
    stats [COLAMD_INFO1] = -1 ;
    stats [COLAMD_INFO2] = -1 ;

    if (!A)             /* A is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_not_present ;
        DEBUG0 (("colamd: A not present\n")) ;
        return (FALSE) ;
    }

    if (!p)             /* p is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p_not_present ;
        DEBUG0 (("colamd: p not present\n")) ;
        return (FALSE) ;
    }

    if (n_row < 0)      /* n_row must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nrow_negative ;
        stats [COLAMD_INFO1] = n_row ;
        DEBUG0 (("colamd: nrow negative %d\n", n_row)) ;
        return (FALSE) ;
    }

    if (n_col < 0)      /* n_col must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
        stats [COLAMD_INFO1] = n_col ;
        DEBUG0 (("colamd: ncol negative %d\n", n_col)) ;
        return (FALSE) ;
    }

    nnz = p [n_col] ;
    if (nnz < 0)        /* nnz must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
        stats [COLAMD_INFO1] = nnz ;
        DEBUG0 (("colamd: number of entries negative %d\n", nnz)) ;
        return (FALSE) ;
    }

    if (p [0] != 0)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
        stats [COLAMD_INFO1] = p [0] ;
        DEBUG0 (("colamd: p[0] not zero %d\n", p [0])) ;
        return (FALSE) ;
    }

    /* === If no knobs, set default knobs =================================== */

    if (!knobs)
    {
        mbdyn_colamd_set_defaults (default_knobs) ;
        knobs = default_knobs ;
    }

    /* === Allocate the Row and Col arrays from array A ===================== */

    Col_size = COLAMD_C (n_col) ;
    Row_size = COLAMD_R (n_row) ;
    need = 2*nnz + n_col + Col_size + Row_size ;

    if (need > Alen)
    {
        /* not enough space in array A to perform the ordering */
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_too_small ;
        stats [COLAMD_INFO1] = need ;
        stats [COLAMD_INFO2] = Alen ;
        DEBUG0 (("colamd: Need Alen >= %d, given only Alen = %d\n", need,Alen));
        return (FALSE) ;
    }

    Alen -= Col_size + Row_size ;
    Col = (mbdyn_Colamd_Col *) &A [Alen] ;
    Row = (mbdyn_Colamd_Row *) &A [Alen + Col_size] ;

    /* === Construct the row and column data structures ===================== */

    if (!init_rows_cols (n_row, n_col, Row, Col, A, p, stats))
    {
        /* input matrix is invalid */
        DEBUG0 (("colamd: Matrix invalid\n")) ;
        return (FALSE) ;
    }

    /* === Initialize scores, kill dense rows/columns ======================= */

    init_scoring (n_row, n_col, Row, Col, A, p, knobs,
        &n_row2, &n_col2, &max_deg) ;

    /* === Order the supercolumns =========================================== */

    ngarbage = find_ordering (n_row, n_col, Alen, Row, Col, A, p,
        n_col2, max_deg, 2*nnz) ;

    /* === Order the non-principal columns ================================== */

    order_children (n_col, Col, p) ;

    /* === Return statistics in stats ======================================= */

    stats [COLAMD_DENSE_ROW] = n_row - n_row2 ;
    stats [COLAMD_DENSE_COL] = n_col - n_col2 ;
    stats [COLAMD_DEFRAG_COUNT] = ngarbage ;
    DEBUG0 (("colamd: done.\n")) ; 
    return (TRUE) ;
}

Here is the call graph for this function:

integer mbdyn_colamd_recommended	(	integer	nnz,
		integer	n_row,
		integer	n_col
	)

Definition at line 1004 of file colamd.c.

References COLAMD_RECOMMENDED.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), and mbdyn_symamd().

{
    return (COLAMD_RECOMMENDED (nnz, n_row, n_col)) ; 
}

void mbdyn_colamd_report

(

integer

stats[20]

)

Definition at line 1570 of file colamd.c.

References print_report().

{
    print_report ("colamd", stats) ;
}

Here is the call graph for this function:

void mbdyn_colamd_set_defaults

(

double

knobs[20]

)

Definition at line 1038 of file colamd.c.

References COLAMD_DENSE_COL, COLAMD_DENSE_ROW, and COLAMD_KNOBS.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), mbdyn_colamd(), and mbdyn_symamd().

{
    /* === Local variables ================================================== */

    integer i ;

    if (!knobs)
    {
        return ;                        /* no knobs to initialize */
    }
    for (i = 0 ; i < COLAMD_KNOBS ; i++)
    {
        knobs [i] = 0 ;
    }
    knobs [COLAMD_DENSE_ROW] = 0.5 ;    /* ignore rows over 50% dense */
    knobs [COLAMD_DENSE_COL] = 0.5 ;    /* ignore columns over 50% dense */
}

integer mbdyn_symamd	(	integer	n,
		integer	A[],
		integer	p[],
		integer	perm[],
		double	knobs[20],
		integer	stats[20],
		void *(*)(size_t, size_t)	allocate,
		void(*)(void *)	release
	)

Definition at line 1066 of file colamd.c.

References ASSERT, COLAMD_DEFRAG_COUNT, COLAMD_DENSE_COL, COLAMD_DENSE_ROW, COLAMD_ERROR_A_not_present, COLAMD_ERROR_col_length_negative, COLAMD_ERROR_internal_error, COLAMD_ERROR_ncol_negative, COLAMD_ERROR_nnz_negative, COLAMD_ERROR_out_of_memory, COLAMD_ERROR_p0_nonzero, COLAMD_ERROR_p_not_present, COLAMD_ERROR_row_index_out_of_bounds, COLAMD_INFO1, COLAMD_INFO2, COLAMD_INFO3, COLAMD_KNOBS, COLAMD_OK, COLAMD_OK_BUT_JUMBLED, COLAMD_STATS, COLAMD_STATUS, count, DEBUG0, DEBUG1, FALSE, mbdyn_colamd(), mbdyn_colamd_recommended(), mbdyn_colamd_set_defaults(), and TRUE.

{
    /* === Local variables ================================================== */

    integer *count ;            /* length of each column of M, and col pointer*/
    integer *mark ;                     /* mark array for finding duplicate entries */
    integer *M ;                        /* row indices of matrix M */
    integer Mlen ;                      /* length of M */
    integer n_row ;                     /* number of rows in M */
    integer nnz ;                       /* number of entries in A */
    integer i ;                 /* row index of A */
    integer j ;                 /* column index of A */
    integer k ;                 /* row index of M */ 
    integer mnz ;                       /* number of nonzeros in M */
    integer pp ;                        /* index into a column of A */
    integer last_row ;          /* last row seen in the current column */
    integer length ;            /* number of nonzeros in a column */

    double cknobs [COLAMD_KNOBS] ;              /* knobs for colamd */
    double default_knobs [COLAMD_KNOBS] ;       /* default knobs for colamd */
    integer cstats [COLAMD_STATS] ;                     /* colamd stats */

#ifndef NDEBUG
    colamd_get_debug ("symamd") ;
#endif /* NDEBUG */

    /* === Check the input arguments ======================================== */

    if (!stats)
    {
        DEBUG0 (("symamd: stats not present\n")) ;
        return (FALSE) ;
    }
    for (i = 0 ; i < COLAMD_STATS ; i++)
    {
        stats [i] = 0 ;
    }
    stats [COLAMD_STATUS] = COLAMD_OK ;
    stats [COLAMD_INFO1] = -1 ;
    stats [COLAMD_INFO2] = -1 ;

    if (!A)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_not_present ;
        DEBUG0 (("symamd: A not present\n")) ;
        return (FALSE) ;
    }

    if (!p)             /* p is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p_not_present ;
        DEBUG0 (("symamd: p not present\n")) ;
        return (FALSE) ;
    }

    if (n < 0)          /* n must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
        stats [COLAMD_INFO1] = n ;
        DEBUG0 (("symamd: n negative %d\n", n)) ;
        return (FALSE) ;
    }

    nnz = p [n] ;
    if (nnz < 0)        /* nnz must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
        stats [COLAMD_INFO1] = nnz ;
        DEBUG0 (("symamd: number of entries negative %d\n", nnz)) ;
        return (FALSE) ;
    }

    if (p [0] != 0)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
        stats [COLAMD_INFO1] = p [0] ;
        DEBUG0 (("symamd: p[0] not zero %d\n", p [0])) ;
        return (FALSE) ;
    }

    /* === If no knobs, set default knobs =================================== */

    if (!knobs)
    {
        mbdyn_colamd_set_defaults (default_knobs) ;
        knobs = default_knobs ;
    }

    /* === Allocate count and mark ========================================== */

    count = (integer *) ((*allocate) (n+1, sizeof (int))) ;
    if (!count)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        DEBUG0 (("symamd: allocate count (size %d) failed\n", n+1)) ;
        return (FALSE) ;
    }

    mark = (integer *) ((*allocate) (n+1, sizeof (int))) ;
    if (!mark)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        (*release) ((void *) count) ;
        DEBUG0 (("symamd: allocate mark (size %d) failed\n", n+1)) ;
        return (FALSE) ;
    }

    /* === Compute column counts of M, check if A is valid ================== */

    stats [COLAMD_INFO3] = 0 ;  /* number of duplicate or unsorted row indices*/

    for (i = 0 ; i < n ; i++)
    {
        mark [i] = -1 ;
    }

    for (j = 0 ; j < n ; j++)
    {
        last_row = -1 ;

        length = p [j+1] - p [j] ;
        if (length < 0)
        {
            /* column pointers must be non-decreasing */
            stats [COLAMD_STATUS] = COLAMD_ERROR_col_length_negative ;
            stats [COLAMD_INFO1] = j ;
            stats [COLAMD_INFO2] = length ;
            (*release) ((void *) count) ;
            (*release) ((void *) mark) ;
            DEBUG0 (("symamd: col %d negative length %d\n", j, length)) ;
            return (FALSE) ;
        }

        for (pp = p [j] ; pp < p [j+1] ; pp++)
        {
            i = A [pp] ;
            if (i < 0 || i >= n)
            {
                /* row index i, in column j, is out of bounds */
                stats [COLAMD_STATUS] = COLAMD_ERROR_row_index_out_of_bounds ;
                stats [COLAMD_INFO1] = j ;
                stats [COLAMD_INFO2] = i ;
                stats [COLAMD_INFO3] = n ;
                (*release) ((void *) count) ;
                (*release) ((void *) mark) ;
                DEBUG0 (("symamd: row %d col %d out of bounds\n", i, j)) ;
                return (FALSE) ;
            }

            if (i <= last_row || mark [i] == j)
            {
                /* row index is unsorted or repeated (or both), thus col */
                /* is jumbled.  This is a notice, not an error condition. */
                stats [COLAMD_STATUS] = COLAMD_OK_BUT_JUMBLED ;
                stats [COLAMD_INFO1] = j ;
                stats [COLAMD_INFO2] = i ;
                (stats [COLAMD_INFO3]) ++ ;
                DEBUG1 (("symamd: row %d col %d unsorted/duplicate\n", i, j)) ;
            }

            if (i > j && mark [i] != j)
            {
                /* row k of M will contain column indices i and j */
                count [i]++ ;
                count [j]++ ;
            }

            /* mark the row as having been seen in this column */
            mark [i] = j ;

            last_row = i ;
        }
    }

    if (stats [COLAMD_STATUS] == COLAMD_OK)
    {
        /* if there are no duplicate entries, then mark is no longer needed */
        (*release) ((void *) mark) ;
    }

    /* === Compute column pointers of M ===================================== */

    /* use output permutation, perm, for column pointers of M */
    perm [0] = 0 ;
    for (j = 1 ; j <= n ; j++)
    {
        perm [j] = perm [j-1] + count [j-1] ;
    }
    for (j = 0 ; j < n ; j++)
    {
        count [j] = perm [j] ;
    }

    /* === Construct M ====================================================== */

    mnz = perm [n] ;
    n_row = mnz / 2 ;
    Mlen = mbdyn_colamd_recommended (mnz, n_row, n) ;
    M = (integer *) ((*allocate) (Mlen, sizeof (int))) ;
    DEBUG0 (("symamd: M is %d-by-%d with %d entries, Mlen = %d\n",
        n_row, n, mnz, Mlen)) ;

    if (!M)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        (*release) ((void *) count) ;
        (*release) ((void *) mark) ;
        DEBUG0 (("symamd: allocate M (size %d) failed\n", Mlen)) ;
        return (FALSE) ;
    }

    k = 0 ;

    if (stats [COLAMD_STATUS] == COLAMD_OK)
    {
        /* Matrix is OK */
        for (j = 0 ; j < n ; j++)
        {
            ASSERT (p [j+1] - p [j] >= 0) ;
            for (pp = p [j] ; pp < p [j+1] ; pp++)
            {
                i = A [pp] ;
                ASSERT (i >= 0 && i < n) ;
                if (i > j)
                {
                    /* row k of M contains column indices i and j */
                    M [count [i]++] = k ;
                    M [count [j]++] = k ;
                    k++ ;
                }
            }
        }
    }
    else
    {
        /* Matrix is jumbled.  Do not add duplicates to M.  Unsorted cols OK. */
        DEBUG0 (("symamd: Duplicates in A.\n")) ;
        for (i = 0 ; i < n ; i++)
        {
            mark [i] = -1 ;
        }
        for (j = 0 ; j < n ; j++)
        {
            ASSERT (p [j+1] - p [j] >= 0) ;
            for (pp = p [j] ; pp < p [j+1] ; pp++)
            {
                i = A [pp] ;
                ASSERT (i >= 0 && i < n) ;
                if (i > j && mark [i] != j)
                {
                    /* row k of M contains column indices i and j */
                    M [count [i]++] = k ;
                    M [count [j]++] = k ;
                    k++ ;
                    mark [i] = j ;
                }
            }
        }
        (*release) ((void *) mark) ;
    }

    /* count and mark no longer needed */
    (*release) ((void *) count) ;
    ASSERT (k == n_row) ;

    /* === Adjust the knobs for M =========================================== */

    for (i = 0 ; i < COLAMD_KNOBS ; i++)
    {
        cknobs [i] = knobs [i] ;
    }

    /* there are no dense rows in M */
    cknobs [COLAMD_DENSE_ROW] = 1.0 ;

    if (n_row != 0 && n < n_row)
    {
        /* On input, the knob is a fraction of 1..n, the number of rows of A. */
        /* Convert it to a fraction of 1..n_row, of the number of rows of M. */
        cknobs [COLAMD_DENSE_COL] = (knobs [COLAMD_DENSE_ROW] * n) / n_row ;
    }
    else
    {
        /* no dense columns in M */
        cknobs [COLAMD_DENSE_COL] = 1.0 ;
    }

    DEBUG0 (("symamd: dense col knob for M: %g\n", cknobs [COLAMD_DENSE_COL])) ;

    /* === Order the columns of M =========================================== */

    if (!mbdyn_colamd (n_row, n, Mlen, M, perm, cknobs, cstats))
    {
        /* This "cannot" happen, unless there is a bug in the code. */
        stats [COLAMD_STATUS] = COLAMD_ERROR_internal_error ;
        (*release) ((void *) M) ;
        DEBUG0 (("symamd: internal error!\n")) ;
        return (FALSE) ;
    }

    /* Note that the output permutation is now in perm */

    /* === get the statistics for symamd from colamd ======================== */

    /* note that a dense column in colamd means a dense row and col in symamd */
    stats [COLAMD_DENSE_ROW]    = cstats [COLAMD_DENSE_COL] ;
    stats [COLAMD_DENSE_COL]    = cstats [COLAMD_DENSE_COL] ;
    stats [COLAMD_DEFRAG_COUNT] = cstats [COLAMD_DEFRAG_COUNT] ;

    /* === Free M =========================================================== */

    (*release) ((void *) M) ;
    DEBUG0 (("symamd: done.\n")) ;
    return (TRUE) ;

}

Here is the call graph for this function:

void mbdyn_symamd_report

(

integer

stats[20]

)

Definition at line 1583 of file colamd.c.

References print_report().

{
    print_report ("symamd", stats) ;
}

Here is the call graph for this function:

static void order_children ( integer  n_col, mbdyn_Colamd_Col  Col[], integer  p[]  )

static

Definition at line 2670 of file colamd.c.

References ASSERT, c, COL_IS_DEAD, COL_IS_DEAD_PRINCIPAL, EMPTY, order, mbdyn_Colamd_Col::order, mbdyn_Colamd_Col::parent, mbdyn_Colamd_Col::shared1, and mbdyn_Colamd_Col::shared2.

Referenced by mbdyn_colamd().

{
    /* === Local variables ================================================== */

    integer i ;                 /* loop counter for all columns */
    integer c ;                 /* column index */
    integer parent ;            /* index of column's parent */
    integer order ;                     /* column's order */

    /* === Order each non-principal column ================================== */

    for (i = 0 ; i < n_col ; i++)
    {
        /* find an un-ordered non-principal column */
        ASSERT (COL_IS_DEAD (i)) ;
        if (!COL_IS_DEAD_PRINCIPAL (i) && Col [i].shared2.order == EMPTY)
        {
            parent = i ;
            /* once found, find its principal parent */
            do
            {
                parent = Col [parent].shared1.parent ;
            } while (!COL_IS_DEAD_PRINCIPAL (parent)) ;

            /* now, order all un-ordered non-principal columns along path */
            /* to this parent.  collapse tree at the same time */
            c = i ;
            /* get order of parent */
            order = Col [parent].shared2.order ;

            do
            {
                ASSERT (Col [c].shared2.order == EMPTY) ;

                /* order this column */
                Col [c].shared2.order = order++ ;
                /* collaps tree */
                Col [c].shared1.parent = parent ;

                /* get immediate parent of this column */
                c = Col [c].shared1.parent ;

                /* continue until we hit an ordered column.  There are */
                /* guarranteed not to be anymore unordered columns */
                /* above an ordered column */
            } while (Col [c].shared2.order == EMPTY) ;

            /* re-order the super_col parent to largest order for this group */
            Col [parent].shared2.order = order ;
        }
    }

    /* === Generate the permutation ========================================= */

    for (c = 0 ; c < n_col ; c++)
    {
        p [Col [c].shared2.order] = c ;
    }
}

static void print_report ( char *  method, integer  stats[20]  )

static

Definition at line 3091 of file colamd.c.

References COLAMD_DEFRAG_COUNT, COLAMD_DENSE_COL, COLAMD_DENSE_ROW, COLAMD_ERROR_A_not_present, COLAMD_ERROR_A_too_small, COLAMD_ERROR_col_length_negative, COLAMD_ERROR_internal_error, COLAMD_ERROR_ncol_negative, COLAMD_ERROR_nnz_negative, COLAMD_ERROR_nrow_negative, COLAMD_ERROR_out_of_memory, COLAMD_ERROR_p0_nonzero, COLAMD_ERROR_p_not_present, COLAMD_ERROR_row_index_out_of_bounds, COLAMD_INFO1, COLAMD_INFO2, COLAMD_INFO3, COLAMD_OK, COLAMD_OK_BUT_JUMBLED, COLAMD_STATUS, INDEX, and PRINTF.

Referenced by mbdyn_colamd_report(), and mbdyn_symamd_report().

{

    integer i1, i2, i3 ;

    if (!stats)
    {
        PRINTF ("%s: No statistics available.\n", method) ;
        return ;
    }

    i1 = stats [COLAMD_INFO1] ;
    i2 = stats [COLAMD_INFO2] ;
    i3 = stats [COLAMD_INFO3] ;

    if (stats [COLAMD_STATUS] >= 0)
    {
        PRINTF ("%s: OK.  ", method) ;
    }
    else
    {
        PRINTF ("%s: ERROR.  ", method) ;
    }

    switch (stats [COLAMD_STATUS])
    {

        case COLAMD_OK_BUT_JUMBLED:

            PRINTF ("Matrix has unsorted or duplicate row indices.\n") ;

            PRINTF ("%s: number of duplicate or out-of-order row indices: %d\n",
            method, i3) ;

            PRINTF ("%s: last seen duplicate or out-of-order row index:   %d\n",
            method, INDEX (i2)) ;

            PRINTF ("%s: last seen in column:                             %d",
            method, INDEX (i1)) ;

            /* no break - fall through to next case instead */

        case COLAMD_OK:

            PRINTF ("\n") ;

            PRINTF ("%s: number of dense or empty rows ignored:           %d\n",
            method, stats [COLAMD_DENSE_ROW]) ;

            PRINTF ("%s: number of dense or empty columns ignored:        %d\n",
            method, stats [COLAMD_DENSE_COL]) ;

            PRINTF ("%s: number of garbage collections performed:         %d\n",
            method, stats [COLAMD_DEFRAG_COUNT]) ;
            break ;

        case COLAMD_ERROR_A_not_present:

            PRINTF ("Array A (row indices of matrix) not present.\n") ;
            break ;

        case COLAMD_ERROR_p_not_present:

            PRINTF ("Array p (column pointers for matrix) not present.\n") ;
            break ;

        case COLAMD_ERROR_nrow_negative:

            PRINTF ("Invalid number of rows (%d).\n", i1) ;
            break ;

        case COLAMD_ERROR_ncol_negative:

            PRINTF ("Invalid number of columns (%d).\n", i1) ;
            break ;

        case COLAMD_ERROR_nnz_negative:

            PRINTF ("Invalid number of nonzero entries (%d).\n", i1) ;
            break ;

        case COLAMD_ERROR_p0_nonzero:

            PRINTF ("Invalid column pointer, p [0] = %d, must be zero.\n", i1) ;
            break ;

        case COLAMD_ERROR_A_too_small:

            PRINTF ("Array A too small.\n") ;
            PRINTF ("        Need Alen >= %d, but given only Alen = %d.\n",
            i1, i2) ;
            break ;

        case COLAMD_ERROR_col_length_negative:

            PRINTF
            ("Column %d has a negative number of nonzero entries (%d).\n",
            INDEX (i1), i2) ;
            break ;

        case COLAMD_ERROR_row_index_out_of_bounds:

            PRINTF
            ("Row index (row %d) out of bounds (%d to %d) in column %d.\n",
            INDEX (i2), INDEX (0), INDEX (i3-1), INDEX (i1)) ;
            break ;

        case COLAMD_ERROR_out_of_memory:

            PRINTF ("Out of memory.\n") ;
            break ;

        case COLAMD_ERROR_internal_error:

            /* if this happens, there is a bug in the code */
            PRINTF
            ("Internal error! Please contact authors (davis@cise.ufl.edu).\n") ;
            break ;
    }
}