vec sem::update_d(double tol, int max_iter)
{
int i;
double conv_crit = 1.0;
int counter = 0;
double old_obj, new_obj;
new_obj = get_objective();
//pre-allocate memory for gradient, hessian and update
vec grad(v_ + gamma_indices_.n_elem);
mat hessian(v_ + gamma_indices_.n_elem, v_ + gamma_indices_.n_elem);
vec update(v_ + gamma_indices_.n_elem);
while(conv_crit > tol && counter < max_iter) {
old_obj = new_obj;
// build in backtracking if necessary
set_gradient_hessian(grad, hessian);
update = join_cols(lambda_, gamma_) - solve(hessian, grad);
lambda_ = update(0, v_ - 1);
gamma_ = update(v_, v_ + gamma_indices_.n_elem);
new_obj = get_objective();
conv_crit = fabs((new_obj - old_obj)/old_obj);
counter++;
}
}
Solution LpsolveAdaptator::getSolution(lprec * lp) {
Solution sol = Solution();
REAL row[get_Norig_columns(lp)];
#ifdef DEBUG
set_verbose(lp, NORMAL);
write_LP(lp, stdout);
#else
set_verbose(lp, CRITICAL);
#endif
solve(lp);
// WARNING possible conversion failure from double to float
sol.setZ(get_objective(lp));
get_variables(lp, row);
#ifdef DEBUG
for(int j = 0; j < get_Norig_columns(lp); j++) {
printf("%s: %f\n", get_col_name(lp, j + 1), row[j]);
}
#endif
for (int i = 0; i < get_Norig_columns(lp); i++) {
double var_value = (double)row[i];
sol.addVariable(var_value);
}
delete_lp(lp);
return sol;
}
int main( ) {
double x[state_dim+1];
double objective[state_dim+1] = {0, -2.5, -5.0, -3.4};
double ieq_coeff[ieq_dim] = {425, 400, 600};
double ieq_matrix[ieq_dim][state_dim+1]
= {{0,2,10,4}, {0,6,5,8}, {0, 7, 10, 8}};
double eq_coeff[eq_dim]; // = {30};
double eq_matrix[eq_dim][state_dim+1];
//
lprec *lp;
//
lp = make_lp(eq_dim+ieq_dim, state_dim);
set_obj_fn (lp, objective);
for(int i=0; i<ieq_dim; i++) {
add_constraint( lp, ieq_matrix[i], LE, ieq_coeff[i] );
}
for(int i=0; i<eq_dim; i++) {
add_constraint( lp, eq_matrix[i], EQ, eq_coeff[i] );
}
//
set_verbose(lp, 0);
set_presolve(lp, PRESOLVE_ROWS | PRESOLVE_COLS | PRESOLVE_LINDEP, get_presolveloops(lp));
solve(lp);
//
std::cout << "f : " << get_objective(lp) << std::endl;
std::cout << "x :" ;
double col0 = get_Norig_columns(lp);
double row0 = get_Norig_rows(lp);
for(int i = 1; i <= col0; i++) {
double _x = get_var_primalresult(lp, row0 + i);
std::cout << " " << _x ;
}
std::cout << std::endl;
}
bool podem::podem_recursive(timeout &time_limit)
{
if (time_limit.is_expired())
throw timeout_exception();
if(is_fault_detected())
{
return true;
}
else
{
if(x_path_check())
{
gate_value objective = get_objective();
//std::cout << "Objective: " << objective.first << " " << simulation_value::strings[objective.second] << std::endl;
gate_value pi = backtrace(objective);
if(pi.first.empty())
{
return false;
}
//std::cout << "PI: " << pi.first << " " << simulation_value::strings[pi.second] << std::endl;
imply(pi);
if(podem_recursive(time_limit))
{
return true;
}
pi.second = simulation_value::inverse_simulation_value(pi.second);
imply(pi);
if(podem_recursive(time_limit))
{
return true;
}
pi.second = simulation_value::X;
imply(pi);
return false;
}
else
{
//std::cout << "X path check is false" << std::endl;
return false;
}
}
}
double __declspec(dllexport) WINAPI _get_objective(lprec *lp)
{
double ret;
if (lp != NULL) {
freebuferror();
ret = get_objective(lp);
}
else
ret = 0;
return(ret);
}
std::optional<Vector> LP::solve(const size_t variables, double * objective) {
auto lp = pimpl_->lp_.get();
// lp_solve uses the result of the previous runs to bootstrap
// the new solution. Sometimes this breaks down for some reason,
// so we just avoid it - it does not really even give a performance
// boost..
default_basis(lp);
// print_lp(pimpl_->lp_.get());
const auto result = ::solve(lp);
REAL * vp;
get_ptr_variables(lp, &vp);
if (objective)
*objective = get_objective(lp);
std::optional<Vector> solution;
if ( result == 0 || result == 1 )
solution = Eigen::Map<Vector>(vp, variables);
return solution;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
const mwSize* dims;
char* CtC_err, *Ctd_err;
nargout = nlhs;
mxAssert(nrhs==4,"Expects four input arguments.\n");
mxAssert(mxIsDouble(prhs[0]), "CtC_all must be a double array.\n");
CtC_err = "CtC must be num_bases x num_bases x patch_M x patch_N.\n";
CtC_all = prhs[0];
dims = mxGetDimensions(CtC_all);
num_bases = inv_tri(dims[0]);
patch_M = 2*(dims[1]-1);
if (mxGetNumberOfDimensions(CtC_all)==3){
patch_N = dims[2];
} else {
patch_N = 1;
}
CtC_allr = mxGetPr(CtC_all);
if (mxIsComplex(CtC_all)){
CtC_alli = mxGetPi(CtC_all);
}
mxAssert(mxIsDouble(prhs[1]), "Ctd must be a double array.\n");
Ctd_err = "Ctd must be num_bases x num_channels x patch_M x patch_N.\n";
Ctd_all = prhs[1];
dims = mxGetDimensions(Ctd_all);
mxAssert(dims[0] == num_bases, Ctd_err);
num_channels = dims[1];
mxAssert(dims[2] == patch_M/2+1, Ctd_err);
if (mxGetNumberOfDimensions(Ctd_all)==4){
mxAssert(dims[3] == patch_N, Ctd_err);
} else {
mxAssert(1 == patch_N, Ctd_err);
}
Ctd_allr = mxGetPr(Ctd_all);
if (mxIsComplex(Ctd_all)){
Ctd_alli = mxGetPi(Ctd_all);
}
mxAssert(mxIsDouble(prhs[2]), "lambda must be a double array.\n");
mxAssert(mxGetM(prhs[2])==num_bases && mxGetN(prhs[2])==1,"lambda must be num_bases x 1.\n");
lambda = mxGetPr(prhs[2]);
c = mxGetScalar(prhs[3]);
plhs[0] = mxCreateDoubleScalar(0);
obj = mxGetPr(plhs[0]);
if (nargout >= 2){
plhs[1] = mxCreateDoubleMatrix(num_bases,1,mxREAL);
grad = mxGetPr(plhs[1]);
}
if (nargout >= 3){
plhs[2] = mxCreateDoubleMatrix(num_bases,num_bases,mxREAL);
hessian = mxGetPr(plhs[2]);
}
get_objective();
}
//Execute function
int LPSolveClass::Execute()
{
/*
std::cout << "---------------------------------\n";
std::cout << "objective function\n";
for (unsigned int i = 0; i < coefficients.size(); i++)
std::cout << coefficients[i] << "\t";
std::cout << "\nConstant Value = " << obj_const << std::endl;
std::cout << "---------------------------------\n";
std::cout << "Equality Constraints\n";
for (unsigned int i = 0; i < A_equ.size(); i++){
//std::cout << "Row index = " << i << "\t\t";
for (unsigned int j = 0; j < A_equ[i].size(); j++)
std::cout << A_equ[i][j] << "\t";
std::cout << "\n";
}
std::cout << "b\n";
for (unsigned int i = 0; i < b_equ.size(); i++)
std::cout << b_equ[i] << "\t";
std::cout << "\n";
std::cout << "---------------------------------\n";
std::cout << "InEquality Constraints\n";
for (unsigned int i = 0; i < A_inequ.size(); i++){
//std::cout << "Row index = " << i << "\t\t";
for (unsigned int j = 0; j < A_inequ[i].size(); j++)
std::cout << A_inequ[i][j] << "\t";
std::cout << "\n";
}
std::cout << "b\n";
for (unsigned int i = 0; i < b_inequ.size(); i++)
std::cout << b_inequ[i] << "\t";
std::cout << "\n";
*/
lprec *lp;
int Ncol = coefficients.size(), *colno = NULL, j, ret = 0;
REAL *row = NULL;
/* We will build the model row by row
So we start with creating a model with 0 rows and n columns */
lp = make_lp(0, Ncol);
if (lp == NULL)
ret = 1;/* couldn't construct a new model... */
if (ret == 0){
//let us name our variables
std::string s = "x";
for (int i = 0; i < Ncol; i++){
std::stringstream out;
out << i;
s = s + out.str();
char *cpy = new char[s.size()+1] ;
strcpy(cpy, s.c_str());
set_col_name(lp, i+1, cpy);
}
/* create space large enough for one row */
colno = (int *) malloc(Ncol * sizeof(*colno));
row = (REAL *) malloc(Ncol * sizeof(*row));
if ((colno == NULL) || (row == NULL))
ret = 2;
}
set_add_rowmode(lp, TRUE);
//add the equation constraints
if (ret == 0){
/* makes building the model faster if it is done rows by row */
if (A_equ.size() > 0){
for (unsigned int i = 0; i < A_equ.size(); i++){//loop over the rows of equality constraints
for (unsigned int j = 0; j < A_equ[i].size(); j++){//loop over the columns of equality constraints
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = A_equ[i][j];
}
/* add the row to lpsolve */
if(!add_constraintex(lp, A_equ[i].size(), row, colno, EQ, b_equ[i]))
ret = 2;
}
}
}
//add the inequality constraints
if (ret == 0){
/* makes building the model faster if it is done rows by row */
if (A_inequ.size() > 0){
for (unsigned int i = 0; i < A_inequ.size(); i++){//loop over the rows of inequality constraints
for (unsigned int j = 0; j < A_inequ[i].size(); j++){//loop over the columns of inequality constraints
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = A_inequ[i][j];
}
/* add the row to lpsolve */
if(!add_constraintex(lp, A_inequ[i].size(), row, colno, LE, b_inequ[i]))
ret = 3;
}
}
}
//add the const constraint
if (ret == 0){
if (b_const.size()>0){
for (unsigned int i = 0; i < b_const.size(); i++){
if (b_const[i] > 0){
for (unsigned int j = 0; j < b_const.size(); j++){
if (i == j){
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = 1.0;
}
else{
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = 0.0;
}
}
if(!add_constraintex(lp, b_const.size(), row, colno, EQ, b_const[i]))
ret = 4;
}
}
}
}
//set the variables to be integer
if (ret == 0){
for (int i = 0; i < Ncol; i++)
set_int(lp, i+1, TRUE);
}
/* rowmode should be turned off again when done building the model */
set_add_rowmode(lp, FALSE);
//add the objective function
if (ret == 0){
//set the objective function
for (unsigned int i = 0; i < coefficients.size(); i++){
colno[i] = i+1;
row[i] = coefficients[i];
}
//set the objective in lpsolve
if(!set_obj_fnex(lp, coefficients.size(), row, colno))
ret = 4;
}
//set the objective to minimize
if (ret == 0){
set_minim(lp);
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
write_LP(lp, stdout);
/* I only want to see important messages on screen while solving */
set_verbose(lp, IMPORTANT);
/* Now let lpsolve calculate a solution */
ret = solve(lp);
if(ret == OPTIMAL)
ret = 0;
else
ret = 5;
}
//get some results
if (ret == 0){
/* a solution is calculated, now lets get some results */
/* objective value */
std::cout << "Objective value: " << get_objective(lp) << std::endl;
/* variable values */
get_variables(lp, row);
/* variable values */
variables.resize(Ncol);
for(j = 0; j < Ncol; j++)
variables[j] = row[j];
/* we are done now */
}
else{
std::cout << "The optimal value can't be solved for linear programming, please check the constraints!!\n";
exit(1);
}
std::cout << "print the result\t # of line segments is \n";
for (int i = 0; i < Ncol; i++)
std::cout << "index = " << i << "\t# = " << variables[i] << std::endl;
/* free allocated memory */
if(row != NULL)
free(row);
if(colno != NULL)
free(colno);
/* clean up such that all used memory by lpsolve is freed */
if (lp != NULL)
delete_lp(lp);
return ret;
}
double CLPLpsolve::getPrimalObjectiveValue()
{
return get_objective(m_env);
}
double solve_constraints(int this_task)
{
lprec *lp;
int numVar = 0, *var = NULL, ret = 0, i, j, k, var_count;
double *coeff = NULL, lhs,rhs, obj;
char col_name[10];
/* Creating a model */
for(i = 1;i < this_task; i++)
numVar+=i;
lp = make_lp(0, numVar);
if(lp == NULL)
ret = 1; /* Couldn't construct a new model */
if(ret == 0) {
var_count = 1;
for(i = 1 ; i < this_task; i++){
for(j = i+1 ; j <= this_task; j++)
{
sprintf(col_name, "%dNNP%d_%d", this_task, i, j);
set_col_name(lp, var_count, col_name);
var_count++;
}
}
/* create space large enough for one row(i.e. equation) */
var = (int *) malloc(numVar * sizeof(*var));
coeff = (double *) malloc(numVar * sizeof(*coeff));
if((var == NULL) || (coeff == NULL))
ret = 2;
}
/* add the equations to lpsolve */
if(ret == 0) {
set_add_rowmode(lp, TRUE);
/* --------------------adding EQN-D-------------------- */
for(j = 2;j <= this_task;j++){
var_count = 0;
for(i = 1; i < j; i++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = 1;
var_count++;
}
lhs= 0;
for(i = 1; i < j; i++)
lhs+= nnp_min[i][j];
lhs*= floor(R[this_task]/task[j].p);
rhs = 0;
for(i = 1; i < j; i++)
rhs += nnp_max[i][j];
rhs *= ceil(R[this_task]/task[j].p);
if(!add_constraintex(lp, var_count, coeff, var, GE, lhs))
ret = 3;
if(!add_constraintex(lp, var_count, coeff, var, LE, rhs))
ret = 3;
}
}
if(ret == 0) {
/* --------------------adding EQN-E-------------------- */
for(k = 2;k <= this_task;k++)
{
var_count = 0;
for(j = 2; j <= k; j++){
for(i = 1; i < j; i++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = 1;
var_count++;
}
}
rhs = 0;
for(i = 1; i < k; i++)
rhs += ceil(R[this_task]/task[i].p);
if(!add_constraintex(lp, var_count, coeff, var, LE,rhs))
ret = 3;
}
}
if(ret == 0) {
/* ------------------adding EQN-G & H------------------ */
for(j = 2; j <= this_task ; j++){
for(i = 1; i < j; i++){
lhs= floor(R[this_task]/task[j].p) * nnp_min[i][j];
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[0] = get_nameindex(lp, col_name, FALSE);
coeff[0] = 1;
if(!add_constraintex(lp, 1, coeff, var, GE, lhs))
ret = 3;
rhs = min(ceil(R[this_task]/task[i].p), ceil(R[this_task]/task[j].p) * ceil(R[j]/task[i].p), ceil(R[this_task]/task[j].p) * nnp_max[i][j]);
if(!add_constraintex(lp, 1, coeff, var, LE,rhs))
ret = 3;
}
}
}
if(ret == 0) {
/* --------------------adding EQN-I-------------------- */
for(i = 1; i < this_task; i++){
var_count = 0;
for(j = i+1; j <= this_task; j++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = 1;
var_count++;
}
rhs = ceil(R[this_task]/task[i].p);
if(!add_constraintex(lp, var_count, coeff, var, LE,rhs))
ret = 3;
}
}
set_add_rowmode(lp, FALSE);
if(ret == 0) {
/* -----------------set the objective----------------- */
var_count = 0;
for(i = 1 ; i < this_task; i++){
for(j = i+1 ; j<= this_task; j++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = get_f(this_task, i, j);
var_count++;
}
}
if(!set_obj_fnex(lp, var_count, coeff, var))
ret = 4;
set_maxim(lp);
write_LP(lp, stdout);
set_verbose(lp, IMPORTANT);
ret = solve(lp);
if(ret == OPTIMAL)
ret = 0;
else
ret = 5;
}
if(ret == 0) {
obj = get_objective(lp);
/* Displaying calculated values */
/* variable values */
printf("\nVariable values:\n");
get_variables(lp, coeff);
printf("\n");
for(j = 0; j < numVar; j++)
printf("%s: %f\n", get_col_name(lp, j + 1), coeff[j]);
/* objective value */
printf("\nObjective value: %f\n\n", obj);
}
printf("LP ERROR = %d\n\n", ret);
/* free allocated memory */
if(coeff != NULL)
free(coeff);
if(var != NULL)
free(var);
if(lp != NULL)
delete_lp(lp);
return ret == 0 ? obj : 0;
}
int calculate (IN int nCols /* variables in the model */,
IN int nRows,
IN double** rows,
IN double* rights,
IN double* objectives,
OUT int* answer,
IN int verbose)
{
lprec *lp;
int result = 0;
char *str = NULL;
int *colno = NULL;
double *row = NULL;
/* We will build the model row by row
* So we start with creating a model
* with 0 rows and 2 columns
*/
if ( !(lp = make_lp (0, nCols)) )
{
/* couldn't construct a new model... */
result = 1;
goto RESULT;
}
if ( !(str = (char*) malloc ((log10 (nCols) + 10) * sizeof (*str))) )
{
result = 2;
goto RESULT;
}
/* let us name our variables. Not required,
* but can be useful for debugging
*/
for ( int i = 1; i <= nCols; ++i )
{
str[0] = 't';
_itoa (i, str + 1, 10);
set_col_name (lp, i, str);
// set_int (lp, i, TRUE);
}
/* create space large enough for one row */
colno = (int *) malloc (nCols * sizeof (*colno));
row = (double*) malloc (nCols * sizeof (*row));
if ( (colno == NULL) || (row == NULL) )
{
result = 2;
goto RESULT;
}
for ( int j = 0; j < nCols; ++j )
{ colno[j] = j + 1; /* (j + 1) column */ }
/* makes building the model faster if it is done rows by row */
set_add_rowmode (lp, TRUE);
for ( int i = 0; i < nRows; ++i )
{
// /* construct j row */
// for ( int j = 0; j < nCols; ++j )
// { row[j] = ??? ; }
/* (210 * t2 + 156 * t3 == 0.0178) */
/* (230 * t2 + 160 * t3 == 0.0176) */
/* add the row to lp_solve */
if ( !add_constraintex (lp, nCols, rows[i], colno, EQ, rights[i]) )
{
result = 3;
goto RESULT;
}
}
/* rowmode should be turned off again when done building the model */
set_add_rowmode (lp, FALSE);
// /* set the objective function */
// for ( int j = 0; j < nCols; ++j )
// { row[j] = objectives[j]; }
/* (t1 + t2 + t3 + t4) */
/* set the objective in lp_solve */
if ( !set_obj_fnex (lp, nCols, objectives, colno) )
{
result = 4;
goto RESULT;
}
/* set the object direction to maximize */
set_minim (lp);
if ( verbose )
{
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
write_LP (lp, stdout);
/* write_lp(lp, "model.lp"); */
}
/* I only want to see important messages on screen while solving */
set_verbose (lp, IMPORTANT);
/* Now let lpsolve calculate a solution */
result = solve (lp);
if ( result == OPTIMAL )
{ result = 0; }
else
{
result = 5;
goto RESULT;
}
/* a solution is calculated,
* now lets get some results
*/
if ( verbose )
{
/* objective value */
printf ("Objective value: %f\n", get_objective (lp));
}
/* variable values */
get_variables (lp, row);
for ( int j = 0; j < nCols; j++ )
{
if ( verbose )
printf ("%s: %f\n", get_col_name (lp, j + 1), row[j]);
answer[j] = row[j];
}
/* we are done now */
RESULT:;
/* free allocated memory */
if ( str != NULL )free (str);
if ( row != NULL ) free (row);
if ( colno != NULL ) free (colno);
if ( lp != NULL )
{
/* clean up such that all used memory by lpsolve is freed */
delete_lp (lp);
}
return result;
}
int demo()
{
lprec *lp;
int Ncol, *colno = NULL, j, ret = 0;
REAL *row = NULL;
/* We will build the model row by row
So we start with creating a model with 0 rows and 2 columns */
Ncol = 2; /* there are two variables in the model */
lp = make_lp(0, Ncol);
if(lp == NULL)
ret = 1; /* couldn't construct a new model... */
if(ret == 0) {
/* let us name our variables. Not required, but can be useful for debugging */
set_col_name(lp, 1, "x");
set_col_name(lp, 2, "y");
/* create space large enough for one row */
colno = (int *) malloc(Ncol * sizeof(*colno));
row = (REAL *) malloc(Ncol * sizeof(*row));
if((colno == NULL) || (row == NULL))
ret = 2;
}
if(ret == 0) {
set_add_rowmode(lp, TRUE); /* makes building the model faster if it is done rows by row */
/* construct first row (120 x + 210 y <= 15000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 120;
colno[j] = 2; /* second column */
row[j++] = 210;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 15000))
ret = 3;
}
if(ret == 0) {
/* construct second row (110 x + 30 y <= 4000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 110;
colno[j] = 2; /* second column */
row[j++] = 30;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 4000))
ret = 3;
}
if(ret == 0) {
/* construct third row (x + y <= 75) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 1;
colno[j] = 2; /* second column */
row[j++] = 1;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 75))
ret = 3;
}
if(ret == 0) {
set_add_rowmode(lp, FALSE); /* rowmode should be turned off again when done building the model */
/* set the objective function (143 x + 60 y) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 143;
colno[j] = 2; /* second column */
row[j++] = 60;
/* set the objective in lpsolve */
if(!set_obj_fnex(lp, j, row, colno))
ret = 4;
}
if(ret == 0) {
/* set the object direction to maximize */
set_maxim(lp);
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
write_LP(lp, stdout);
/* write_lp(lp, "model.lp"); */
/* I only want to see important messages on screen while solving */
set_verbose(lp, IMPORTANT);
/* Now let lpsolve calculate a solution */
ret = solve(lp);
if(ret == OPTIMAL)
ret = 0;
else
ret = 5;
}
if(ret == 0) {
/* a solution is calculated, now lets get some results */
/* objective value */
printf("Objective value: %f\n", get_objective(lp));
/* variable values */
get_variables(lp, row);
for(j = 0; j < Ncol; j++)
printf("%s: %f\n", get_col_name(lp, j + 1), row[j]);
/* we are done now */
}
/* free allocated memory */
if(row != NULL)
free(row);
if(colno != NULL)
free(colno);
if(lp != NULL) {
/* clean up such that all used memory by lpsolve is freed */
delete_lp(lp);
}
return(ret);
}
