// virtual
Matrix* NominalToCategorical::filterLabels(Matrix& labels)
{
if(labels.cols() != 1)
ThrowError("unexpected number of label dims");
Matrix* pOut = new Matrix();
pOut->setSize(0, m_labelVals);
if(m_labelVals == 1)
{
for(size_t i = 0; i < labels.rows(); i++)
{
vector<double> row;
row.push_back(labels[i][0]);
pOut->copyRow(row);
}
}
else
{
for(size_t i = 0; i < labels.rows(); i++)
{
vector<double> row;
row.resize(m_labelVals, 0.0);
row[(size_t)labels[i][0]] = 1.0;
pOut->copyRow(row);
}
}
return pOut;
}
virtual void Jacobian(const Vector& x,Matrix& J) {
J.resize(1,x.n);
Vector Ji(3);
Real len = Sqrt(Sqr(x[1])+Sqr(x[0]));
if(FuzzyZero(len)) Ji.setZero();
else {
Real xc = x[0]*primaryRadius/len;
Real yc = x[1]*primaryRadius/len;
Real dlend0 = x[0]/len;
Real dlend1 = x[1]/len;
//derivative of xc w.r.t. x[0], x[1]
Real dxcd0 = (len*primaryRadius - x[0]*primaryRadius*dlend0)/Sqr(len);
Real dxcd1 = -x[0]*primaryRadius*dlend1/Sqr(len);
//derivative of yc w.r.t. x[0], x[1]
Real dycd0 = -x[1]*primaryRadius*dlend0/Sqr(len);
Real dycd1 = (len*primaryRadius - x[1]*primaryRadius*dlend1)/Sqr(len);
Ji[0] = 2.0*(x[0]-xc)*(1-dxcd0) - 2.0*(x[1]-yc)*dycd0;
Ji[1] = -2.0*(x[0]-xc)*dxcd1 + 2.0*(x[1]-yc)*(1-dycd1);
Ji[2] = 2*x[2];
}
J.copyRow(0,Ji);
/*
//TEMP: debugging
Matrix Jdiff(1,3);
Vector temp=x;
JacobianCenteredDifference(*this,temp,0.001,Jdiff);
if(!Jdiff.isEqual(J,1e-2)) {
cout<<"Jacobian error at "<<x<<endl;
cout<<Ji<<endl;
cout<<Jdiff<<endl;
}
Assert(Jdiff.isEqual(J,1e-2));
*/
}
virtual void Jacobian(const Vector& x,Matrix& J) {
J.resize(1,x.n);
Vector Ji = x;
Ji(0) = Mod(x[0]+1.5,3.0)-1.5;
Ji *= 2;
J.copyRow(0,Ji);
}
Matrix* Normalize::filterFeatures(Matrix& features)
{
Matrix* pOut = new Matrix(features);
for(size_t i = 0; i < features.rows(); i++)
{
vector<double> row = filterFeatures(features[i]);
pOut->copyRow(row);
}
return pOut;
}
Matrix* Discretize::filterFeatures(Matrix& features)
{
Matrix* pOut = new Matrix(features);
pOut->makeContinuousAttrsNominal(m_bins);
for(size_t i = 0; i < features.rows(); i++)
{
vector<double> row = filterFeatures(features[i]);
pOut->copyRow(row);
}
return pOut;
}
Matrix* NominalToCategorical::filterFeatures(Matrix& features)
{
Matrix* pOut = new Matrix();
pOut->setSize(0, m_totalFeatureVals);
for(size_t i = 0; i < features.rows(); i++)
{
vector<double> row = filterFeatures(features[i]);
pOut->copyRow(row);
}
return pOut;
}
// virtual
Matrix* Normalize::filterLabels(Matrix& labels)
{
Matrix* pOut = new Matrix(labels);
for(size_t i = 0; i < labels.rows(); i++)
{
vector<double> row;
if(m_labelMin == UNKNOWN_VALUE) // if the attribute is nominal...
row.push_back(labels[i][0]);
else
row.push_back((labels[i][0] - m_labelMin) / std::max(1e-12, m_labelMax - m_labelMin));
pOut->copyRow(row);
}
return pOut;
}
virtual void Jacobian(const Vector& x,Matrix& J) {
J.resize(1,x.n);
Vector Ji = x;
Ji *= 2;
J.copyRow(0,Ji);
}
bool LP_InteriorPoint::Set(const LinearProgram& lp)
{
Matrix Aeq;
Vector beq;
int neq=0,nineq=0;
for(int i=0;i<lp.A.m;i++) {
if(lp.ConstraintType(i) == LinearProgram::Fixed) neq++;
else {
if(lp.HasLowerBound(lp.ConstraintType(i))) nineq++;
if(lp.HasUpperBound(lp.ConstraintType(i))) nineq++;
}
}
for(int i=0;i<lp.A.n;i++) {
if(lp.VariableType(i) == LinearProgram::Fixed) neq++;
else {
if(lp.HasLowerBound(lp.VariableType(i))) nineq++;
if(lp.HasUpperBound(lp.VariableType(i))) nineq++;
}
}
if(neq == 0) {
x0.clear();
N.clear();
((LinearProgram&)solver) = lp;
//solver.minimize is ignored by the solver
if(!solver.minimize) solver.c.inplaceNegative();
return true;
}
Aeq.resize(neq,lp.A.n);
beq.resize(neq);
neq=0;
for(int i=0;i<lp.A.m;i++) {
if(lp.ConstraintType(i)==LinearProgram::Fixed)
{
Vector Ai;
lp.A.getRowRef(i,Ai);
Aeq.copyRow(neq,Ai);
beq(neq) = lp.p(i);
neq++;
}
}
for (int i=0;i<lp.A.n;i++) {
if(lp.VariableType(i)==LinearProgram::Fixed)
{
Vector Aeqi;
Aeq.getRowRef(i,Aeqi);
Aeqi.setZero();
Aeqi(i) = One;
beq(neq) = lp.l(i);
neq++;
}
}
SVDecomposition<Real> svd;
if(!svd.set(Aeq)) {
if(solver.verbose>=1) cout<<"LP_InteriorPoint: Couldn't set SVD of equality constraints!!!"<<endl;
return false;
}
svd.backSub(beq,x0);
svd.getNullspace(N);
//Set the solver to use the new variable y
if(N.n == 0) { //overconstrained!
cout<<"Overconstrained!"<<endl;
solver.Resize(0,0);
return true;
}
if(nineq == 0) {
cout<<"No inequalities!"<<endl;
abort();
return true;
}
if(solver.verbose >= 1) cout<<"LP_InteriorPoint: Decomposed the problem from "<<lp.A.n<<" to "<<N.n<<" variables"<<endl;
solver.Resize(nineq,N.n);
//objective
foffset = dot(lp.c,x0);
//c is such that c'*y = lp.c'*N*y => c = N'*lp.c
N.mulTranspose(lp.c,solver.c);
solver.minimize = lp.minimize;
if(!solver.minimize) solver.c.inplaceNegative();
//inequality constraints
//q <= Aineq*x <= p
//q <= Aineq*x0 + Aineq*N*y <= p
//q - Aineq*x0 <= Aineq*N*y <= p-Aineq*x0
//==> -Aineq*N*y <= -q + Aineq*x0
nineq=0;
for(int i=0;i<lp.A.m;i++) {
if(lp.ConstraintType(i)==LinearProgram::Fixed) continue;
if(lp.HasUpperBound(lp.ConstraintType(i))) {
Vector Ai,sAi;
lp.A.getRowRef(i,Ai);
solver.A.getRowRef(nineq,sAi);
N.mulTranspose(Ai,sAi);
solver.p(nineq) = lp.p(i) - dot(Ai,x0);
nineq++;
}
if(lp.HasLowerBound(lp.ConstraintType(i))) {
Vector Ai,sAi;
lp.A.getRowRef(i,Ai);
solver.A.getRowRef(nineq,sAi);
N.mulTranspose(Ai,sAi);
sAi.inplaceNegative();
solver.p(nineq) = dot(Ai,x0) - lp.q(i);
nineq++;
}
}
//transform bounds to inequality constraints
for(int i=0;i<lp.u.n;i++) {
if(lp.VariableType(i)==LinearProgram::Fixed) continue;
if(lp.HasLowerBound(lp.VariableType(i))) {
//-xi < -li
//-ei'*N*y <= -li+ei'*x0
Vector Ni,sAi;
N.getRowRef(i,Ni);
solver.A.getRowRef(nineq,sAi);
sAi.setNegative(Ni);
solver.p(nineq) = -lp.l(i) + x0(i);
nineq++;
}
if(lp.HasUpperBound(lp.VariableType(i))) {
//xi < ui
//ei'*N*y <= ui-ei'*x0
Vector Ni,sAi;
N.getRowRef(i,Ni);
solver.A.getRowRef(nineq,sAi);
sAi.copy(Ni);
solver.p(nineq) = lp.u(i) - x0(i);
nineq++;
}
}
Assert(solver.IsValid());
return true;
}
