598 lines
23 KiB
C++
598 lines
23 KiB
C++
// This file is part of libigl, a simple c++ geometry processing library.
|
|
//
|
|
// Copyright (C) 2016 Alec Jacobson <alecjacobson@gmail.com>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public License
|
|
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
|
|
// obtain one at http://mozilla.org/MPL/2.0/.
|
|
#include "min_quad_with_fixed.h"
|
|
|
|
#include "slice.h"
|
|
#include "is_symmetric.h"
|
|
#include "find.h"
|
|
#include "sparse.h"
|
|
#include "repmat.h"
|
|
#include "matlab_format.h"
|
|
#include "EPS.h"
|
|
#include "cat.h"
|
|
|
|
//#include <Eigen/SparseExtra>
|
|
// Bug in unsupported/Eigen/SparseExtra needs iostream first
|
|
#include <iostream>
|
|
#include <unsupported/Eigen/SparseExtra>
|
|
#include <cassert>
|
|
#include <cstdio>
|
|
#include <iostream>
|
|
|
|
template <typename T, typename Derivedknown>
|
|
IGL_INLINE bool igl::min_quad_with_fixed_precompute(
|
|
const Eigen::SparseMatrix<T>& A2,
|
|
const Eigen::MatrixBase<Derivedknown> & known,
|
|
const Eigen::SparseMatrix<T>& Aeq,
|
|
const bool pd,
|
|
min_quad_with_fixed_data<T> & data
|
|
)
|
|
{
|
|
//#define MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
using namespace Eigen;
|
|
using namespace std;
|
|
const Eigen::SparseMatrix<T> A = 0.5*A2;
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" pre"<<endl;
|
|
#endif
|
|
// number of rows
|
|
int n = A.rows();
|
|
// cache problem size
|
|
data.n = n;
|
|
|
|
int neq = Aeq.rows();
|
|
// default is to have 0 linear equality constraints
|
|
if(Aeq.size() != 0)
|
|
{
|
|
assert(n == Aeq.cols() && "#Aeq.cols() should match A.rows()");
|
|
}
|
|
|
|
assert(A.rows() == n && "A should be square");
|
|
assert(A.cols() == n && "A should be square");
|
|
|
|
// number of known rows
|
|
int kr = known.size();
|
|
|
|
assert((kr == 0 || known.minCoeff() >= 0)&& "known indices should be in [0,n)");
|
|
assert((kr == 0 || known.maxCoeff() < n) && "known indices should be in [0,n)");
|
|
assert(neq <= n && "Number of equality constraints should be less than DOFs");
|
|
|
|
|
|
// cache known
|
|
data.known = known;
|
|
// get list of unknown indices
|
|
data.unknown.resize(n-kr);
|
|
std::vector<bool> unknown_mask;
|
|
unknown_mask.resize(n,true);
|
|
for(int i = 0;i<kr;i++)
|
|
{
|
|
unknown_mask[known(i)] = false;
|
|
}
|
|
int u = 0;
|
|
for(int i = 0;i<n;i++)
|
|
{
|
|
if(unknown_mask[i])
|
|
{
|
|
data.unknown(u) = i;
|
|
u++;
|
|
}
|
|
}
|
|
// get list of lagrange multiplier indices
|
|
data.lagrange.resize(neq);
|
|
for(int i = 0;i<neq;i++)
|
|
{
|
|
data.lagrange(i) = n + i;
|
|
}
|
|
// cache unknown followed by lagrange indices
|
|
data.unknown_lagrange.resize(data.unknown.size()+data.lagrange.size());
|
|
// Would like to do:
|
|
//data.unknown_lagrange << data.unknown, data.lagrange;
|
|
// but Eigen can't handle empty vectors in comma initialization
|
|
// https://forum.kde.org/viewtopic.php?f=74&t=107974&p=364947#p364947
|
|
if(data.unknown.size() > 0)
|
|
{
|
|
data.unknown_lagrange.head(data.unknown.size()) = data.unknown;
|
|
}
|
|
if(data.lagrange.size() > 0)
|
|
{
|
|
data.unknown_lagrange.tail(data.lagrange.size()) = data.lagrange;
|
|
}
|
|
|
|
SparseMatrix<T> Auu;
|
|
slice(A,data.unknown,data.unknown,Auu);
|
|
assert(Auu.size() != 0 && Auu.rows() > 0 && "There should be at least one unknown.");
|
|
|
|
// Positive definiteness is *not* determined, rather it is given as a
|
|
// parameter
|
|
data.Auu_pd = pd;
|
|
if(data.Auu_pd)
|
|
{
|
|
// PD implies symmetric
|
|
data.Auu_sym = true;
|
|
// This is an annoying assertion unless EPS can be chosen in a nicer way.
|
|
//assert(is_symmetric(Auu,EPS<double>()));
|
|
assert(is_symmetric(Auu,1.0) &&
|
|
"Auu should be symmetric if positive definite");
|
|
}else
|
|
{
|
|
// determine if A(unknown,unknown) is symmetric and/or positive definite
|
|
VectorXi AuuI,AuuJ;
|
|
MatrixXd AuuV;
|
|
find(Auu,AuuI,AuuJ,AuuV);
|
|
data.Auu_sym = is_symmetric(Auu,EPS<double>()*AuuV.maxCoeff());
|
|
}
|
|
|
|
// Determine number of linearly independent constraints
|
|
int nc = 0;
|
|
if(neq>0)
|
|
{
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" qr"<<endl;
|
|
#endif
|
|
// QR decomposition to determine row rank in Aequ
|
|
slice(Aeq,data.unknown,2,data.Aequ);
|
|
assert(data.Aequ.rows() == neq &&
|
|
"#Rows in Aequ should match #constraints");
|
|
assert(data.Aequ.cols() == data.unknown.size() &&
|
|
"#cols in Aequ should match #unknowns");
|
|
data.AeqTQR.compute(data.Aequ.transpose().eval());
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<endl<<matlab_format(SparseMatrix<T>(data.Aequ.transpose().eval()),"AeqT")<<endl<<endl;
|
|
#endif
|
|
switch(data.AeqTQR.info())
|
|
{
|
|
case Eigen::Success:
|
|
break;
|
|
case Eigen::NumericalIssue:
|
|
cerr<<"Error: Numerical issue."<<endl;
|
|
return false;
|
|
case Eigen::InvalidInput:
|
|
cerr<<"Error: Invalid input."<<endl;
|
|
return false;
|
|
default:
|
|
cerr<<"Error: Other."<<endl;
|
|
return false;
|
|
}
|
|
nc = data.AeqTQR.rank();
|
|
assert(nc<=neq &&
|
|
"Rank of reduced constraints should be <= #original constraints");
|
|
data.Aeq_li = nc == neq;
|
|
//cout<<"data.Aeq_li: "<<data.Aeq_li<<endl;
|
|
}else
|
|
{
|
|
data.Aeq_li = true;
|
|
}
|
|
|
|
if(data.Aeq_li)
|
|
{
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" Aeq_li=true"<<endl;
|
|
#endif
|
|
// Append lagrange multiplier quadratic terms
|
|
SparseMatrix<T> new_A;
|
|
SparseMatrix<T> AeqT = Aeq.transpose();
|
|
SparseMatrix<T> Z(neq,neq);
|
|
// This is a bit slower. But why isn't cat fast?
|
|
new_A = cat(1, cat(2, A, AeqT ),
|
|
cat(2, Aeq, Z ));
|
|
|
|
// precompute RHS builders
|
|
if(kr > 0)
|
|
{
|
|
SparseMatrix<T> Aulk,Akul;
|
|
// Slow
|
|
slice(new_A,data.unknown_lagrange,data.known,Aulk);
|
|
//// This doesn't work!!!
|
|
//data.preY = Aulk + Akul.transpose();
|
|
// Slow
|
|
if(data.Auu_sym)
|
|
{
|
|
data.preY = Aulk*2;
|
|
}else
|
|
{
|
|
slice(new_A,data.known,data.unknown_lagrange,Akul);
|
|
SparseMatrix<T> AkulT = Akul.transpose();
|
|
data.preY = Aulk + AkulT;
|
|
}
|
|
}else
|
|
{
|
|
data.preY.resize(data.unknown_lagrange.size(),0);
|
|
}
|
|
|
|
// Positive definite and no equality constraints (Positive definiteness
|
|
// implies symmetric)
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" factorize"<<endl;
|
|
#endif
|
|
if(data.Auu_pd && neq == 0)
|
|
{
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" llt"<<endl;
|
|
#endif
|
|
data.llt.compute(Auu);
|
|
switch(data.llt.info())
|
|
{
|
|
case Eigen::Success:
|
|
break;
|
|
case Eigen::NumericalIssue:
|
|
cerr<<"Error: Numerical issue."<<endl;
|
|
return false;
|
|
default:
|
|
cerr<<"Error: Other."<<endl;
|
|
return false;
|
|
}
|
|
data.solver_type = min_quad_with_fixed_data<T>::LLT;
|
|
}else
|
|
{
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" ldlt"<<endl;
|
|
#endif
|
|
// Either not PD or there are equality constraints
|
|
SparseMatrix<T> NA;
|
|
slice(new_A,data.unknown_lagrange,data.unknown_lagrange,NA);
|
|
data.NA = NA;
|
|
// Ideally we'd use LDLT but Eigen doesn't support positive semi-definite
|
|
// matrices:
|
|
// http://forum.kde.org/viewtopic.php?f=74&t=106962&p=291990#p291990
|
|
if(data.Auu_sym && false)
|
|
{
|
|
data.ldlt.compute(NA);
|
|
switch(data.ldlt.info())
|
|
{
|
|
case Eigen::Success:
|
|
break;
|
|
case Eigen::NumericalIssue:
|
|
cerr<<"Error: Numerical issue."<<endl;
|
|
return false;
|
|
default:
|
|
cerr<<"Error: Other."<<endl;
|
|
return false;
|
|
}
|
|
data.solver_type = min_quad_with_fixed_data<T>::LDLT;
|
|
}else
|
|
{
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" lu"<<endl;
|
|
#endif
|
|
// Resort to LU
|
|
// Bottleneck >1/2
|
|
data.lu.compute(NA);
|
|
//std::cout<<"NA=["<<std::endl<<NA<<std::endl<<"];"<<std::endl;
|
|
switch(data.lu.info())
|
|
{
|
|
case Eigen::Success:
|
|
break;
|
|
case Eigen::NumericalIssue:
|
|
cerr<<"Error: Numerical issue."<<endl;
|
|
return false;
|
|
case Eigen::InvalidInput:
|
|
cerr<<"Error: Invalid Input."<<endl;
|
|
return false;
|
|
default:
|
|
cerr<<"Error: Other."<<endl;
|
|
return false;
|
|
}
|
|
data.solver_type = min_quad_with_fixed_data<T>::LU;
|
|
}
|
|
}
|
|
}else
|
|
{
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" Aeq_li=false"<<endl;
|
|
#endif
|
|
data.neq = neq;
|
|
const int nu = data.unknown.size();
|
|
//cout<<"nu: "<<nu<<endl;
|
|
//cout<<"neq: "<<neq<<endl;
|
|
//cout<<"nc: "<<nc<<endl;
|
|
//cout<<" matrixR"<<endl;
|
|
SparseMatrix<T> AeqTR,AeqTQ;
|
|
AeqTR = data.AeqTQR.matrixR();
|
|
// This shouldn't be necessary
|
|
AeqTR.prune(0.0);
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" matrixQ"<<endl;
|
|
#endif
|
|
// THIS IS ESSENTIALLY DENSE AND THIS IS BY FAR THE BOTTLENECK
|
|
// http://forum.kde.org/viewtopic.php?f=74&t=117500
|
|
AeqTQ = data.AeqTQR.matrixQ();
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" prune"<<endl;
|
|
cout<<" nnz: "<<AeqTQ.nonZeros()<<endl;
|
|
#endif
|
|
// This shouldn't be necessary
|
|
AeqTQ.prune(0.0);
|
|
//cout<<"AeqTQ: "<<AeqTQ.rows()<<" "<<AeqTQ.cols()<<endl;
|
|
//cout<<matlab_format(AeqTQ,"AeqTQ")<<endl;
|
|
//cout<<" perms"<<endl;
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" nnz: "<<AeqTQ.nonZeros()<<endl;
|
|
cout<<" perm"<<endl;
|
|
#endif
|
|
SparseMatrix<double> I(neq,neq);
|
|
I.setIdentity();
|
|
data.AeqTE = data.AeqTQR.colsPermutation() * I;
|
|
data.AeqTET = data.AeqTQR.colsPermutation().transpose() * I;
|
|
assert(AeqTR.rows() == nu && "#rows in AeqTR should match #unknowns");
|
|
assert(AeqTR.cols() == neq && "#cols in AeqTR should match #constraints");
|
|
assert(AeqTQ.rows() == nu && "#rows in AeqTQ should match #unknowns");
|
|
assert(AeqTQ.cols() == nu && "#cols in AeqTQ should match #unknowns");
|
|
//cout<<" slice"<<endl;
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" slice"<<endl;
|
|
#endif
|
|
data.AeqTQ1 = AeqTQ.topLeftCorner(nu,nc);
|
|
data.AeqTQ1T = data.AeqTQ1.transpose().eval();
|
|
// ALREADY TRIM (Not 100% sure about this)
|
|
data.AeqTR1 = AeqTR.topLeftCorner(nc,nc);
|
|
data.AeqTR1T = data.AeqTR1.transpose().eval();
|
|
//cout<<"AeqTR1T.size() "<<data.AeqTR1T.rows()<<" "<<data.AeqTR1T.cols()<<endl;
|
|
// Null space
|
|
data.AeqTQ2 = AeqTQ.bottomRightCorner(nu,nu-nc);
|
|
data.AeqTQ2T = data.AeqTQ2.transpose().eval();
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" proj"<<endl;
|
|
#endif
|
|
// Projected hessian
|
|
SparseMatrix<T> QRAuu = data.AeqTQ2T * Auu * data.AeqTQ2;
|
|
{
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" factorize"<<endl;
|
|
#endif
|
|
// QRAuu should always be PD
|
|
data.llt.compute(QRAuu);
|
|
switch(data.llt.info())
|
|
{
|
|
case Eigen::Success:
|
|
break;
|
|
case Eigen::NumericalIssue:
|
|
cerr<<"Error: Numerical issue."<<endl;
|
|
return false;
|
|
default:
|
|
cerr<<"Error: Other."<<endl;
|
|
return false;
|
|
}
|
|
data.solver_type = min_quad_with_fixed_data<T>::QR_LLT;
|
|
}
|
|
#ifdef MIN_QUAD_WITH_FIXED_CPP_DEBUG
|
|
cout<<" smash"<<endl;
|
|
#endif
|
|
// Known value multiplier
|
|
SparseMatrix<T> Auk;
|
|
slice(A,data.unknown,data.known,Auk);
|
|
SparseMatrix<T> Aku;
|
|
slice(A,data.known,data.unknown,Aku);
|
|
SparseMatrix<T> AkuT = Aku.transpose();
|
|
data.preY = Auk + AkuT;
|
|
// Needed during solve
|
|
data.Auu = Auu;
|
|
slice(Aeq,data.known,2,data.Aeqk);
|
|
assert(data.Aeqk.rows() == neq);
|
|
assert(data.Aeqk.cols() == data.known.size());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
template <
|
|
typename T,
|
|
typename DerivedB,
|
|
typename DerivedY,
|
|
typename DerivedBeq,
|
|
typename DerivedZ,
|
|
typename Derivedsol>
|
|
IGL_INLINE bool igl::min_quad_with_fixed_solve(
|
|
const min_quad_with_fixed_data<T> & data,
|
|
const Eigen::MatrixBase<DerivedB> & B,
|
|
const Eigen::MatrixBase<DerivedY> & Y,
|
|
const Eigen::MatrixBase<DerivedBeq> & Beq,
|
|
Eigen::PlainObjectBase<DerivedZ> & Z,
|
|
Eigen::PlainObjectBase<Derivedsol> & sol)
|
|
{
|
|
using namespace std;
|
|
using namespace Eigen;
|
|
typedef Matrix<T,Dynamic,1> VectorXT;
|
|
typedef Matrix<T,Dynamic,Dynamic> MatrixXT;
|
|
// number of known rows
|
|
int kr = data.known.size();
|
|
if(kr!=0)
|
|
{
|
|
assert(kr == Y.rows());
|
|
}
|
|
// number of columns to solve
|
|
int cols = Y.cols();
|
|
assert(B.cols() == 1 || B.cols() == cols);
|
|
assert(Beq.size() == 0 || Beq.cols() == 1 || Beq.cols() == cols);
|
|
|
|
// resize output
|
|
Z.resize(data.n,cols);
|
|
// Set known values
|
|
for(int i = 0;i < kr;i++)
|
|
{
|
|
for(int j = 0;j < cols;j++)
|
|
{
|
|
Z(data.known(i),j) = Y(i,j);
|
|
}
|
|
}
|
|
|
|
if(data.Aeq_li)
|
|
{
|
|
// number of lagrange multipliers aka linear equality constraints
|
|
int neq = data.lagrange.size();
|
|
// append lagrange multiplier rhs's
|
|
MatrixXT BBeq(B.rows() + Beq.rows(),cols);
|
|
if(B.size() > 0)
|
|
{
|
|
BBeq.topLeftCorner(B.rows(),cols) = B.replicate(1,B.cols()==cols?1:cols);
|
|
}
|
|
if(Beq.size() > 0)
|
|
{
|
|
BBeq.bottomLeftCorner(Beq.rows(),cols) = -2.0*Beq.replicate(1,Beq.cols()==cols?1:cols);
|
|
}
|
|
|
|
// Build right hand side
|
|
MatrixXT BBequlcols;
|
|
igl::slice(BBeq,data.unknown_lagrange,1,BBequlcols);
|
|
MatrixXT NB;
|
|
if(kr == 0)
|
|
{
|
|
NB = BBequlcols;
|
|
}else
|
|
{
|
|
NB = data.preY * Y + BBequlcols;
|
|
}
|
|
|
|
//std::cout<<"NB=["<<std::endl<<NB<<std::endl<<"];"<<std::endl;
|
|
//cout<<matlab_format(NB,"NB")<<endl;
|
|
switch(data.solver_type)
|
|
{
|
|
case igl::min_quad_with_fixed_data<T>::LLT:
|
|
sol = data.llt.solve(NB);
|
|
break;
|
|
case igl::min_quad_with_fixed_data<T>::LDLT:
|
|
sol = data.ldlt.solve(NB);
|
|
break;
|
|
case igl::min_quad_with_fixed_data<T>::LU:
|
|
// Not a bottleneck
|
|
sol = data.lu.solve(NB);
|
|
break;
|
|
default:
|
|
cerr<<"Error: invalid solver type"<<endl;
|
|
return false;
|
|
}
|
|
//std::cout<<"sol=["<<std::endl<<sol<<std::endl<<"];"<<std::endl;
|
|
// Now sol contains sol/-0.5
|
|
sol *= -0.5;
|
|
// Now sol contains solution
|
|
// Place solution in Z
|
|
for(int i = 0;i<(sol.rows()-neq);i++)
|
|
{
|
|
for(int j = 0;j<sol.cols();j++)
|
|
{
|
|
Z(data.unknown_lagrange(i),j) = sol(i,j);
|
|
}
|
|
}
|
|
}else
|
|
{
|
|
assert(data.solver_type == min_quad_with_fixed_data<T>::QR_LLT);
|
|
MatrixXT eff_Beq;
|
|
// Adjust Aeq rhs to include known parts
|
|
eff_Beq =
|
|
//data.AeqTQR.colsPermutation().transpose() * (-data.Aeqk * Y + Beq);
|
|
data.AeqTET * (-data.Aeqk * Y + Beq.replicate(1,Beq.cols()==cols?1:cols));
|
|
// Where did this -0.5 come from? Probably the same place as above.
|
|
MatrixXT Bu;
|
|
slice(B,data.unknown,1,Bu);
|
|
MatrixXT NB;
|
|
NB = -0.5*(Bu.replicate(1,B.cols()==cols?1:cols) + data.preY * Y);
|
|
// Trim eff_Beq
|
|
const int nc = data.AeqTQR.rank();
|
|
const int neq = Beq.rows();
|
|
eff_Beq = eff_Beq.topLeftCorner(nc,cols).eval();
|
|
data.AeqTR1T.template triangularView<Lower>().solveInPlace(eff_Beq);
|
|
// Now eff_Beq = (data.AeqTR1T \ (data.AeqTET * (-data.Aeqk * Y + Beq)))
|
|
MatrixXT lambda_0;
|
|
lambda_0 = data.AeqTQ1 * eff_Beq;
|
|
//cout<<matlab_format(lambda_0,"lambda_0")<<endl;
|
|
MatrixXT QRB;
|
|
QRB = -data.AeqTQ2T * (data.Auu * lambda_0) + data.AeqTQ2T * NB;
|
|
Derivedsol lambda;
|
|
lambda = data.llt.solve(QRB);
|
|
// prepare output
|
|
Derivedsol solu;
|
|
solu = data.AeqTQ2 * lambda + lambda_0;
|
|
// http://www.math.uh.edu/~rohop/fall_06/Chapter3.pdf
|
|
Derivedsol solLambda;
|
|
{
|
|
Derivedsol temp1,temp2;
|
|
temp1 = (data.AeqTQ1T * NB - data.AeqTQ1T * data.Auu * solu);
|
|
data.AeqTR1.template triangularView<Upper>().solveInPlace(temp1);
|
|
//cout<<matlab_format(temp1,"temp1")<<endl;
|
|
temp2 = Derivedsol::Zero(neq,cols);
|
|
temp2.topLeftCorner(nc,cols) = temp1;
|
|
//solLambda = data.AeqTQR.colsPermutation() * temp2;
|
|
solLambda = data.AeqTE * temp2;
|
|
}
|
|
// sol is [Z(unknown);Lambda]
|
|
assert(data.unknown.size() == solu.rows());
|
|
assert(cols == solu.cols());
|
|
assert(data.neq == neq);
|
|
assert(data.neq == solLambda.rows());
|
|
assert(cols == solLambda.cols());
|
|
sol.resize(data.unknown.size()+data.neq,cols);
|
|
sol.block(0,0,solu.rows(),solu.cols()) = solu;
|
|
sol.block(solu.rows(),0,solLambda.rows(),solLambda.cols()) = solLambda;
|
|
for(int u = 0;u<data.unknown.size();u++)
|
|
{
|
|
for(int j = 0;j<Z.cols();j++)
|
|
{
|
|
Z(data.unknown(u),j) = solu(u,j);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <
|
|
typename T,
|
|
typename DerivedB,
|
|
typename DerivedY,
|
|
typename DerivedBeq,
|
|
typename DerivedZ>
|
|
IGL_INLINE bool igl::min_quad_with_fixed_solve(
|
|
const min_quad_with_fixed_data<T> & data,
|
|
const Eigen::MatrixBase<DerivedB> & B,
|
|
const Eigen::MatrixBase<DerivedY> & Y,
|
|
const Eigen::MatrixBase<DerivedBeq> & Beq,
|
|
Eigen::PlainObjectBase<DerivedZ> & Z)
|
|
{
|
|
Eigen::Matrix<typename DerivedZ::Scalar, Eigen::Dynamic, Eigen::Dynamic> sol;
|
|
return min_quad_with_fixed_solve(data,B,Y,Beq,Z,sol);
|
|
}
|
|
|
|
template <
|
|
typename T,
|
|
typename Derivedknown,
|
|
typename DerivedB,
|
|
typename DerivedY,
|
|
typename DerivedBeq,
|
|
typename DerivedZ>
|
|
IGL_INLINE bool igl::min_quad_with_fixed(
|
|
const Eigen::SparseMatrix<T>& A,
|
|
const Eigen::MatrixBase<DerivedB> & B,
|
|
const Eigen::MatrixBase<Derivedknown> & known,
|
|
const Eigen::MatrixBase<DerivedY> & Y,
|
|
const Eigen::SparseMatrix<T>& Aeq,
|
|
const Eigen::MatrixBase<DerivedBeq> & Beq,
|
|
const bool pd,
|
|
Eigen::PlainObjectBase<DerivedZ> & Z)
|
|
{
|
|
min_quad_with_fixed_data<T> data;
|
|
if(!min_quad_with_fixed_precompute(A,known,Aeq,pd,data))
|
|
{
|
|
return false;
|
|
}
|
|
return min_quad_with_fixed_solve(data,B,Y,Beq,Z);
|
|
}
|
|
|
|
#ifdef IGL_STATIC_LIBRARY
|
|
// Explicit template instantiation
|
|
// generated by autoexplicit.sh
|
|
template bool igl::min_quad_with_fixed<double, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::SparseMatrix<double, 0, int> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::SparseMatrix<double, 0, int> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, bool, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
|
|
template bool igl::min_quad_with_fixed_solve<double, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1> >(igl::min_quad_with_fixed_data<double> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&);
|
|
template bool igl::min_quad_with_fixed_precompute<double, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::SparseMatrix<double, 0, int> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> > const&, Eigen::SparseMatrix<double, 0, int> const&, bool, igl::min_quad_with_fixed_data<double>&);
|
|
template bool igl::min_quad_with_fixed_solve<double, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1> >(igl::min_quad_with_fixed_data<double> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&);
|
|
template bool igl::min_quad_with_fixed_solve<double, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(igl::min_quad_with_fixed_data<double> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
|
|
template bool igl::min_quad_with_fixed_precompute<double, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::SparseMatrix<double, 0, int> const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::SparseMatrix<double, 0, int> const&, bool, igl::min_quad_with_fixed_data<double>&);
|
|
template bool igl::min_quad_with_fixed_solve<double, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(igl::min_quad_with_fixed_data<double> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
|
|
template bool igl::min_quad_with_fixed_solve<double, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(igl::min_quad_with_fixed_data<double> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
|
|
template bool igl::min_quad_with_fixed_solve<double, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(igl::min_quad_with_fixed_data<double> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
|
|
template bool igl::min_quad_with_fixed_solve<double, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(igl::min_quad_with_fixed_data<double> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
|
|
template bool igl::min_quad_with_fixed<double, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::SparseMatrix<double, 0, int> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::SparseMatrix<double, 0, int> const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, bool, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&);
|
|
#endif
|