Beispiel #1
0
void testConvexRelaxations()
{
    DenseMatrix A(1,3);
    A << 1, 2, 3;

    DenseVector b(1);
    b(0) = 1;

    std::vector<VariablePtr> vars =
    {
        std::make_shared<Variable>(1,0,6),
        std::make_shared<Variable>(2,0,4),
        std::make_shared<Variable>(3,0,2)
    };

    ConstraintPtr lincon1 = std::make_shared<ConstraintLinear>(vars, A, b, true);

    A << 3, 2, 1;
    ConstraintPtr lincon2 = std::make_shared<ConstraintLinear>(vars, A, b, true);

    SPLINTER::DataTable data;
    data.addSample(0,0);
    data.addSample(0.5,0.5);
    data.addSample(1,1);

    SPLINTER::BSpline bs(data, SPLINTER::BSplineType::LINEAR);
    auto bsvars = {vars.at(0), vars.at(1)};
    ConstraintPtr bscon = std::make_shared<ConstraintBSpline>(bsvars, bs, true);

    ConstraintSetPtr cs = std::make_shared<ConstraintSet>();
    cs->add(lincon1);
    cs->add(lincon2);
    cs->add(bscon);

    cout << cs->getVariables() << endl;

    cout << "Relaxed" << endl;

    ConstraintPtr csr = cs->getConvexRelaxation();

    cout << csr->getVariables() << endl;
}
Beispiel #2
0
void testNewConstraintClasses()
{
    // Create some vars
    std::vector<VariablePtr> vars;

    for (int i = 0; i < 3; i++)
    {
        auto var = std::make_shared<Variable>(1, 0, i+1);
        vars.push_back(var);
        cout << *var << endl;
    }

    ConstraintSetPtr cs = std::make_shared<ConstraintSet>();

    DenseMatrix A = DenseMatrix::Zero(3,3);
    DenseVector b = DenseVector::Zero(3);
    b(0) = 0.5;

    A(0,0) = 1;
    ConstraintPtr lincon = std::make_shared<ConstraintLinear>(vars, A, b, true);

    A(1,1) = 2;
    ConstraintPtr lincon2 = std::make_shared<ConstraintLinear>(vars, A, b, true);

    A(2,2) = 3;
    ConstraintPtr lincon3 = std::make_shared<ConstraintLinear>(vars, A, b, true);

    cs->add(lincon);
    //cs->add(lincon2); // TODO: continue here tomorrow!
    //cs->add(lincon3);

    ConstraintSetPtr cs2 = std::make_shared<ConstraintSet>(*cs); // Shallow copy

    ConstraintSetPtr cs4 = std::make_shared<ConstraintSet>();
    cs4->add(cs); // Shallow copy

    ConstraintSetPtr cs5 = std::make_shared<ConstraintSet>(*cs, true); // Deep copy

    DenseVector x = DenseVector::Zero(3);
    x(0) = 1;
    x(1) = 1;
    x(2) = 1;

    DenseVector y;
    DenseVector dy;
    DenseVector ddy;

    {
        cout << "Evaluating cs" << endl;

        y = cs->eval(x);
        dy = cs->evalJacobian(x);
        ddy = cs->evalHessian(x);
        cout << "y:" << endl;
        cout << y << endl;
        cout << "dy" << endl;
        cout << dy << endl;
        cout << "ddy" << endl;
        cout << ddy << endl;
    }

    ConstraintPtr cs3 = cs->clone(); // Deep copy

    {
        cout << "Evaluating cs without x" << endl;

        std::vector<VariablePtr> vars = cs->getVariables();
        vars.at(0)->setValue(2);

        y = cs->eval();
        dy = cs->evalJacobian();
        ddy = cs->evalHessian();
        cout << "y:" << endl;
        cout << y << endl;
        cout << "dy" << endl;
        cout << dy << endl;
        cout << "ddy" << endl;
        cout << ddy << endl;
    }

    {
        cout << "Evaluating cs2 (shallow copy)." << endl;

        y = cs2->eval();
        dy = cs2->evalJacobian();
        ddy = cs2->evalHessian();
        cout << "y:" << endl;
        cout << y << endl;
        cout << "dy" << endl;
        cout << dy << endl;
        cout << "ddy" << endl;
        cout << ddy << endl;
    }

    {
        cout << "Evaluating cs3 (deep copy)." << endl;

        y = cs3->eval();
        dy = cs3->evalJacobian();
        ddy = cs3->evalHessian();
        cout << "y:" << endl;
        cout << y << endl;
        cout << "dy" << endl;
        cout << dy << endl;
        cout << "ddy" << endl;
        cout << ddy << endl;
    }

    {
        cout << "Evaluating cs4 (shallow composite)." << endl;

        y = cs4->eval();
        dy = cs4->evalJacobian();
        ddy = cs4->evalHessian();
        cout << "y:" << endl;
        cout << y << endl;
        cout << "dy" << endl;
        cout << dy << endl;
        cout << "ddy" << endl;
        cout << ddy << endl;

    }

    {
        cout << "Evaluating cs5 (deep copy)." << endl;

        y = cs5->eval();
        dy = cs5->evalJacobian();
        ddy = cs5->evalHessian();
        cout << "y:" << endl;
        cout << y << endl;
        cout << "dy" << endl;
        cout << dy << endl;
        cout << "ddy" << endl;
        cout << ddy << endl;
    }
}