even more

OndselSolver/GESpMat.cpp

@@ -31,7 +31,7 @@ FColDsptr GESpMat::basicSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCo
 	return answerX;
 }
 
-FColDsptr GESpMat::basicSolvewithsaveOriginal(FMatDsptr fullMat, FColDsptr fullCol, bool saveOriginal)
+FColDsptr GESpMat::basicSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
 {
 	assert(false);
 	return FColDsptr();

OndselSolver/InLineJoint.cpp

@@ -13,7 +13,7 @@ MbD::InLineJoint::InLineJoint()
 {
 }
 
-MbD::InLineJoint::InLineJoint(const char* str)
+MbD::InLineJoint::InLineJoint(const char*)
 {
 }
 

OndselSolver/InPlaneJoint.cpp

@@ -13,7 +13,7 @@ MbD::InPlaneJoint::InPlaneJoint()
 {
 }
 
-MbD::InPlaneJoint::InPlaneJoint(const char* str)
+MbD::InPlaneJoint::InPlaneJoint(const char*)
 {
 }
 

OndselSolver/Integral.cpp

@@ -15,7 +15,7 @@ void MbD::Integral::arguments(Symsptr args)
 	expression = integrand->integrateWRT(xx);
 }
 
-Symsptr MbD::Integral::expandUntil(Symsptr sptr, std::shared_ptr<std::unordered_set<Symsptr>> set)
+Symsptr MbD::Integral::expandUntil(Symsptr, std::shared_ptr<std::unordered_set<Symsptr>> set)
 {
 	auto expand = expression->expandUntil(expression, set);
 	auto answer = std::make_shared<Integral>();
@@ -26,7 +26,7 @@ Symsptr MbD::Integral::expandUntil(Symsptr sptr, std::shared_ptr<std::unordered_
 	return answer;
 }
 
-Symsptr MbD::Integral::simplifyUntil(Symsptr sptr, std::shared_ptr<std::unordered_set<Symsptr>> set)
+Symsptr MbD::Integral::simplifyUntil(Symsptr, std::shared_ptr<std::unordered_set<Symsptr>> set)
 {
 	auto simple = expression->simplifyUntil(expression, set);
 	auto answer = std::make_shared<Integral>();

OndselSolver/Integrator.cpp

@@ -10,6 +10,6 @@
 
 using namespace MbD;
 
-void Integrator::setSystem(Solver* sys)
+void Integrator::setSystem(Solver*)
 {
 }

OndselSolver/IntegratorInterface.cpp

@@ -69,7 +69,7 @@ void IntegratorInterface::postFirstStep()
 	//this->checkForOutputThrough(integrator->t);
 }
 
-void IntegratorInterface::interpolateAt(double tArg)
+void IntegratorInterface::interpolateAt(double)
 {
 	//"Interpolate for system state at tArg and leave system in that state."
 	assert(false);

OndselSolver/Item.cpp

@@ -97,7 +97,7 @@ void MbD::Item::checkForCollisionDiscontinuityBetweenand(double, double)
 	assert(false);
 }
 
-void Item::removeRedundantConstraints(std::shared_ptr<std::vector<int>> redunEqnNos)
+void Item::removeRedundantConstraints(std::shared_ptr<std::vector<int>>)
 {
 }
 
@@ -125,11 +125,11 @@ void MbD::Item::registerName()
 	assert(false);
 }
 
-void Item::fillPosKineError(FColDsptr col)
+void Item::fillPosKineError(FColDsptr)
 {
 }
 
-void Item::fillPosKineJacob(SpMatDsptr mat)
+void Item::fillPosKineJacob(SpMatDsptr)
 {
 }
 
@@ -163,53 +163,53 @@ void MbD::Item::fillpFpydot(SpMatDsptr)
 	assert(false);
 }
 
-void Item::fillRedundantConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>> redunConstraints)
+void Item::fillRedundantConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
 {
 }
 
-void MbD::Item::fillStaticError(FColDsptr col)
+void MbD::Item::fillStaticError(FColDsptr)
 {
 	assert(false);
 }
 
-void MbD::Item::fillStaticJacob(FMatDsptr mat)
+void MbD::Item::fillStaticJacob(FMatDsptr)
 {
 	assert(false);
 }
 
-void Item::fillConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>> allConstraints)
+void Item::fillConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
 {
 	assert(false);
 }
 
-void MbD::Item::fillDispConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>> dispConstraints)
+void MbD::Item::fillDispConstraints(std::shared_ptr<std::vector<std::shared_ptr<Constraint>>>)
 {
 	assert(false);
 }
 
-void MbD::Item::fillDynError(FColDsptr col)
+void MbD::Item::fillDynError(FColDsptr)
 {
 	assert(false);
 }
 
-void Item::fillqsu(FColDsptr col)
+void Item::fillqsu(FColDsptr)
 {
 }
 
-void Item::fillqsuWeights(DiagMatDsptr diagMat)
+void Item::fillqsuWeights(DiagMatDsptr)
 {
 }
 
-void MbD::Item::fillqsuWeightsSmall(FColDsptr col)
+void MbD::Item::fillqsuWeightsSmall(FColDsptr)
 {
 	assert(false);
 }
 
-void Item::fillqsulam(FColDsptr col)
+void Item::fillqsulam(FColDsptr)
 {
 }
 
-void Item::setqsulam(FColDsptr col)
+void Item::setqsulam(FColDsptr)
 {
 }
 
@@ -316,13 +316,13 @@ void Item::storeDynState()
 {
 }
 
-double MbD::Item::suggestSmallerOrAcceptCollisionFirstStepSize(double hnew)
+double MbD::Item::suggestSmallerOrAcceptCollisionFirstStepSize(double)
 {
 	assert(false);
 	return 0.0;
 }
 
-double MbD::Item::suggestSmallerOrAcceptCollisionStepSize(double hnew)
+double MbD::Item::suggestSmallerOrAcceptCollisionStepSize(double)
 {
 	assert(false);
 	return 0.0;
@@ -356,47 +356,47 @@ void Item::postVelIC()
 {
 }
 
-void Item::fillqsudot(FColDsptr col)
+void Item::fillqsudot(FColDsptr)
 {
 }
 
-void MbD::Item::fillqsudotPlam(FColDsptr col)
+void MbD::Item::fillqsudotPlam(FColDsptr)
 {
 	assert(false);
 }
 
-void MbD::Item::fillqsudotPlamDeriv(FColDsptr col)
+void MbD::Item::fillqsudotPlamDeriv(FColDsptr)
 {
 	assert(false);
 }
 
-void Item::fillqsudotWeights(DiagMatDsptr diagMat)
+void Item::fillqsudotWeights(DiagMatDsptr)
 {
 }
 
-void Item::fillVelICError(FColDsptr col)
+void Item::fillVelICError(FColDsptr)
 {
 }
 
-void Item::fillVelICJacob(SpMatDsptr mat)
+void Item::fillVelICJacob(SpMatDsptr)
 {
 }
 
-void MbD::Item::getString(std::string str)
+void MbD::Item::getString(std::string)
 {
 	assert(false);
 }
 
-void Item::setqsudotlam(FColDsptr col)
+void Item::setqsudotlam(FColDsptr)
 {
 }
 
-void MbD::Item::setqsudotPlam(FColDsptr col)
+void MbD::Item::setqsudotPlam(FColDsptr)
 {
 	assert(false);
 }
 
-void MbD::Item::setqsudotPlamDeriv(FColDsptr col)
+void MbD::Item::setqsudotPlamDeriv(FColDsptr)
 {
 	assert(false);
 }
@@ -469,48 +469,48 @@ void MbD::Item::postCollisionStep()
 	assert(false);
 }
 
-void Item::fillqsuddotlam(FColDsptr col)
+void Item::fillqsuddotlam(FColDsptr)
 {
 }
 
-void Item::fillAccICIterError(FColDsptr col)
+void Item::fillAccICIterError(FColDsptr)
 {
 }
 
-void Item::fillAccICIterJacob(SpMatDsptr mat)
+void Item::fillAccICIterJacob(SpMatDsptr)
 {
 }
 
-void MbD::Item::fillCollisionDerivativeICError(FColDsptr col)
+void MbD::Item::fillCollisionDerivativeICError(FColDsptr)
 {
 	assert(false);
 }
 
-void MbD::Item::fillCollisionDerivativeICJacob(SpMatDsptr mat)
+void MbD::Item::fillCollisionDerivativeICJacob(SpMatDsptr)
 {
 	assert(false);
 }
 
-void MbD::Item::fillCollisionError(FColDsptr col)
+void MbD::Item::fillCollisionError(FColDsptr)
 {
 	assert(false);
 }
 
-void MbD::Item::fillCollisionpFpy(SpMatDsptr mat)
+void MbD::Item::fillCollisionpFpy(SpMatDsptr)
 {
 	assert(false);
 }
 
-void MbD::Item::fillCollisionpFpydot(SpMatDsptr mat)
+void MbD::Item::fillCollisionpFpydot(SpMatDsptr)
 {
 	assert(false);
 }
 
-void Item::setqsudot(FColDsptr col)
+void Item::setqsudot(FColDsptr)
 {
 }
 
-void Item::setqsuddotlam(FColDsptr col)
+void Item::setqsuddotlam(FColDsptr)
 {
 }
 
@@ -525,16 +525,16 @@ void MbD::Item::storeCollisionState()
 	assert(false);
 }
 
-void Item::discontinuityAtaddTypeTo(double t, std::shared_ptr<std::vector<DiscontinuityType>> disconTypes)
+void Item::discontinuityAtaddTypeTo(double, std::shared_ptr<std::vector<DiscontinuityType>>)
 {
 }
 
-void MbD::Item::discontinuityAtICAddTo(std::shared_ptr<std::vector<DiscontinuityType>> disconTypes)
+void MbD::Item::discontinuityAtICAddTo(std::shared_ptr<std::vector<DiscontinuityType>>)
 {
 	assert(false);
 }
 
-double Item::checkForDynDiscontinuityBetweenand(double tprev, double t)
+double Item::checkForDynDiscontinuityBetweenand(double, double t)
 {
 	//"Check for discontinuity in the last step defined by the interval (tprevious,t]."
 	//"Default is assume no discontinuity and return t."
@@ -546,7 +546,7 @@ void Item::constraintsReport()
 {
 }
 
-void Item::setqsu(FColDsptr qsuOld)
+void Item::setqsu(FColDsptr)
 {
 }
 
@@ -565,17 +565,17 @@ void Item::logString(const char* chars)
 	this->logString(str);
 }
 
-void MbD::Item::logStringwithArgument(const char* chars, const char* chars1)
+void MbD::Item::logStringwithArgument(const char*, const char*)
 {
 	assert(false);
 }
 
-void MbD::Item::logStringwithArguments(const char* chars, std::shared_ptr<std::vector<char*>> arrayOfChars)
+void MbD::Item::logStringwithArguments(const char*, std::shared_ptr<std::vector<char*>>)
 {
 	assert(false);
 }
 
-void MbD::Item::normalImpulse(double imp)
+void MbD::Item::normalImpulse(double)
 {
 	assert(false);
 }
@@ -618,14 +618,14 @@ void MbD::Item::postStaticIteration()
 	assert(false);
 }
 
-void Item::fillPosICError(FColDsptr col)
+void Item::fillPosICError(FColDsptr)
 {
 }
 
-void Item::fillPosICJacob(FMatDsptr mat)
+void Item::fillPosICJacob(FMatDsptr)
 {
 }
 
-void Item::fillPosICJacob(SpMatDsptr mat)
+void Item::fillPosICJacob(SpMatDsptr)
 {
 }

OndselSolver/Joint.cpp

@@ -134,7 +134,7 @@ void Joint::fillqsudot(FColDsptr col)
 	constraintsDo([&](std::shared_ptr<Constraint> con) { con->fillqsudot(col); });
 }
 
-void Joint::fillqsudotWeights(DiagMatDsptr diagMat)
+void Joint::fillqsudotWeights(DiagMatDsptr)
 {
 }
 
@@ -170,7 +170,7 @@ void Joint::fillPosICJacob(SpMatDsptr mat)
 
 void Joint::removeRedundantConstraints(std::shared_ptr<std::vector<int>> redundantEqnNos)
 {
-	for (int i = 0; i < constraints->size(); i++)
+	for (int i = 0; i < (int)constraints->size(); i++)
 	{
 		auto& constraint = constraints->at(i);
 		if (std::find(redundantEqnNos->begin(), redundantEqnNos->end(), constraint->iG) != redundantEqnNos->end()) {
@@ -183,7 +183,7 @@ void Joint::removeRedundantConstraints(std::shared_ptr<std::vector<int>> redunda
 
 void Joint::reactivateRedundantConstraints()
 {
-	for (int i = 0; i < constraints->size(); i++)
+	for (int i = 0; i < (int)constraints->size(); i++)
 	{
 		auto& con = constraints->at(i);
 		if (con->isRedundant()) {

OndselSolver/LDUFullMat.cpp

@@ -17,7 +17,7 @@ FColDsptr LDUFullMat::basicSolvewithsaveOriginal(FMatDsptr fullMat, FColDsptr fu
 	return answer;
 }
 
-FColDsptr LDUFullMat::basicSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCol, bool saveOriginal)
+FColDsptr LDUFullMat::basicSolvewithsaveOriginal(SpMatDsptr, FColDsptr, bool)
 {
 	assert(false);
 	return FColDsptr();
@@ -105,7 +105,7 @@ void LDUFullMat::decomposesaveOriginal(FMatDsptr fullMat, bool saveOriginal)
 	}
 }
 
-void LDUFullMat::decomposesaveOriginal(SpMatDsptr spMat, bool saveOriginal)
+void LDUFullMat::decomposesaveOriginal(SpMatDsptr, bool)
 {
 	assert(false);
 }