Function tiny_set_tv_linear_constraints

src/tinympc/tiny_api.cpp:254–304

}

int tiny_set_tv_linear_constraints(TinySolver* solver,
                               tinyMatrix tv_Alin_x, tinyMatrix tv_blin_x,
                               tinyMatrix tv_Alin_u, tinyMatrix tv_blin_u) {
    if (!solver) {
        std::cout << "Error in tiny_set_linear_constraints: solver is nullptr" << std::endl;
        return 1;
    }

    // Make sure all linear constraint matrix sizes are self-consistent
    int num_tv_state_linear = tv_Alin_x.rows() / solver->work->N;
    int num_tv_input_linear = tv_Alin_u.rows() / (solver->work->N-1);
    int status = 0;
    
    // Check state constraint dimensions
    if (num_tv_state_linear > 0) {
        status |= check_dimension("State time-varying linear constraint matrix (tv_Alin_x)", "rows", 
                                                    tv_Alin_x.rows(), num_tv_state_linear * solver->work->N);
        status |= check_dimension("State time-varying linear constraint matrix (tv_Alin_x)", "columns", 
                                                    tv_Alin_x.cols(), solver->work->nx);
        status |= check_dimension("State time-varying linear constraint vector (tv_blin_x)", "rows", 
                                                    tv_blin_x.rows(), num_tv_state_linear);
        status |= check_dimension("State time-varying linear constraint vector (tv_blin_x)", "columns", 
                                                    tv_blin_x.cols(), solver->work->N);
    }
    
    // Check input constraint dimensions
    if (num_tv_input_linear > 0) {
        status |= check_dimension("Input time-varying linear constraint matrix (tv_Alin_u)", "rows", 
                                                tv_Alin_u.rows(), num_tv_input_linear * (solver->work->N-1));
        status |= check_dimension("Input time-varying linear constraint matrix (tv_Alin_u)", "columns", 
                                                tv_Alin_u.cols(), solver->work->nu);
        status |= check_dimension("Input time-varying linear constraint vector (tv_blin_u)", "rows", 
                                                tv_blin_u.rows(), num_tv_input_linear);
        status |= check_dimension("Input time-varying linear constraint vector (tv_blin_u)", "columns", 
                                                tv_blin_u.cols(), solver->work->N-1);
    }
    
    if (status) {
        return status;
    }

    solver->work->numtvStateLinear = num_tv_state_linear;
    solver->work->numtvInputLinear = num_tv_input_linear;

    solver->work->tv_Alin_x = tv_Alin_x;
    solver->work->tv_blin_x = tv_blin_x;
    solver->work->tv_Alin_u = tv_Alin_u;
    solver->work->tv_blin_u = tv_blin_u;

    return 0;
}


int tiny_precompute_and_set_cache(TinyCache *cache,