Nabble - AMPL

[AMPL 3042] Re: a problem

2009-11-26T20:00:08Z

here is the code and when i use option solver knitroampl it just stops
responding .....and with minos ( after having lower bounds) it exits
like the one mentioned above...........any suggestions ???????

param N integer;

set Instruments := {1..N+1};

param B_D;
param B_I;
param sigma;
param D;
set States := {1..2^(N+1)};
param a { 2..N+1};
param k;
param alpha {2..N+1};
param gamma {2..N+1};
param theta_G {Instruments};
param theta_B {Instruments};
param epsilon {Instruments};
param capgamma {2..N+1};
param tau_max ;
param omega;
param theta {Instruments, States};
param si {States};

#### Variables #####
var e {Instruments} >= 0;
var T;
var tau {States};
var L {i in Instruments,j in States} ;
var R {i in Instruments,j in States} ;
var S {i in 2..N+1, j in States} ;
var beta {i in 2..N+1, j in States};
var capdelta {States};
var W {j in States} = (sum {i in 2..N+1} (a[i] * S[i,j]^((k-1)/k)))^k/
(k-1);
###### Objective function####
maximize Objective : sum {j in States} (si[j] * (W[j] + sigma *
capdelta[j])) ;

###### Constraints #####
subject to Constraint_12 {i in 2..N+1, j in States}: S[i,j] - (gamma
[i] * L[i,j]^alpha[i] * R[i,j]^beta[i,j]) <= 0;
subject to Constraint_13 {i in 2..N+1, j in States}: S[i,j] >=
capgamma[i];
subject to Constraint_16 {i in 2..N+1, j in States}: beta[i,j] - (1-
alpha[i])*(1- theta[i,j]/(theta[i,j] + e[i])) = 0 ;
subject to Constraint_17 {j in States}: R[1,j] - tau[j]* L[1,j]^omega
= 0 ;
subject to Constraint_18 {j in States}: tau[j] - tau_max * (1 - theta
[1,j]/(theta[1,j] + e[1])) = 0 ;
subject to Constraint_19 {j in States}: R[1,j] - sum{i in 2..N+1} R
[i,j] >= 0;
subject to Constraint_20 : B_D - T - e[1] - sum{i in 2..N+1} e[i] >=
0;
subject to Constraint_21 {j in States}: B_I + T - L[1,j] - sum{i in
2..N+1} L[i,j] - capdelta[j] >= 0 ;
subject to Constraint_23 : T >= 0;

problem SOLVE: Objective, e, T, tau, L, R, S, beta, capdelta,
Constraint_12, Constraint_13, Constraint_16, Constraint_17,
Constraint_18, Constraint_19, Constraint_20, Constraint_21,
Constraint_23 ;

On Nov 26, 8:42 pm, Nilu <nilu8...@...> wrote:

> hi i am trying to solve a non linear problem and I have given lower
> bounds to the variables which may cause problems but after all these
> things when i execute the solve command I get this:
>
> Presolve eliminates 1 constraint.
> Substitution eliminates 8 variables.
> Adjusted problem:
> 100 variables:
> 83 nonlinear variables
> 17 linear variables
> 65 constraints; 204 linear nonzeros
> 48 nonlinear constraints
> 17 linear constraints
> 1 nonlinear objective; 24 nonzeros.
> MINOS 5.5: exit code 3221225477
>
> Can you suggest any reason for the problem ???.......It seems there is
> some problem in calculating the objective.....any ideas ????

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=en.

[AMPL 3041] a problem

2009-11-26T18:42:28Z

hi i am trying to solve a non linear problem and I have given lower
bounds to the variables which may cause problems but after all these
things when i execute the solve command I get this:

Presolve eliminates 1 constraint.
Substitution eliminates 8 variables.
Adjusted problem:
100 variables:
83 nonlinear variables
17 linear variables
65 constraints; 204 linear nonzeros
48 nonlinear constraints
17 linear constraints
1 nonlinear objective; 24 nonzeros.
MINOS 5.5: exit code 3221225477

Can you suggest any reason for the problem ???.......It seems there is
some problem in calculating the objective.....any ideas ????

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=en.

[AMPL 3040] String expressions in read table commands

2009-11-26T09:34:09Z

Hello!

I would like to use data from different excel files and solve my
problem for each of them. I use this code (Tt is not defined in
mono.dat):

model mono.mod;
data mono.dat;
set CASES= 1..2;
for {i in CASES}
{reset data Tt;
table flow IN "ODBC" ("flow_sce\scenario" & i & ".xls"): [TIME], Tt;
read table flow;
solve;
display P;
}

This code is not working and I got the following error messages:
"Abandoning compound command to accept declaration of flow.
Rejecting declaration because it uses loop dummy i."

Could you help me to formulate this right?

Thanks,
Marie

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=en.

[AMPL 3039] Re: write table command error

2009-11-25T15:25:38Z

Dear Bob,

Thanks for the explanation!

I did find a workaround. I think it is my fault.
When declare the table, I actually assign a condition.
The structure of my code is:

1. table example OUT: {i in NAME, j in TIME: condition[i,j] = 1} ->
[NAME,TIME], Value;
2. "code to assign values to parameter condition[i,j]"
3. write table example;

When moved table declaration after the code section, the error
disappeared.
The structure of new code is:
1. "code to assign values to parameter condition[i,j]"
2. table example OUT: {i in NAME, j in TIME: condition[i,j] = 1} ->
[NAME,TIME], Value;
3. write table example;

Therefore I believe I should always use the second structure. For the
first one, ampl sometimes does not complain. I don't know why.

Thanks for the help and have a nice holiday!

Feng

On Nov 24, 8:57 am, "Robert Fourer" <4...@...> wrote:

> This error message suggests that you might have run up against an obscure
> bug of some kind. Can you provide the files that you used, so that I can
> try to reproduce the problem? Then we can get it fixed but in the mean time
> there may be a simple workaround.
>
> Bob Fourer
> 4...@...
>
>
>
> > -----Original Message-----
> > From: Mangotree [mailto:mangotree...@...]
> > Sent: Monday, November 23, 2009 5:57 PM
> > To: AMPL Modeling Language
> > Subject: [AMPL 3035] write table command error
>
> > Dear AMPL guru,
>
> > When using write table command, ampl gave me an error
> > message:
>
> > 'Error executing "write_table" command:
>
> > 1 contexts remain open after compile!'
>
> > The table is defined as: table example OUT: {i in NAME, j in TIME} ->
> > [NAME,TIME], Value;
>
> > where: Value is defined over 2 sets Name & Time.
>
> > Can someone advise me where the issue is? What is the exact
> > meaning of the error message? Thanks!
>
> > Feng
>
> > --
>
> > You received this message because you are subscribed to the Google Groups
> > "AMPL Modeling Language" group.
> > To post to this group, send email to ampl@....
> > To unsubscribe from this group, send email to
> > ampl+unsubscribe@....
> > For more options, visit this group at
> >http://groups.google.com/group/ampl?hl=.- Hide quoted text -
>
> - Show quoted text -

Re: [AMPL 3038] Re: calculating runlength

2009-11-25T00:03:23Z

To report my sudden unexpected success late last night. Turns out that changing constraint runlength6 to:

subject to runlength6{i in S24s, j in LOCATIONS, k in COMP_TIMES}: (1-runmap[i, j, k])*(1+LENGTH)+ run[i, j, k] >= PERSISTENCE_THRESHOLD;

caused the model to become linear. The presolve and the CPLEX solver now accept the problem and find a valid optimal solution.

Thanks and best regards

On Tue, Nov 24, 2009 at 6:03 PM, Saqib Ilyas <msaqib@...> wrote:

I am now able to correctly compute the runlength as I desire. However, the problem now has nonlinear constraints. Do you think I might be able to somehow express the same in a linear fashion? Also, abusufyan, I didn't get your question.

set LOCATIONS;
param Gamma >= 0;
param gamma >= 0;
param lambda >= 0;
param Lambda >= 0;
set COMP_TIMES = 1 .. (Gamma*gamma/lambda);
set PWR_TIMES = 1 .. (Gamma*gamma);
param pwr_price{LOCATIONS, PWR_TIMES} >= 0;
param workload{COMP_TIMES} >= 0;
param workloadPerS24 >= 0;
param total_S24s >= 0;
set S24s = 1..total_S24s;
param s24_capacity{LOCATIONS} integer >= 0;
param DCPower >=0;
param LENGTH = Gamma*gamma/lambda;

var runlength{S24s, LOCATIONS} integer >= 0;

var z {S24s, LOCATIONS, COMP_TIMES} binary;

var run{S24s, LOCATIONS, COMP_TIMES} integer <= LENGTH + 1;

var S24_Map{S24s, j in LOCATIONS, COMP_TIMES} binary ;

var active_S24s { i in LOCATIONS, j in COMP_TIMES} = sum{k in S24s} S24_Map[k, i, j];

var temp_Required_Pwr {i in LOCATIONS, j in COMP_TIMES} = (sum{k in S24s} S24_Map[k, i, j]) * DCPower / s24_capacity[i];

var Required_Pwr{i in LOCATIONS, j in PWR_TIMES} = sum {k in j*gamma/lambda .. (j+1)*gamma/lambda-1} temp_Required_Pwr[i, k]

;

var tCost{i in LOCATIONS, j in PWR_TIMES} = Required_Pwr[i, j]*pwr_price[i,j];

var runmap{S24s, LOCATIONS, COMP_TIMES} binary;

minimize Cost: sum{i in LOCATIONS} (sum{j in PWR_TIMES} tCost[i,j]);

subject to Workload {i in COMP_TIMES}:
workload[i] <= (sum {j in LOCATIONS} active_S24s[j, i])*workloadPerS24;

subject to saneS24s {i in LOCATIONS, j in COMP_TIMES}: active_S24s[i, j] <= s24_capacity[i];

subject to runlength1 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= run[i, j, k-1] + 1;

subject to runlength2 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= run[i, j, k-1] + 1 - LENGTH * (1 -

S24_Map[i, j, k]);

subject to runlength4 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= 0;

subject to runlength5 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= S24_Map[i, j, k]*(1+LENGTH);

subject to runlength3{i in S24s, j in LOCATIONS}: run[i, j, 1] = S24_Map[i, j, 1];

subject to runmap1{i in S24s, j in LOCATIONS, k in COMP_TIMES: k < LENGTH}: runmap[i, j, k] >= S24_Map[i, j, k] - S24_Map[i, j, k+1];

subject to runmap2{i in S24s, j in LOCATIONS, k in COMP_TIMES: k < LENGTH}: 2*runmap[i, j, k] <= S24_Map[i, j, k] + 1 - S24_Map[i, j, k+1];

subject to runmap3{i in S24s, j in LOCATIONS}: runmap[i, j, LENGTH] = S24_Map[i, j, LENGTH];

subject to runlength6{i in S24s, j in LOCATIONS}: runlength[i, j] = min{k in COMP_TIMES} ((1-runmap[i, j, k])*(1+LENGTH)+run[i, j, k]);

On Sat, Nov 21, 2009 at 10:50 PM, abusufiyan p .. <sufiyanponani@...> wrote:

mr: saqib,i would like to more information about lenear programming problem

On 11/21/09, Saqib Ilyas <msaqib@...> wrote:

Firstly, thanks for your reply and taking out time for this implementation. Paul, I would love an integer linear problem. Thanks for your clever linearization of the model. I spent some time trying to digest it and implement it in my model. The model is slightly different from what you've interpreted.

First, I am (now) interested in the number of consecutive 1s. That is 1100011010 has three runs of length 2, 2, and 1 respectively, whereas 00111100 has one run of length 4. Secondly, I am interested in constraining the length of the smallest runs. I tried to adapt your approach to my problem and implemented the following (Yea, well, I had some 3 dimensional variables and didn't want to make any mistakes while trying to adapt it for posting on the lsit):

var runlength integer >= 0;

var z {COMP_TIMES} binary;

var run{S24s, LOCATIONS, COMP_TIMES} <= LENGTH + 1;

var S24_Map{S24s, j in LOCATIONS, COMP_TIMES} binary ;

subject to runlength1 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= run[i, j, k-1] + 1;

subject to runlength2 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= run[i, j, k-1] + 1 - LENGTH * (1 - S24_Map[i, j, k-1]);

subject to runlength3{i in S24s, j in LOCATIONS}: run[i, j, 1] = 1 - LENGTH*(1-S24_Map[i, j, 1]);

subject to PickOne: sum{i in COMP_TIMES} z[i] <= 1;

subject to MinCondition{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k];

subject to Limit{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k] + LENGTH*(1-run[i, j, k]);

#subject to MinRun: runlength >= 2;

I've still got the run length constraint commented out and yet the problem doesn't seem to be solvable and I get impossible deduced bounds in presolve. Given my modified requirements, is there some error in the above constraints that you can see? Otherwise, I can post the complete model and data files for you and others to run and try.

On Thu, Nov 19, 2009 at 5:27 AM, Paul <rubin@...> wrote:

You haven't specified whether your model is linear or not, so I'm
going to assume it's an integer linear program. I'm inferring from
your examples that (a) the length of a run includes the bounding 1
bits (e.g., 1001 is a run of length 4) and (b) when you refer to the
run length of a bit sequence you mean the length of the longest run in
the sequence. That leaves open the question of whether a bit sequence
that starts/ends with a zero has an initial/final run (i.e., is there
an implicit one before/after a sequence). For instance, would 000000
be considered a single run of six zeros or considered to have no runs
at all?

Assuming you want a linear model and there must be an explicit one bit
at each end of a run, something like the following might work. I
won't swear it's the most efficient possible formulation, though. I'm
adopting the convention that no runs equates to run length 0.

param LENGTH integer > 0; # length of a bit sequence -- I assume they
all have the same length
set POSITION := 1..LENGTH; # index set
var bit {POSITION} binary; # variables that will yield a bit
sequence
var runlength integer >= 0; # maximum run length
var r {POSITION}; # helper variable that maps each bit to the length
of the run containing it -- NOT nonnegative and not explicitly
declared integer
var y {POSITION} binary; # helper variable that maps a bit to 0 if it
is part of an ongoing run and 1 if not
var z {POSITION} binary; # helper variable that points to the end bit
of the longest run

# the next three constraints determine y
s.t. Ongoing1 {k in POSITION : k > 1}: y[k] >= bit[k-1] + bit[k] - 1;
s.t. Ongoing2 {k in POSITION : k > 1}: 2*y[k] <= bit[k-1] + bit[k];
s.t. Start: y[1] = 0; # the first bit cannot be part of an "ongoing"
run (it could start one)
# if bit[k] and bit[k-1] are both 1, y[k] = 1; otherwise y[k] = 0

# the following constraints compute the length of any ongoing run at
each position
s.t. RunUpperLimit {k in POSITION}: r[k] <= r[k-1] + 1; # run length
increases at most 1 as you advance one bit
s.t. InRun1 {k in POSITION : k > 1}: r[k] >= r[k-1] + 1 - LENGTH*y
[k]; # if y[k] = 0 (position k is part of a run), r[k] must equal r
[k-1] + 1
s.t. InRun2 {k in POSITION : k > 1}: r[k] <= 1 + LENGTH*(1 - y[k]); #
if y[k] = 0 (position k is part of a run), this is vacuous; otherwise
it forces r[k] <= 1 (bit[k] could be the initial 1 of a run, or it
could be part of a non-run)
s.t. InitLength: r[1] = 1 - LENGTH*(1-bit[1]); # if bit[1] = 1, r[1]
= 1; otherwise r[1] is negative (sequence starts with 0, so the
initial "run" doesn't count)

# the next constraint says we'll select at most a single bit position
as the terminus of the maximum run
s.t. PickOne: sum {k in POSIITION} z[k] <= 1; # the sum is zero --
all z[k] are 0 -- iff there is no run

# finally, we need constraints to define the maximum run length
s.t. MaxCondition {k in POSITION}: runlength >= r[k]; # the run
length is at least as large as the ongoing run length at every
position
s.t. Limit {k in POSITION}: runlength <= r[k] + LENGTH*(1 - z[k]); #
limits the runlength to r[k] if k is the position that terminates the
longest run

You really need to check that mess; it's not beyond the bounds of
possibility that I booted something.

/Paul

msaqib wrote:
> My case is "c", the bits are model variables and the run length should be
> computed and it factors in the objective function.
>
>
> Paul-432 wrote:
> >
> > I can interpret this three different ways:
> >
> > a) the bits are parameters of the model;
> > b) the bits are model variables (unknown when the model is
> > formulated), and you need to compute the run length of the final
> > solution after the solution is obtained; or
> > c) the bits are model variables and so is the run length, and the run
> > length is used within the model.
> >
> > The first two can be handled by looping; the third requires additional
> > model constructs (constraints and probability some auxiliary
> > variables).
> >
> > /Paul
> >
> > On Nov 16, 8:24 am, msaqib <msa...@...> wrote:
> >> Hi all
> >> In a model, I need to calculate the runlength of a sequence of binary
> >> (0/1)
> >> numbers. In other words, I need to count the number of zeros between a
> >> pair
> >> of ones. For example, the runlength in 0010001110010 is 5, and that for
> >> 0010000110010 is 6. I'm not sure how to represent this mathematically in
> >> an
> >> AMPL model. We typically do this iteratively in other programming
> >> languages.
> >> Any clues?
> >> Thanks and best regards
> >> --
> >
> --
> View this message in context: http://old.nabble.com/calculating-runlength-tp26371837p26385781.html
> Sent from the AMPL mailing list archive at Nabble.com.

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
Muhammad Saqib Ilyas
PhD Student, Computer Science and Engineering
Lahore University of Management Sciences

--
You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
Muhammad Saqib Ilyas
PhD Student, Computer Science and Engineering
Lahore University of Management Sciences

--
Muhammad Saqib Ilyas
PhD Student, Computer Science and Engineering
Lahore University of Management Sciences

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=en.

RE: [AMPL 3037] write table command error

2009-11-24T08:57:50Z

This error message suggests that you might have run up against an obscure
bug of some kind. Can you provide the files that you used, so that I can
try to reproduce the problem? Then we can get it fixed but in the mean time
there may be a simple workaround.

Bob Fourer
4er@...

> -----Original Message-----
> From: Mangotree [mailto:mangotree.gf@...]
> Sent: Monday, November 23, 2009 5:57 PM
> To: AMPL Modeling Language
> Subject: [AMPL 3035] write table command error
>
> Dear AMPL guru,
>
> When using write table command, ampl gave me an error
> message:
>
> 'Error executing "write_table" command:
>
> 1 contexts remain open after compile!'
>
> The table is defined as: table example OUT: {i in NAME, j in TIME} ->
> [NAME,TIME], Value;
>
> where: Value is defined over 2 sets Name & Time.
>
> Can someone advise me where the issue is? What is the exact
> meaning of the error message? Thanks!
>
> Feng
>
> --
>
> You received this message because you are subscribed to the Google Groups
> "AMPL Modeling Language" group.
> To post to this group, send email to ampl@....
> To unsubscribe from this group, send email to
> ampl+unsubscribe@....
> For more options, visit this group at
> http://groups.google.com/group/ampl?hl=.
>

Re: [AMPL 3036] Re: calculating runlength

2009-11-24T05:03:59Z

I am now able to correctly compute the runlength as I desire. However, the problem now has nonlinear constraints. Do you think I might be able to somehow express the same in a linear fashion? Also, abusufyan, I didn't get your question.

set LOCATIONS;
param Gamma >= 0;
param gamma >= 0;
param lambda >= 0;
param Lambda >= 0;
set COMP_TIMES = 1 .. (Gamma*gamma/lambda);
set PWR_TIMES = 1 .. (Gamma*gamma);
param pwr_price{LOCATIONS, PWR_TIMES} >= 0;
param workload{COMP_TIMES} >= 0;
param workloadPerS24 >= 0;
param total_S24s >= 0;
set S24s = 1..total_S24s;
param s24_capacity{LOCATIONS} integer >= 0;
param DCPower >=0;
param LENGTH = Gamma*gamma/lambda;

var runlength{S24s, LOCATIONS} integer >= 0;

var z {S24s, LOCATIONS, COMP_TIMES} binary;

var run{S24s, LOCATIONS, COMP_TIMES} integer <= LENGTH + 1;

var S24_Map{S24s, j in LOCATIONS, COMP_TIMES} binary ;

var active_S24s { i in LOCATIONS, j in COMP_TIMES} = sum{k in S24s} S24_Map[k, i, j];

var temp_Required_Pwr {i in LOCATIONS, j in COMP_TIMES} = (sum{k in S24s} S24_Map[k, i, j]) * DCPower / s24_capacity[i];

var Required_Pwr{i in LOCATIONS, j in PWR_TIMES} = sum {k in j*gamma/lambda .. (j+1)*gamma/lambda-1} temp_Required_Pwr[i, k]

;

var tCost{i in LOCATIONS, j in PWR_TIMES} = Required_Pwr[i, j]*pwr_price[i,j];

var runmap{S24s, LOCATIONS, COMP_TIMES} binary;

minimize Cost: sum{i in LOCATIONS} (sum{j in PWR_TIMES} tCost[i,j]);

subject to Workload {i in COMP_TIMES}:
workload[i] <= (sum {j in LOCATIONS} active_S24s[j, i])*workloadPerS24;

subject to saneS24s {i in LOCATIONS, j in COMP_TIMES}: active_S24s[i, j] <= s24_capacity[i];

subject to runlength1 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= run[i, j, k-1] + 1;

subject to runlength2 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= run[i, j, k-1] + 1 - LENGTH * (1 -

S24_Map[i, j, k]);

subject to runlength4 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= 0;

subject to runlength5 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= S24_Map[i, j, k]*(1+LENGTH);

subject to runlength3{i in S24s, j in LOCATIONS}: run[i, j, 1] = S24_Map[i, j, 1];

subject to runmap1{i in S24s, j in LOCATIONS, k in COMP_TIMES: k < LENGTH}: runmap[i, j, k] >= S24_Map[i, j, k] - S24_Map[i, j, k+1];

subject to runmap2{i in S24s, j in LOCATIONS, k in COMP_TIMES: k < LENGTH}: 2*runmap[i, j, k] <= S24_Map[i, j, k] + 1 - S24_Map[i, j, k+1];

subject to runmap3{i in S24s, j in LOCATIONS}: runmap[i, j, LENGTH] = S24_Map[i, j, LENGTH];

subject to runlength6{i in S24s, j in LOCATIONS}: runlength[i, j] = min{k in COMP_TIMES} ((1-runmap[i, j, k])*(1+LENGTH)+run[i, j, k]);

On Sat, Nov 21, 2009 at 10:50 PM, abusufiyan p .. <sufiyanponani@...> wrote:

mr: saqib,i would like to more information about lenear programming problem

On 11/21/09, Saqib Ilyas <msaqib@...> wrote:

Firstly, thanks for your reply and taking out time for this implementation. Paul, I would love an integer linear problem. Thanks for your clever linearization of the model. I spent some time trying to digest it and implement it in my model. The model is slightly different from what you've interpreted.

First, I am (now) interested in the number of consecutive 1s. That is 1100011010 has three runs of length 2, 2, and 1 respectively, whereas 00111100 has one run of length 4. Secondly, I am interested in constraining the length of the smallest runs. I tried to adapt your approach to my problem and implemented the following (Yea, well, I had some 3 dimensional variables and didn't want to make any mistakes while trying to adapt it for posting on the lsit):

var runlength integer >= 0;

var z {COMP_TIMES} binary;

var run{S24s, LOCATIONS, COMP_TIMES} <= LENGTH + 1;

var S24_Map{S24s, j in LOCATIONS, COMP_TIMES} binary ;

subject to runlength1 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= run[i, j, k-1] + 1;

subject to runlength2 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= run[i, j, k-1] + 1 - LENGTH * (1 - S24_Map[i, j, k-1]);

subject to runlength3{i in S24s, j in LOCATIONS}: run[i, j, 1] = 1 - LENGTH*(1-S24_Map[i, j, 1]);

subject to PickOne: sum{i in COMP_TIMES} z[i] <= 1;

subject to MinCondition{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k];

subject to Limit{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k] + LENGTH*(1-run[i, j, k]);

#subject to MinRun: runlength >= 2;

I've still got the run length constraint commented out and yet the problem doesn't seem to be solvable and I get impossible deduced bounds in presolve. Given my modified requirements, is there some error in the above constraints that you can see? Otherwise, I can post the complete model and data files for you and others to run and try.

On Thu, Nov 19, 2009 at 5:27 AM, Paul <rubin@...> wrote:

You haven't specified whether your model is linear or not, so I'm
going to assume it's an integer linear program. I'm inferring from
your examples that (a) the length of a run includes the bounding 1
bits (e.g., 1001 is a run of length 4) and (b) when you refer to the
run length of a bit sequence you mean the length of the longest run in
the sequence. That leaves open the question of whether a bit sequence
that starts/ends with a zero has an initial/final run (i.e., is there
an implicit one before/after a sequence). For instance, would 000000
be considered a single run of six zeros or considered to have no runs
at all?

Assuming you want a linear model and there must be an explicit one bit
at each end of a run, something like the following might work. I
won't swear it's the most efficient possible formulation, though. I'm
adopting the convention that no runs equates to run length 0.

param LENGTH integer > 0; # length of a bit sequence -- I assume they
all have the same length
set POSITION := 1..LENGTH; # index set
var bit {POSITION} binary; # variables that will yield a bit
sequence
var runlength integer >= 0; # maximum run length
var r {POSITION}; # helper variable that maps each bit to the length
of the run containing it -- NOT nonnegative and not explicitly
declared integer
var y {POSITION} binary; # helper variable that maps a bit to 0 if it
is part of an ongoing run and 1 if not
var z {POSITION} binary; # helper variable that points to the end bit
of the longest run

# the next three constraints determine y
s.t. Ongoing1 {k in POSITION : k > 1}: y[k] >= bit[k-1] + bit[k] - 1;
s.t. Ongoing2 {k in POSITION : k > 1}: 2*y[k] <= bit[k-1] + bit[k];
s.t. Start: y[1] = 0; # the first bit cannot be part of an "ongoing"
run (it could start one)
# if bit[k] and bit[k-1] are both 1, y[k] = 1; otherwise y[k] = 0

# the following constraints compute the length of any ongoing run at
each position
s.t. RunUpperLimit {k in POSITION}: r[k] <= r[k-1] + 1; # run length
increases at most 1 as you advance one bit
s.t. InRun1 {k in POSITION : k > 1}: r[k] >= r[k-1] + 1 - LENGTH*y
[k]; # if y[k] = 0 (position k is part of a run), r[k] must equal r
[k-1] + 1
s.t. InRun2 {k in POSITION : k > 1}: r[k] <= 1 + LENGTH*(1 - y[k]); #
if y[k] = 0 (position k is part of a run), this is vacuous; otherwise
it forces r[k] <= 1 (bit[k] could be the initial 1 of a run, or it
could be part of a non-run)
s.t. InitLength: r[1] = 1 - LENGTH*(1-bit[1]); # if bit[1] = 1, r[1]
= 1; otherwise r[1] is negative (sequence starts with 0, so the
initial "run" doesn't count)

# the next constraint says we'll select at most a single bit position
as the terminus of the maximum run
s.t. PickOne: sum {k in POSIITION} z[k] <= 1; # the sum is zero --
all z[k] are 0 -- iff there is no run

# finally, we need constraints to define the maximum run length
s.t. MaxCondition {k in POSITION}: runlength >= r[k]; # the run
length is at least as large as the ongoing run length at every
position
s.t. Limit {k in POSITION}: runlength <= r[k] + LENGTH*(1 - z[k]); #
limits the runlength to r[k] if k is the position that terminates the
longest run

You really need to check that mess; it's not beyond the bounds of
possibility that I booted something.

/Paul

msaqib wrote:
> My case is "c", the bits are model variables and the run length should be
> computed and it factors in the objective function.
>
>
> Paul-432 wrote:
> >
> > I can interpret this three different ways:
> >
> > a) the bits are parameters of the model;
> > b) the bits are model variables (unknown when the model is
> > formulated), and you need to compute the run length of the final
> > solution after the solution is obtained; or
> > c) the bits are model variables and so is the run length, and the run
> > length is used within the model.
> >
> > The first two can be handled by looping; the third requires additional
> > model constructs (constraints and probability some auxiliary
> > variables).
> >
> > /Paul
> >
> > On Nov 16, 8:24 am, msaqib <msa...@...> wrote:
> >> Hi all
> >> In a model, I need to calculate the runlength of a sequence of binary
> >> (0/1)
> >> numbers. In other words, I need to count the number of zeros between a
> >> pair
> >> of ones. For example, the runlength in 0010001110010 is 5, and that for
> >> 0010000110010 is 6. I'm not sure how to represent this mathematically in
> >> an
> >> AMPL model. We typically do this iteratively in other programming
> >> languages.
> >> Any clues?
> >> Thanks and best regards
> >> --
> >
> --
> View this message in context: http://old.nabble.com/calculating-runlength-tp26371837p26385781.html
> Sent from the AMPL mailing list archive at Nabble.com.

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
Muhammad Saqib Ilyas
PhD Student, Computer Science and Engineering
Lahore University of Management Sciences

--
You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
Muhammad Saqib Ilyas
PhD Student, Computer Science and Engineering
Lahore University of Management Sciences

[AMPL 3035] write table command error

2009-11-23T15:57:11Z

Dear AMPL guru,

When using write table command, ampl gave me an error
message:

'Error executing "write_table" command:

1 contexts remain open after compile!'

The table is defined as: table example OUT: {i in NAME, j in TIME} ->
[NAME,TIME], Value;

where: Value is defined over 2 sets Name & Time.

Can someone advise me where the issue is? What is the exact
meaning of the error message? Thanks!

Feng

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

[AMPL 3034] how to spec. an assignment constraint

2009-11-23T07:09:43Z

hi!

I'm quite novice in ampl yet and trying to solve a sort of a task
assignment problem with ampl/cplex. I have had several attempts on one
of my constraints but it does not seem to work out for me.

The problem is the following, I have a set of i's clustered into
subsets and a set of j's clustered into subsets for another reason.
Let's say

i in FRUITS, j in STUDENTS, then within the fruits I would have e.g.
25 types/subsets/SUBFRUITS (fruits are categorized in param ms[i,s]
given as data) and also the students would be classified e.g. into 10
CLASSES (also a param classes[j] tells which class a student is in).

In this case I would want to have all fruits given to some students
such that all fruits of a certain type out of the 25 possible, e.g. 5
apples, are distributed among the students so that each of the five
apples are given to students in different classes (out of the 10). No
second student in a class can get an apple where an apple has already
been handed out.

The target of the optimization is the mapping between i -> j (m[i,j]
binary), and this would be one of the constraints to it.

One of my many failed attempts to specify this constraint:

subject to Constr1 {s in SUBFRUITS, i in FRUITS, k in FRUITS, d in
CLASSES: i<k}:
ms[i,s] * md[i,d] + ms[k,s] * md[k,d] <= 1;

where the binary md[i,d] would return the mapping between a fruit i
(in FRUITS) and a class d (a subclass within STUDENTS), but I don't
know how to specify md[] to make this work.

First of all I'm not quite sure if md[] would be a var or a param, as
it derives from a var that we optimize, the mapping m[i,j], the
following way:
md[ i, m[i,j]*classes[j] ] = 1, and 0 otherwise.

since we have the classification of the students in the param classes
[j], but this sentence above is syntactically incorrect.

Could anyone give me a hint how to spec. this constraint of mine?

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

Re: [AMPL 3032] Re: calculating runlength

2009-11-21T15:02:31Z

Saqib Ilyas wrote:
> Firstly, thanks for your reply and taking out time for this implementation.

You're welcome.

> Paul, I would love an integer linear problem. Thanks for your clever
> linearization of the model. I spent some time trying to digest it and
> implement it in my model. The model is slightly different from what you've
> interpreted.
> First, I am (now) interested in the number of consecutive 1s. That is
> 1100011010 has three runs of length 2, 2, and 1 respectively, whereas
> 00111100 has one run of length 4. Secondly, I am interested in constraining
> the length of the smallest runs. I tried to adapt your approach to my
> problem and implemented the following (Yea, well, I had some 3 dimensional
> variables and didn't want to make any mistakes while trying to adapt it for
> posting on the lsit):
>
> var runlength integer >= 0;
> var z {COMP_TIMES} binary;
> var run{S24s, LOCATIONS, COMP_TIMES} <= LENGTH + 1;
> var S24_Map{S24s, j in LOCATIONS, COMP_TIMES} binary ;
>
> subject to runlength1 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}:
> run[i, j, k] <= run[i, j, k-1] + 1;
>
> subject to runlength2 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}:
> run[i, j, k] >= run[i, j, k-1] + 1 - LENGTH * (1 - S24_Map[i, j, k-1]);
>
> subject to runlength3{i in S24s, j in LOCATIONS}: run[i, j, 1] = 1 -
> LENGTH*(1-S24_Map[i, j, 1]);
>
> subject to PickOne: sum{i in COMP_TIMES} z[i] <= 1;
> subject to MinCondition{i in S24s, j in LOCATIONS, k in COMP_TIMES}:
> runlength <= run[i, j, k];
>
> subject to Limit{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <=
> run[i, j, k] + LENGTH*(1-run[i, j, k]);
>
> #subject to MinRun: runlength >= 2;
>
> I've still got the run length constraint commented out and yet the problem
> doesn't seem to be solvable and I get impossible deduced bounds in presolve.
> Given my modified requirements, is there some error in the above constraints
> that you can see?

Yes, there's a problem. Keep in mind that run[i,j,k] is defined for
every triple (i,j,k), not just for those that are parts of a run. So
if S24_Map[i,j,1] (which I assume represents the first bit in a
string) is 0, then run[i,j,1] is negative (courtesy of the runlength3
constraints), which means runlength is negative (courtesy of
MinCondition), which means the MinRun constraint cannot be satisfied.

There are other problems as well. Suppose that S24_Map[i,j,1] = 1
(initial bit is 1). Then run[i,j,1] = 1, which means runlength <= 1.

Your definition of run[,,] is ok. What you need to do is constrain
runlength <= run[i,j,k] only when S24_Map[i,j,k] = 1 and S24_Map[i,j,k
+1] = 0 (or does not exist because k is at its largest possible
value). In other words, runlength needs to be limited only by the
cumulative run length at a bit that marks the end of a run.

/Paul

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

Re: [AMPL 3033] Re: calculating runlength

2009-11-21T09:50:22Z

mr: saqib,i would like to more information about lenear programming problem

On 11/21/09, Saqib Ilyas <msaqib@...> wrote:

Firstly, thanks for your reply and taking out time for this implementation. Paul, I would love an integer linear problem. Thanks for your clever linearization of the model. I spent some time trying to digest it and implement it in my model. The model is slightly different from what you've interpreted.

First, I am (now) interested in the number of consecutive 1s. That is 1100011010 has three runs of length 2, 2, and 1 respectively, whereas 00111100 has one run of length 4. Secondly, I am interested in constraining the length of the smallest runs. I tried to adapt your approach to my problem and implemented the following (Yea, well, I had some 3 dimensional variables and didn't want to make any mistakes while trying to adapt it for posting on the lsit):

var runlength integer >= 0;

var z {COMP_TIMES} binary;

var run{S24s, LOCATIONS, COMP_TIMES} <= LENGTH + 1;

var S24_Map{S24s, j in LOCATIONS, COMP_TIMES} binary ;

subject to runlength1 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= run[i, j, k-1] + 1;

subject to runlength2 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= run[i, j, k-1] + 1 - LENGTH * (1 - S24_Map[i, j, k-1]);

subject to runlength3{i in S24s, j in LOCATIONS}: run[i, j, 1] = 1 - LENGTH*(1-S24_Map[i, j, 1]);

subject to PickOne: sum{i in COMP_TIMES} z[i] <= 1;

subject to MinCondition{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k];

subject to Limit{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k] + LENGTH*(1-run[i, j, k]);

#subject to MinRun: runlength >= 2;

I've still got the run length constraint commented out and yet the problem doesn't seem to be solvable and I get impossible deduced bounds in presolve. Given my modified requirements, is there some error in the above constraints that you can see? Otherwise, I can post the complete model and data files for you and others to run and try.

On Thu, Nov 19, 2009 at 5:27 AM, Paul <rubin@...> wrote:

You haven't specified whether your model is linear or not, so I'm
going to assume it's an integer linear program. I'm inferring from
your examples that (a) the length of a run includes the bounding 1
bits (e.g., 1001 is a run of length 4) and (b) when you refer to the
run length of a bit sequence you mean the length of the longest run in
the sequence. That leaves open the question of whether a bit sequence
that starts/ends with a zero has an initial/final run (i.e., is there
an implicit one before/after a sequence). For instance, would 000000
be considered a single run of six zeros or considered to have no runs
at all?

Assuming you want a linear model and there must be an explicit one bit
at each end of a run, something like the following might work. I
won't swear it's the most efficient possible formulation, though. I'm
adopting the convention that no runs equates to run length 0.

param LENGTH integer > 0; # length of a bit sequence -- I assume they
all have the same length
set POSITION := 1..LENGTH; # index set
var bit {POSITION} binary; # variables that will yield a bit
sequence
var runlength integer >= 0; # maximum run length
var r {POSITION}; # helper variable that maps each bit to the length
of the run containing it -- NOT nonnegative and not explicitly
declared integer
var y {POSITION} binary; # helper variable that maps a bit to 0 if it
is part of an ongoing run and 1 if not
var z {POSITION} binary; # helper variable that points to the end bit
of the longest run

# the next three constraints determine y
s.t. Ongoing1 {k in POSITION : k > 1}: y[k] >= bit[k-1] + bit[k] - 1;
s.t. Ongoing2 {k in POSITION : k > 1}: 2*y[k] <= bit[k-1] + bit[k];
s.t. Start: y[1] = 0; # the first bit cannot be part of an "ongoing"
run (it could start one)
# if bit[k] and bit[k-1] are both 1, y[k] = 1; otherwise y[k] = 0

# the following constraints compute the length of any ongoing run at
each position
s.t. RunUpperLimit {k in POSITION}: r[k] <= r[k-1] + 1; # run length
increases at most 1 as you advance one bit
s.t. InRun1 {k in POSITION : k > 1}: r[k] >= r[k-1] + 1 - LENGTH*y
[k]; # if y[k] = 0 (position k is part of a run), r[k] must equal r
[k-1] + 1
s.t. InRun2 {k in POSITION : k > 1}: r[k] <= 1 + LENGTH*(1 - y[k]); #
if y[k] = 0 (position k is part of a run), this is vacuous; otherwise
it forces r[k] <= 1 (bit[k] could be the initial 1 of a run, or it
could be part of a non-run)
s.t. InitLength: r[1] = 1 - LENGTH*(1-bit[1]); # if bit[1] = 1, r[1]
= 1; otherwise r[1] is negative (sequence starts with 0, so the
initial "run" doesn't count)

# the next constraint says we'll select at most a single bit position
as the terminus of the maximum run
s.t. PickOne: sum {k in POSIITION} z[k] <= 1; # the sum is zero --
all z[k] are 0 -- iff there is no run

# finally, we need constraints to define the maximum run length
s.t. MaxCondition {k in POSITION}: runlength >= r[k]; # the run
length is at least as large as the ongoing run length at every
position
s.t. Limit {k in POSITION}: runlength <= r[k] + LENGTH*(1 - z[k]); #
limits the runlength to r[k] if k is the position that terminates the
longest run

You really need to check that mess; it's not beyond the bounds of
possibility that I booted something.

/Paul

msaqib wrote:
> My case is "c", the bits are model variables and the run length should be
> computed and it factors in the objective function.
>
>
> Paul-432 wrote:
> >
> > I can interpret this three different ways:
> >
> > a) the bits are parameters of the model;
> > b) the bits are model variables (unknown when the model is
> > formulated), and you need to compute the run length of the final
> > solution after the solution is obtained; or
> > c) the bits are model variables and so is the run length, and the run
> > length is used within the model.
> >
> > The first two can be handled by looping; the third requires additional
> > model constructs (constraints and probability some auxiliary
> > variables).
> >
> > /Paul
> >
> > On Nov 16, 8:24 am, msaqib <msa...@...> wrote:
> >> Hi all
> >> In a model, I need to calculate the runlength of a sequence of binary
> >> (0/1)
> >> numbers. In other words, I need to count the number of zeros between a
> >> pair
> >> of ones. For example, the runlength in 0010001110010 is 5, and that for
> >> 0010000110010 is 6. I'm not sure how to represent this mathematically in
> >> an
> >> AMPL model. We typically do this iteratively in other programming
> >> languages.
> >> Any clues?
> >> Thanks and best regards
> >> --
> >
> --
> View this message in context: http://old.nabble.com/calculating-runlength-tp26371837p26385781.html
> Sent from the AMPL mailing list archive at Nabble.com.

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
Muhammad Saqib Ilyas
PhD Student, Computer Science and Engineering
Lahore University of Management Sciences

--
You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

Re: [AMPL 3031] Re: calculating runlength

2009-11-21T03:07:30Z

Firstly, thanks for your reply and taking out time for this implementation. Paul, I would love an integer linear problem. Thanks for your clever linearization of the model. I spent some time trying to digest it and implement it in my model. The model is slightly different from what you've interpreted.

First, I am (now) interested in the number of consecutive 1s. That is 1100011010 has three runs of length 2, 2, and 1 respectively, whereas 00111100 has one run of length 4. Secondly, I am interested in constraining the length of the smallest runs. I tried to adapt your approach to my problem and implemented the following (Yea, well, I had some 3 dimensional variables and didn't want to make any mistakes while trying to adapt it for posting on the lsit):

var runlength integer >= 0;

var z {COMP_TIMES} binary;

var run{S24s, LOCATIONS, COMP_TIMES} <= LENGTH + 1;

var S24_Map{S24s, j in LOCATIONS, COMP_TIMES} binary ;

subject to runlength1 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] <= run[i, j, k-1] + 1;

subject to runlength2 {i in S24s, j in LOCATIONS, k in COMP_TIMES: k > 1}: run[i, j, k] >= run[i, j, k-1] + 1 - LENGTH * (1 - S24_Map[i, j, k-1]);

subject to runlength3{i in S24s, j in LOCATIONS}: run[i, j, 1] = 1 - LENGTH*(1-S24_Map[i, j, 1]);

subject to PickOne: sum{i in COMP_TIMES} z[i] <= 1;

subject to MinCondition{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k];

subject to Limit{i in S24s, j in LOCATIONS, k in COMP_TIMES}: runlength <= run[i, j, k] + LENGTH*(1-run[i, j, k]);

#subject to MinRun: runlength >= 2;

I've still got the run length constraint commented out and yet the problem doesn't seem to be solvable and I get impossible deduced bounds in presolve. Given my modified requirements, is there some error in the above constraints that you can see? Otherwise, I can post the complete model and data files for you and others to run and try.

On Thu, Nov 19, 2009 at 5:27 AM, Paul <rubin@...> wrote:

You haven't specified whether your model is linear or not, so I'm
going to assume it's an integer linear program. I'm inferring from
your examples that (a) the length of a run includes the bounding 1
bits (e.g., 1001 is a run of length 4) and (b) when you refer to the
run length of a bit sequence you mean the length of the longest run in
the sequence. That leaves open the question of whether a bit sequence
that starts/ends with a zero has an initial/final run (i.e., is there
an implicit one before/after a sequence). For instance, would 000000
be considered a single run of six zeros or considered to have no runs
at all?

Assuming you want a linear model and there must be an explicit one bit
at each end of a run, something like the following might work. I
won't swear it's the most efficient possible formulation, though. I'm
adopting the convention that no runs equates to run length 0.

param LENGTH integer > 0; # length of a bit sequence -- I assume they
all have the same length
set POSITION := 1..LENGTH; # index set
var bit {POSITION} binary; # variables that will yield a bit
sequence
var runlength integer >= 0; # maximum run length
var r {POSITION}; # helper variable that maps each bit to the length
of the run containing it -- NOT nonnegative and not explicitly
declared integer
var y {POSITION} binary; # helper variable that maps a bit to 0 if it
is part of an ongoing run and 1 if not
var z {POSITION} binary; # helper variable that points to the end bit
of the longest run

# the next three constraints determine y
s.t. Ongoing1 {k in POSITION : k > 1}: y[k] >= bit[k-1] + bit[k] - 1;
s.t. Ongoing2 {k in POSITION : k > 1}: 2*y[k] <= bit[k-1] + bit[k];
s.t. Start: y[1] = 0; # the first bit cannot be part of an "ongoing"
run (it could start one)
# if bit[k] and bit[k-1] are both 1, y[k] = 1; otherwise y[k] = 0

# the following constraints compute the length of any ongoing run at
each position
s.t. RunUpperLimit {k in POSITION}: r[k] <= r[k-1] + 1; # run length
increases at most 1 as you advance one bit
s.t. InRun1 {k in POSITION : k > 1}: r[k] >= r[k-1] + 1 - LENGTH*y
[k]; # if y[k] = 0 (position k is part of a run), r[k] must equal r
[k-1] + 1
s.t. InRun2 {k in POSITION : k > 1}: r[k] <= 1 + LENGTH*(1 - y[k]); #
if y[k] = 0 (position k is part of a run), this is vacuous; otherwise
it forces r[k] <= 1 (bit[k] could be the initial 1 of a run, or it
could be part of a non-run)
s.t. InitLength: r[1] = 1 - LENGTH*(1-bit[1]); # if bit[1] = 1, r[1]
= 1; otherwise r[1] is negative (sequence starts with 0, so the
initial "run" doesn't count)

# the next constraint says we'll select at most a single bit position
as the terminus of the maximum run
s.t. PickOne: sum {k in POSIITION} z[k] <= 1; # the sum is zero --
all z[k] are 0 -- iff there is no run

# finally, we need constraints to define the maximum run length
s.t. MaxCondition {k in POSITION}: runlength >= r[k]; # the run
length is at least as large as the ongoing run length at every
position
s.t. Limit {k in POSITION}: runlength <= r[k] + LENGTH*(1 - z[k]); #
limits the runlength to r[k] if k is the position that terminates the
longest run

You really need to check that mess; it's not beyond the bounds of
possibility that I booted something.

/Paul

msaqib wrote:
> My case is "c", the bits are model variables and the run length should be
> computed and it factors in the objective function.
>
>
> Paul-432 wrote:
> >
> > I can interpret this three different ways:
> >
> > a) the bits are parameters of the model;
> > b) the bits are model variables (unknown when the model is
> > formulated), and you need to compute the run length of the final
> > solution after the solution is obtained; or
> > c) the bits are model variables and so is the run length, and the run
> > length is used within the model.
> >
> > The first two can be handled by looping; the third requires additional
> > model constructs (constraints and probability some auxiliary
> > variables).
> >
> > /Paul
> >
> > On Nov 16, 8:24 am, msaqib <msa...@...> wrote:
> >> Hi all
> >> In a model, I need to calculate the runlength of a sequence of binary
> >> (0/1)
> >> numbers. In other words, I need to count the number of zeros between a
> >> pair
> >> of ones. For example, the runlength in 0010001110010 is 5, and that for
> >> 0010000110010 is 6. I'm not sure how to represent this mathematically in
> >> an
> >> AMPL model. We typically do this iteratively in other programming
> >> languages.
> >> Any clues?
> >> Thanks and best regards
> >> --
> >
> --
> View this message in context: http://old.nabble.com/calculating-runlength-tp26371837p26385781.html
> Sent from the AMPL mailing list archive at Nabble.com.

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl%2Bunsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

--
Muhammad Saqib Ilyas
PhD Student, Computer Science and Engineering
Lahore University of Management Sciences

[AMPL 3030] save the current B&C tree in AMPL 10

2009-11-20T06:57:11Z

Is it possible in AMPL 10 that one can save the MIP B&C tree to a
file so that later on the search can start from that status??? It
would be really nice if someone can help. It is also helpful if anyone
knows how to do it in cplex 10.

Thanks,

/Lei

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

RE: [AMPL 3029] Remove/reset table in ODBC

2009-11-19T11:24:52Z

The command "delete table example;" will remove the table definition, after
which you can declare a different table with the same name.

Bob Fourer
4er@...

> -----Original Message-----
> From: Ziming Guan [mailto:z.guan@...]
> Sent: Wednesday, November 18, 2009 1:00 PM
> To: ampl@...
> Subject: [AMPL 3026] Remove/reset table in ODBC
>
> Hi,
>
> I declare a table using ODBC to write data from spreadsheet, for example,
> as
>
> table example OUT "ODBC" "example.xls" "example" :
> {t in 1..T} -> [Stage],
> {r in RES} <beta[r,t] ~ (r)>
> ;
>
> Then later I want to remove or reset this table and then declare a table
> with the same name as
>
> table example OUT "ODBC" "example.xls" "example" :
> {t in 1..T} -> [Stage],
> {r in RESALL} <beta[r,t] ~ (r)>
> ;
>
> What are the commands to remove or reset a table in ODBC? Or is there
> another way to do this?
>
> Thank you,
> Ziming
>

[AMPL 3028] Remove/reset table in ODBC

2009-11-18T18:17:21Z

Return Receipt

Your [AMPL 3026] Remove/reset table in ODBC
document:

was Chandrashekar S Tallichetty/IN/GM/GMC
received
by:

at: 11/19/2009 07:47:24 AM

Nothing in this message is intended to constitute an electronic signature unless a specific statement to the contrary is included in this message.

Confidentiality Note: This message is intended only for the person or entity to which it is addressed. It may contain confidential and/or privileged material. Any review, transmission, dissemination or other use, or taking of any action in reliance upon this message by persons or entities other than the intended recipient is prohibited and may be unlawful. If you received this message in error, please contact the sender and delete it from your computer.

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

Re: [AMPL 3027] Re: calculating runlength

2009-11-18T16:27:32Z

You haven't specified whether your model is linear or not, so I'm
going to assume it's an integer linear program. I'm inferring from
your examples that (a) the length of a run includes the bounding 1
bits (e.g., 1001 is a run of length 4) and (b) when you refer to the
run length of a bit sequence you mean the length of the longest run in
the sequence. That leaves open the question of whether a bit sequence
that starts/ends with a zero has an initial/final run (i.e., is there
an implicit one before/after a sequence). For instance, would 000000
be considered a single run of six zeros or considered to have no runs
at all?

Assuming you want a linear model and there must be an explicit one bit
at each end of a run, something like the following might work. I
won't swear it's the most efficient possible formulation, though. I'm
adopting the convention that no runs equates to run length 0.

param LENGTH integer > 0; # length of a bit sequence -- I assume they
all have the same length
set POSITION := 1..LENGTH; # index set
var bit {POSITION} binary; # variables that will yield a bit
sequence
var runlength integer >= 0; # maximum run length
var r {POSITION}; # helper variable that maps each bit to the length
of the run containing it -- NOT nonnegative and not explicitly
declared integer
var y {POSITION} binary; # helper variable that maps a bit to 0 if it
is part of an ongoing run and 1 if not
var z {POSITION} binary; # helper variable that points to the end bit
of the longest run

# the next three constraints determine y
s.t. Ongoing1 {k in POSITION : k > 1}: y[k] >= bit[k-1] + bit[k] - 1;
s.t. Ongoing2 {k in POSITION : k > 1}: 2*y[k] <= bit[k-1] + bit[k];
s.t. Start: y[1] = 0; # the first bit cannot be part of an "ongoing"
run (it could start one)
# if bit[k] and bit[k-1] are both 1, y[k] = 1; otherwise y[k] = 0

# the following constraints compute the length of any ongoing run at
each position
s.t. RunUpperLimit {k in POSITION}: r[k] <= r[k-1] + 1; # run length
increases at most 1 as you advance one bit
s.t. InRun1 {k in POSITION : k > 1}: r[k] >= r[k-1] + 1 - LENGTH*y
[k]; # if y[k] = 0 (position k is part of a run), r[k] must equal r
[k-1] + 1
s.t. InRun2 {k in POSITION : k > 1}: r[k] <= 1 + LENGTH*(1 - y[k]); #
if y[k] = 0 (position k is part of a run), this is vacuous; otherwise
it forces r[k] <= 1 (bit[k] could be the initial 1 of a run, or it
could be part of a non-run)
s.t. InitLength: r[1] = 1 - LENGTH*(1-bit[1]); # if bit[1] = 1, r[1]
= 1; otherwise r[1] is negative (sequence starts with 0, so the
initial "run" doesn't count)

# the next constraint says we'll select at most a single bit position
as the terminus of the maximum run
s.t. PickOne: sum {k in POSIITION} z[k] <= 1; # the sum is zero --
all z[k] are 0 -- iff there is no run

# finally, we need constraints to define the maximum run length
s.t. MaxCondition {k in POSITION}: runlength >= r[k]; # the run
length is at least as large as the ongoing run length at every
position
s.t. Limit {k in POSITION}: runlength <= r[k] + LENGTH*(1 - z[k]); #
limits the runlength to r[k] if k is the position that terminates the
longest run

You really need to check that mess; it's not beyond the bounds of
possibility that I booted something.

/Paul

msaqib wrote:

> My case is "c", the bits are model variables and the run length should be
> computed and it factors in the objective function.
>
>
> Paul-432 wrote:
> >
> > I can interpret this three different ways:
> >
> > a) the bits are parameters of the model;
> > b) the bits are model variables (unknown when the model is
> > formulated), and you need to compute the run length of the final
> > solution after the solution is obtained; or
> > c) the bits are model variables and so is the run length, and the run
> > length is used within the model.
> >
> > The first two can be handled by looping; the third requires additional
> > model constructs (constraints and probability some auxiliary
> > variables).
> >
> > /Paul
> >
> > On Nov 16, 8:24 am, msaqib <msa...@...> wrote:
> >> Hi all
> >> In a model, I need to calculate the runlength of a sequence of binary
> >> (0/1)
> >> numbers. In other words, I need to count the number of zeros between a
> >> pair
> >> of ones. For example, the runlength in 0010001110010 is 5, and that for
> >> 0010000110010 is 6. I'm not sure how to represent this mathematically in
> >> an
> >> AMPL model. We typically do this iteratively in other programming
> >> languages.
> >> Any clues?
> >> Thanks and best regards
> >> --
> >
> --
> View this message in context: http://old.nabble.com/calculating-runlength-tp26371837p26385781.html
> Sent from the AMPL mailing list archive at Nabble.com.

[AMPL 3026] Remove/reset table in ODBC

2009-11-18T10:59:32Z

Hi,

I declare a table using ODBC to write data from spreadsheet, for example, as

table example OUT "ODBC" "example.xls" "example" :
{t in 1..T} -> [Stage],
{r in RES} <beta[r,t] ~ (r)>
;

Then later I want to remove or reset this table and then declare a table
with the same name as

table example OUT "ODBC" "example.xls" "example" :
{t in 1..T} -> [Stage],
{r in RESALL} <beta[r,t] ~ (r)>
;

What are the commands to remove or reset a table in ODBC? Or is there
another way to do this?

Thank you,
Ziming

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=en.

RE: [AMPL 3025] Re: Logical operators

2009-11-17T16:00:16Z

Thank you!

Robert Fourer-2 wrote:

>
>
> To express such a "disjunctive" constraint of this kind for current
> solvers,
> you need to define a zero-one (or "binary") variable and to create two
> constraints. The first constraint is equivalent to c1 when the binary
> variable is 1, but is trivially satisfied when the binary variable is 0;
> the
> second constraint is equivalent to c2 when the binary variable is 0, but
> is
> trivially satisfied when the binary variable is 1.
>
> The details depend on the specifics of your constraints. But as a simple
> example if you want to specify
>
> param a >= 0;
> param b >= 0;
>
> var x >= 0;
> var y >= 0;
>
> subj to eitheror: x >= a or y >= b;
>
> then you can write
>
> var u binary;
>
> subj to eitherx: x >= a * u;
> subj to eithery: y >= b * (1-u);
>
> For other kinds of inequalities the formulation is a little different, but
> it's not hard to find once you appreciate the principle involved.
>
> Bob Fourer
> 4er@...
>
>
>> -----Original Message-----
>> From: Jen T [mailto:jeniphyr@...]
>> Sent: Sunday, November 15, 2009 6:04 PM
>> To: ampl@...
>> Subject: Re: [AMPL 3013] Re: Logical operators
>>
>>
>> I'm new to AMPL, so try to forgive me if this question is posed
>> elsewhere,
>> or if there is an obvious solution.
>>
>> As the solvers don't support logical operators, is there an alternative
>> way to encode a constraint of the following form...
>>
>> subject to constraintName : c1 or c2;
>>
>> ... where c1 and c2 are simple non-strict inequalities?
>>
>>
>>
>>
>>
>> Robert Fourer-2 wrote:
>> >
>> > AMPL does allow constraints that use logical operators like "or" (not
>> > "OR"), but currently none of the AMPL-solver interfaces are set up to
>> > use such constraints.
>> >
>> > Bob Fourer
>> > 4er@...
>> >
>> >
>> >> -----Original Message-----
>> >> From: ampl@... [mailto:ampl@...] On Behalf
>> Of
>> >> Dilip
>> >> Kothari
>> >> Sent: Sunday, April 08, 2007 3:30 AM
>> >> To: ampl@...
>> >> Subject: [AMPL 957] Logical operators
>> >>
>> >> Hi
>> >> Is AMPL permit the use of logical operators.
>> >> e.g I wish to write
>> >> zn[i,j] = z[i,j] OR y[i,j]
>> >> where zn,z and y are variables. i and j are index over sets
>> >> I and J respectively.
>> >> Thanks,
>> >> DK
>> >>
>> >
>> >
>> >
>> >
>> > --~--~---------~--~----~------------~-------~--~----~
>> > You received this message because you are subscribed to the Google
>> Groups
>> > "AMPL Modeling Language" group.
>> > To post to this group, send email to ampl@...
>> > To unsubscribe from this group, send email to
>> > ampl-unsubscribe@...
>> > For more options, visit this group at
>> > http://groups.google.com/group/ampl?hl=en
>> > -~----------~----~----~----~------~----~------~--~---
>> >
>> >
>> >
>>
>> --
>> View this message in context: http://old.nabble.com/-AMPL-957--Logical-
>> operators-tp9892505p26365085.html
>> Sent from the AMPL mailing list archive at Nabble.com.
>>
>> --
>>
>> You received this message because you are subscribed to the Google Groups
>> "AMPL Modeling Language" group.
>> To post to this group, send email to ampl@....
>> To unsubscribe from this group, send email to
>> ampl+unsubscribe@....
>> For more options, visit this group at
>> http://groups.google.com/group/ampl?hl=.
>>
>
>
> --
>
> You received this message because you are subscribed to the Google Groups
> "AMPL Modeling Language" group.
> To post to this group, send email to ampl@....
> To unsubscribe from this group, send email to
> ampl+unsubscribe@....
> For more options, visit this group at
> http://groups.google.com/group/ampl?hl=.
>
>
>
>

--
View this message in context: http://old.nabble.com/-AMPL-957--Logical-operators-tp9892505p26400087.html
Sent from the AMPL mailing list archive at Nabble.com.

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

RE: [AMPL 3024] Help with AMPL and L1-SVM

2009-11-17T15:39:54Z

There are two ways to read data from a text file, both described in chapter
9 of the AMPL book. You can create a formatted data file according to the
syntax described in sections 9.1-9.4, and then read it using the "data"
command. Or you can create an unformatted file -- containing just a series
of values -- and then read those values into specified parameters using the
"read" command described in section 9.5.

Both of these approaches are quite general. The details of how you use them
will depend upon how you have written the "set" and "param" statements in
your model.

Bob Fourer
4er@...

> -----Original Message-----
> From: guess85 [mailto:saintofme85@...]
> Sent: Thursday, November 12, 2009 2:06 PM
> To: AMPL Modeling Language
> Subject: [AMPL 3005] Help with AMPL and L1-SVM
>
> Hi, I have to use AMPL to write a L1-SVM classifier. I need to read
> data from a text file where there is the instances and the result of
> classification. I try to write it but without success, how can I do?
> Thanks for the help.
>

RE: [AMPL 3023] If...Then...Else

2009-11-17T13:28:49Z

Various problems here:

-- In defining the variables, you need to use >= and <=,
rather than > and <.

-- The square root function is "sqrt" rather than "Sqrt".

-- Probably you forgot "data;" before the data statements,
or read the data file as a model file.

Also it's not going to work with existing solvers to have an expression
involving variables between "if" and "then". You could try defining a
zero-one variable Outside[emp] and inventing some constraints to force that
variable to be one if (XEmpA[emp] - XGrpA)^2 + (YEmpA[emp] - YGrpA)^2 >=
Ra^2; then you could minimize sum {emp in GROUPA} Outside[emp] using a
solver that can handle both quadratic expressions and integer variables.
But if it's acceptable to use a square rather than a circle then you might
find yourself with a more tractable, linear problem.

Bob Fourer
4er@...

> -----Original Message-----
> From: Daniel [mailto:daniel.han.park@...]
> Sent: Monday, November 16, 2009 11:29 AM
> To: AMPL Modeling Language
> Subject: [AMPL 3018] If...Then...Else
>
> Hello,
>
> I'm a recent IE grad with just one grad level IE course under my belt.
> My boss gave me a fun project. Our department is being reorganized
> (people on our floor are being assigned to new groups) and he wants to
> know where to locate each group on our floor to minimize the number
> moves (cost about $800 each).
>
> For now I'm just trying to find the x,y coordinate that minimizes the
> number of individuals in one of those groups (we'll call it GroupA)
> that are outside the area if a circle centered at (XGrpA, YGrpA) with
> a radius of Ra.
>
> The .mod file (first time using AMPL so please feel free to point out
> any syntax errors):
>
> set GROUPA; # employees in groupa
>
> param XEmpA {emp in GROUPA};
> param YEmpA {emp in GROUPA};
> param Ra;
>
> var XGrpA > 2, < 6;
> var YGrpA > 3, < 8;
>
> minimize Moves: sum{emp in GROUPA} (if Sqrt((XEmpA[emp] - XGrpA)^2 +
> (YEmpA[emp] - YGrpA)^2) > Ra then 1 else 0)
>
> The data file:
>
> # Type data here or open a data file...
>
> set GROUPA := 1 2 3 4 5 6 7 8 9 10;
>
> param: XEmpA YEmpA :=
> 1 1 1
> 2 7 1
> 3 1 2
> 4 3 2
> 5 4 2
> 6 4 2
> 7 8 2
> 8 1 3
> 9 2 3
> 10 3 3;
>
> param Ra := 3;
>
> I get the following errors:
>
> file -
> line 7
> offset 169
> cannot enforce strict bound
> file -
> line 7
> offset 174
> cannot enforce strict bound
> file -
> line 8
> offset 190
> cannot enforce strict bound
> file -
> line 8
> offset 195
> cannot enforce strict bound
> file -
> line 9
> offset 238
> Sqrt is not defined
> file -
> line 12
> offset 365
> GROUPA is already defined
> file -
> line 13
> offset 398
> syntax error
> file -
> line 24
> offset 499
> Ra is already defined
>
> Specific Questions: What is the correct symbol for the square root
> operator? Is there some documentation on when you can and cannot use
> the if, then statements in AMPL (looked through the related forum
> posts but still a bit confused on this)?
>
> AMPL book is on the way but I'd like to get a little bit done sooner
> to show my boss. Thanks!!!
>

RE: [AMPL 3022] Re: Logical operators

2009-11-17T13:14:07Z

To express such a "disjunctive" constraint of this kind for current solvers,
you need to define a zero-one (or "binary") variable and to create two
constraints. The first constraint is equivalent to c1 when the binary
variable is 1, but is trivially satisfied when the binary variable is 0; the
second constraint is equivalent to c2 when the binary variable is 0, but is
trivially satisfied when the binary variable is 1.

The details depend on the specifics of your constraints. But as a simple
example if you want to specify

param a >= 0;
param b >= 0;

var x >= 0;
var y >= 0;

subj to eitheror: x >= a or y >= b;

then you can write

var u binary;

subj to eitherx: x >= a * u;
subj to eithery: y >= b * (1-u);

For other kinds of inequalities the formulation is a little different, but
it's not hard to find once you appreciate the principle involved.

Bob Fourer
4er@...

> -----Original Message-----
> From: Jen T [mailto:jeniphyr@...]
> Sent: Sunday, November 15, 2009 6:04 PM
> To: ampl@...
> Subject: Re: [AMPL 3013] Re: Logical operators
>
>
> I'm new to AMPL, so try to forgive me if this question is posed elsewhere,
> or if there is an obvious solution.
>
> As the solvers don't support logical operators, is there an alternative
> way to encode a constraint of the following form...
>
> subject to constraintName : c1 or c2;
>
> ... where c1 and c2 are simple non-strict inequalities?
>
>
>
>
>
> Robert Fourer-2 wrote:
> >
> > AMPL does allow constraints that use logical operators like "or" (not
> > "OR"), but currently none of the AMPL-solver interfaces are set up to
> > use such constraints.
> >
> > Bob Fourer
> > 4er@...
> >
> >
> >> -----Original Message-----
> >> From: ampl@... [mailto:ampl@...] On Behalf Of
> >> Dilip
> >> Kothari
> >> Sent: Sunday, April 08, 2007 3:30 AM
> >> To: ampl@...
> >> Subject: [AMPL 957] Logical operators
> >>
> >> Hi
> >> Is AMPL permit the use of logical operators.
> >> e.g I wish to write
> >> zn[i,j] = z[i,j] OR y[i,j]
> >> where zn,z and y are variables. i and j are index over sets
> >> I and J respectively.
> >> Thanks,
> >> DK
> >>
> >
> >
> >
> >
> > --~--~---------~--~----~------------~-------~--~----~
> > You received this message because you are subscribed to the Google
> Groups
> > "AMPL Modeling Language" group.
> > To post to this group, send email to ampl@...
> > To unsubscribe from this group, send email to
> > ampl-unsubscribe@...
> > For more options, visit this group at
> > http://groups.google.com/group/ampl?hl=en
> > -~----------~----~----~----~------~----~------~--~---
> >
> >
> >
>
> --
> View this message in context: http://old.nabble.com/-AMPL-957--Logical-
> operators-tp9892505p26365085.html
> Sent from the AMPL mailing list archive at Nabble.com.
>
> --
>
> You received this message because you are subscribed to the Google Groups
> "AMPL Modeling Language" group.
> To post to this group, send email to ampl@....
> To unsubscribe from this group, send email to
> ampl+unsubscribe@....
> For more options, visit this group at
> http://groups.google.com/group/ampl?hl=.
>

[AMPL 3019] Re: calculating runlength

2009-11-17T05:37:29Z

Hi Paul
Thanks for the reply. In my case, it is "c", i.e., the bits are
variables and the value they take on, is factored into the objective
function.
I have a feeling that computing exclusive OR(XOR) of each adjacent
pair of bits and summing the answer (as an integer) gives me the
answer. Can anyone come up with a different approach? I'll need to
read the AMPL book to see if XOR is possible in AMPL models.
Thanks and best regards

On Nov 16, 8:02 pm, Paul <ru...@...> wrote:

> I can interpret this three different ways:
>
> a) the bits are parameters of the model;
> b) the bits are model variables (unknown when the model is
> formulated), and you need to compute the run length of the final
> solution after the solution is obtained; or
> c) the bits are model variables and so is the run length, and the run
> length is used within the model.
>
> The first two can be handled by looping; the third requires additional
> model constructs (constraints and probability some auxiliary
> variables).
>
> /Paul
>
> On Nov 16, 8:24 am, msaqib <msa...@...> wrote:
>
>
>
> > Hi all
> > In a model, I need to calculate the runlength of a sequence of binary (0/1)
> > numbers. In other words, I need to count the number of zeros between a pair
> > of ones. For example, the runlength in 0010001110010 is 5, and that for
> > 0010000110010 is 6. I'm not sure how to represent this mathematically in an
> > AMPL model. We typically do this iteratively in other programming languages.
> > Any clues?
> > Thanks and best regards
> > --
> > View this message in context:http://old.nabble.com/calculating-runlength-tp26371837p26371837.html
> > Sent from the AMPL mailing list archive at Nabble.com.- Hide quoted text -
>
> - Show quoted text -

Re: [AMPL 3021] expanding defined variables

2009-11-17T01:31:51Z

David M. Gay suggested this (with the <var> = <defining expression>
explicit constraint approach):

expand{i in 1.._nvars: _var[i].status == 'sub'} _con[_var[i].defeqn];

It works but Lambda[1,1,1] appears in def_sum_xLambda[1,1]
however Lambda[1,1,1] is 1 and should be eliminated.

In other words: the output still needs considerable editing.

It seems to me that the easiest would be to write a custom parser for
the nl file.

Many thanks for the help,

Ali

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

Re: [AMPL 3015] Re: calculating runlength

2009-11-16T23:56:10Z

My case is "c", the bits are model variables and the run length should be computed and it factors in the objective function.

Paul-432 wrote:

I can interpret this three different ways:

a) the bits are parameters of the model;
b) the bits are model variables (unknown when the model is
formulated), and you need to compute the run length of the final
solution after the solution is obtained; or
c) the bits are model variables and so is the run length, and the run
length is used within the model.

The first two can be handled by looping; the third requires additional
model constructs (constraints and probability some auxiliary
variables).

/Paul

On Nov 16, 8:24 am, msaqib <msa...@gmail.com> wrote:
> Hi all
> In a model, I need to calculate the runlength of a sequence of binary (0/1)
> numbers. In other words, I need to count the number of zeros between a pair
> of ones. For example, the runlength in 0010001110010 is 5, and that for
> 0010000110010 is 6. I'm not sure how to represent this mathematically in an
> AMPL model. We typically do this iteratively in other programming languages.
> Any clues?
> Thanks and best regards
> --

[AMPL 3018] If...Then...Else

2009-11-16T09:29:29Z

Hello,

I'm a recent IE grad with just one grad level IE course under my belt.
My boss gave me a fun project. Our department is being reorganized
(people on our floor are being assigned to new groups) and he wants to
know where to locate each group on our floor to minimize the number
moves (cost about $800 each).

For now I'm just trying to find the x,y coordinate that minimizes the
number of individuals in one of those groups (we'll call it GroupA)
that are outside the area if a circle centered at (XGrpA, YGrpA) with
a radius of Ra.

The .mod file (first time using AMPL so please feel free to point out
any syntax errors):

set GROUPA; # employees in groupa

param XEmpA {emp in GROUPA};
param YEmpA {emp in GROUPA};
param Ra;

var XGrpA > 2, < 6;
var YGrpA > 3, < 8;

minimize Moves: sum{emp in GROUPA} (if Sqrt((XEmpA[emp] - XGrpA)^2 +
(YEmpA[emp] - YGrpA)^2) > Ra then 1 else 0)

The data file:

# Type data here or open a data file...

set GROUPA := 1 2 3 4 5 6 7 8 9 10;

param: XEmpA YEmpA :=
1 1 1
2 7 1
3 1 2
4 3 2
5 4 2
6 4 2
7 8 2
8 1 3
9 2 3
10 3 3;

param Ra := 3;

I get the following errors:

file -
line 7
offset 169
cannot enforce strict bound
file -
line 7
offset 174
cannot enforce strict bound
file -
line 8
offset 190
cannot enforce strict bound
file -
line 8
offset 195
cannot enforce strict bound
file -
line 9
offset 238
Sqrt is not defined
file -
line 12
offset 365
GROUPA is already defined
file -
line 13
offset 398
syntax error
file -
line 24
offset 499
Ra is already defined

Specific Questions: What is the correct symbol for the square root
operator? Is there some documentation on when you can and cannot use
the if, then statements in AMPL (looked through the related forum
posts but still a bit confused on this)?

AMPL book is on the way but I'd like to get a little bit done sooner
to show my boss. Thanks!!!

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

[AMPL 3017] Re: Segmentation fault and Logical constraint is always false error

2009-11-16T08:50:40Z

Thanks a lot, it helps me to found the mistake. The RHS of the
constriant was missing.

On Nov 16, 5:05 pm, Paul <ru...@...> wrote:

> Try adding the line
>
> expand optimality_cut[nsoln];
>
> after nsoln gets incremented and see what you get.
>
> /Paul
>
> On Nov 15, 9:46 pm, enhany75 <enhan...@...> wrote:
>
> > Hi,
>
> > I am trying to solve a model by decomposition using master and sub-
> > problem. At each time an optimality cut is added to the master
> > problem.
>
> > subject to optimality_cut {n in nols: n <= nsoln}: sum {j in t1, i in
> > prodj[j],q in seqj[j]: Xjiq_cut[n,j,i,q] = 0} Xjiq[j,i,q] + sum {j in
> > t1, i in prodj[j],q in seqj[j]: Xjiq_cut[n,j,i,q] = 1}(1- Xjiq[j,i,q])
> > + sum {k in t2, i in prodk[k],q in seqk[k]: Xkiq_cut[n,k,i,q] = 0} Xkiq
> > [k,i,q] + sum {k in t2, i in prodk[k],q in seqk[k]: Xkiq_cut[n,k,i,q]
> > = 1}(1- Xkiq[k,i,q]);
>
> > But the solver gives me this error message
>
> > presolve, constraint optimality_cut[2]:
> > Logical constraint is always false.
> > presolve, constraint optimality_cut[1]:
> > Logical constraint is always false.
> > presolve, constraint optimality_cut[1]:
> > Logical constraint is always false.
> > presolve, constraint optimality_cut[2]:
> > .
> > srun: error: n281: task0: Segmentation fault
>
> > Could you please tell me why the Logical constraint is always false,
> > knowing that Xjiq_cut take binary values.
>
>

[AMPL 3016] Re: Segmentation fault and Logical constraint is always false error

2009-11-16T07:05:58Z

Try adding the line

expand optimality_cut[nsoln];

after nsoln gets incremented and see what you get.

/Paul

On Nov 15, 9:46 pm, enhany75 <enhan...@...> wrote:

> Hi,
>
> I am trying to solve a model by decomposition using master and sub-
> problem. At each time an optimality cut is added to the master
> problem.
>
> subject to optimality_cut {n in nols: n <= nsoln}: sum {j in t1, i in
> prodj[j],q in seqj[j]: Xjiq_cut[n,j,i,q] = 0} Xjiq[j,i,q] + sum {j in
> t1, i in prodj[j],q in seqj[j]: Xjiq_cut[n,j,i,q] = 1}(1- Xjiq[j,i,q])
> + sum {k in t2, i in prodk[k],q in seqk[k]: Xkiq_cut[n,k,i,q] = 0} Xkiq
> [k,i,q] + sum {k in t2, i in prodk[k],q in seqk[k]: Xkiq_cut[n,k,i,q]
> = 1}(1- Xkiq[k,i,q]);
>
> But the solver gives me this error message
>
> presolve, constraint optimality_cut[2]:
> Logical constraint is always false.
> presolve, constraint optimality_cut[1]:
> Logical constraint is always false.
> presolve, constraint optimality_cut[1]:
> Logical constraint is always false.
> presolve, constraint optimality_cut[2]:
> .
> srun: error: n281: task0: Segmentation fault
>
> Could you please tell me why the Logical constraint is always false,
> knowing that Xjiq_cut take binary values.

[AMPL 3015] Re: calculating runlength

2009-11-16T07:02:19Z

I can interpret this three different ways:

a) the bits are parameters of the model;
b) the bits are model variables (unknown when the model is
formulated), and you need to compute the run length of the final
solution after the solution is obtained; or
c) the bits are model variables and so is the run length, and the run
length is used within the model.

The first two can be handled by looping; the third requires additional
model constructs (constraints and probability some auxiliary
variables).

/Paul

On Nov 16, 8:24 am, msaqib <msa...@...> wrote:

> Hi all
> In a model, I need to calculate the runlength of a sequence of binary (0/1)
> numbers. In other words, I need to count the number of zeros between a pair
> of ones. For example, the runlength in 0010001110010 is 5, and that for
> 0010000110010 is 6. I'm not sure how to represent this mathematically in an
> AMPL model. We typically do this iteratively in other programming languages.
> Any clues?
> Thanks and best regards
> --
> View this message in context:http://old.nabble.com/calculating-runlength-tp26371837p26371837.html
> Sent from the AMPL mailing list archive at Nabble.com.

calculating runlength

2009-11-16T05:24:48Z

Hi all
In a model, I need to calculate the runlength of a sequence of binary (0/1) numbers. In other words, I need to count the number of zeros between a pair of ones. For example, the runlength in 0010001110010 is 5, and that for 0010000110010 is 6. I'm not sure how to represent this mathematically in an AMPL model. We typically do this iteratively in other programming languages.
Any clues?
Thanks and best regards

[AMPL 3012] Segmentation fault and Logical constraint is always false error

2009-11-15T18:46:15Z

Hi,

I am trying to solve a model by decomposition using master and sub-
problem. At each time an optimality cut is added to the master
problem.

subject to optimality_cut {n in nols: n <= nsoln}: sum {j in t1, i in
prodj[j],q in seqj[j]: Xjiq_cut[n,j,i,q] = 0} Xjiq[j,i,q] + sum {j in
t1, i in prodj[j],q in seqj[j]: Xjiq_cut[n,j,i,q] = 1}(1- Xjiq[j,i,q])
+ sum {k in t2, i in prodk[k],q in seqk[k]: Xkiq_cut[n,k,i,q] = 0} Xkiq
[k,i,q] + sum {k in t2, i in prodk[k],q in seqk[k]: Xkiq_cut[n,k,i,q]
= 1}(1- Xkiq[k,i,q]);

But the solver gives me this error message

presolve, constraint optimality_cut[2]:
Logical constraint is always false.
presolve, constraint optimality_cut[1]:
Logical constraint is always false.
presolve, constraint optimality_cut[1]:
Logical constraint is always false.
presolve, constraint optimality_cut[2]:
.
srun: error: n281: task0: Segmentation fault

Could you please tell me why the Logical constraint is always false,
knowing that Xjiq_cut take binary values.

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.

Re: [AMPL 970] Re: Logical operators

2009-11-15T16:04:11Z

I'm new to AMPL, so try to forgive me if this question is posed elsewhere,
or if there is an obvious solution.

As the solvers don't support logical operators, is there an alternative way to
encode a constraint of the following form...

subject to constraintName : c1 or c2;

... where c1 and c2 are simple non-strict inequalities?

Robert Fourer-2 wrote:

AMPL does allow constraints that use logical operators like "or" (not "OR"),
but currently none of the AMPL-solver interfaces are set up to use such
constraints.

Bob Fourer
4er@ampl.com

> -----Original Message-----
> From: ampl@googlegroups.com [mailto:ampl@googlegroups.com] On Behalf Of Dilip
> Kothari
> Sent: Sunday, April 08, 2007 3:30 AM
> To: ampl@googlegroups.com
> Subject: [AMPL 957] Logical operators
>
> Hi
> Is AMPL permit the use of logical operators.
> e.g I wish to write
> zn[i,j] = z[i,j] OR y[i,j]
> where zn,z and y are variables. i and j are index over sets
> I and J respectively.
> Thanks,
> DK
>

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@googlegroups.com
To unsubscribe from this group, send email to ampl-unsubscribe@googlegroups.com
For more options, visit this group at http://groups.google.com/group/ampl?hl=en
-~----------~----~----~----~------~----~------~--~---

RE: [AMPL 3011] Re: number accuracy in writing to file

2009-11-14T07:50:48Z

AMPL's calculations are done in double-precision floating point arithmetic
using all of the precision that the computer and processor can provide.

The display_precision and display_round options affect how numerical values
are displayed, but numbers are stored in full precision internally and the
full precision is used in all calculations.

Bob Fourer
4er@...

> -----Original Message-----
> From: hessam [mailto:hessam.1983@...]
> Sent: Friday, November 13, 2009 3:22 AM
> To: AMPL Modeling Language
> Subject: [AMPL 3006] Re: number accuracy in writing to file
>
> I have another question. Is there any default precision in math
> calculations in AMPL or the operations (for example dividing two
> numbers) are calculated with maximum precision??
>
> On Nov 12, 11:36 am, hessam <hessam.1...@...> wrote:
> > Thanks Bob, your comments are always a great help to me.
> >
> > On Nov 12, 7:23 am, "Robert Fourer" <4...@...> wrote:> The default
> precision for "display" is 6 significant digits. To get a more
> > > precise display of the objective value, set for example "option
> > > display_precision 10;" before the display command. (To tell AMPL that
> you
> > > want the most precision possible, given the number of bits used to
> represent
> > > the objective value in the computer, set "option display_precision
> 0;".)
> >
> > > Bob Fourer
> > > 4...@...
> >
> > > > -----Original Message-----
> > > > From: hessam [mailto:hessam.1...@...]
> > > > Sent: Wednesday, November 11, 2009 9:47 PM
> > > > To: AMPL Modeling Language
> > > > Subject: [AMPL 2996] number accuracy in writing to file
> >
> > > > Hi All,
> >
> > > > I have a problem with writing my results in a file. When I solve my
> > > > ILP with CPLEX+AMPL I get this result:
> > > > --------------------------------------------------------------------
> ------
> > > > CPLEX 11.2.1: optimal integer solution; objective 1213236000
> > > > 731 MIP simplex iterations
> > > > 0 branch-and-bound nodes
> > > > 6 Gomory cuts
> > > > 7 zero-half cuts
> > > > --------------------------------------------------------------------
> ------
> >
> > > > BUT when I use the command "display totalenergy > result.txt;" after
> > > > solving my ILP (note than the variable totalenergy is the objective
> > > > which I try to minimize), in the file I see the number 1213240000
> !!!
> > > > Any suggestions about how I can have the same number in the file??
> >
> > > > Thanks,
> > > > Hessam
> >
> >
>
> --
>
> You received this message because you are subscribed to the Google Groups
> "AMPL Modeling Language" group.
> To post to this group, send email to ampl@....
> To unsubscribe from this group, send email to
> ampl+unsubscribe@....
> For more options, visit this group at
> http://groups.google.com/group/ampl?hl=.
>

RE: [AMPL 3010] AMPL/MINOS support of complex numbers

2009-11-13T16:54:38Z

There is no support for complex variables in AMPL. You have to declare the
real and imaginary parts (x and y) separately and write the objective and
constraints in terms of those parts.

Bob Fourer
4er@...

> -----Original Message-----
> From: Enrique Perea [mailto:enrique.perea@...]
> Sent: Friday, November 13, 2009 2:04 PM
> To: AMPL Modeling Language
> Subject: [AMPL 3007] AMPL/MINOS support of complex numbers
>
> Hi,
>
> I'm working on a telecommunication application problem and some of my
> variables and input parameter are complex-valued i.e. z= x + j*y,
> where x,y are real.
>
> Does AMPL/MINOS suport such complex variables?
>
> Does somebody know, any other solver that support them?
>
> Your help will be greatly appreciated,
>
> -Diego Perea
> Ph.D. student
> Ecole Polytechnique de Montreal.
>

RE: [AMPL 3009] Converting if-then-else statement to linear equations

2009-11-13T16:52:28Z

The CPLEX message about a "nonquadratic nonlinear constraint" is due to the
use of a variable following "if" in the constraint expression. CPLEX
doesn't recognize this as the sort of linear or quadratic expression that it
can deal with.

The "presolve" messages are indicating that there are no feasible values for
your variables, because your constraints imply conflicting bounds for some
of them. Without seeing the whole model I can't be sure why that is.

However, it seems to me that if your variables are nonnegative then it would
suffice for you to write the constraints

t[i,m] >= a[i,m] - U[i,m] * (1-y[i,m])

where U[i,m] is an upper limit on the value that variable a[i,m] can be
expected to take. (For best results U[i,m] should not be chosen any larger
than necessary.) If the variables can be negative then you would also need

t[i,m] >= L[i,m] * y[i,m]

where L[i,m] is a (negative) lower limit on the value that variable t[i,m]
can be expected to take. With CPLEX you can also express these conditions
using "indicator constraints" that are written in AMPL as

y[i,m] = 1 ==> t[i,m] >= a[i,m];
y[i,m] = 0 ==> t[i,m] >= 0;

where of course the second is unnecessary variables that are already
declared nonnegative.

Bob Fourer
4er@...

> -----Original Message-----
> From: hessam [mailto:hessam.1983@...]
> Sent: Friday, November 13, 2009 5:32 PM
> To: AMPL Modeling Language
> Subject: [AMPL 3008] Converting if-then-else statement to linear equations
>
> Hi,
>
> I'm trying to implement the following condition in AMPL+CPLEX
> solver: (t[i,m] >= a[i,m]*y[i,m]) , in this condition, variables "t"
> and "a" are numbers and variable "y" in binary.
>
> I try to implement this in AMPL like this:
> --------------------------------------------------------------------------
> -----------
> subject to ......... : t[i,m]>= (if y[i,m]=1 then a[i,m] else 0);
> --------------------------------------------------------------------------
> -----------
>
> but I receive the following error in the AMPL:
> CPLEX 11.2.1: /tmp/at13284.nl contains a nonquadratic nonlinear
> constraint.
>
> Then I tried to implement the constraint as linear equations so I
> define a new variable named "ya" and I wrote the conditions as
> following:
>
> subject to contition1 .....: t[i,m]>= ya[i,m];
> subject to contition2 .....: a[i,m]>= ya[i,m];
> subject to contition3 .....: ya[i,m]>= 0;
> subject to contition4 .....: M*y[i,m] >= ya[i,m];
> subject to contition5 .....: M*(1-y[i,m])>=a[i,m]-ya[i,m];
>
> M is an arbitrary big number. With this conditions, if y[i,m]=0 then
> with condition 3 & 4 we can claim ya[i,m]=0 and if y[i,m]=1 then with
> condition 2 & 5 we can claim ya[i,m]=a[i,m]. BUT when I try to solve
> my ILP, I receive the following errors in AMPL:
> presolve, variable ya[46,3,2]:
> impossible deduced bounds: lower = 0, upper = -2.1338e-11
> presolve, variable ya[46,3,1]:
> impossible deduced bounds: lower = 0, upper = -2.1338e-11
> presolve, variable ya[46,2,2]:
> impossible deduced bounds: lower = 0, upper = -0.000546142
> presolve, variable ya[46,2,1]:
> impossible deduced bounds: lower = 0, upper = -0.000546142
> presolve, variable ya[46,1,2]:
> impossible deduced bounds: lower = 0, upper = -0.00157774
>
>
> What is the problem?? Why I can't have if-then-else statement in my
> code??
>
> Thanks all,
>
>
>
> --
>
> You received this message because you are subscribed to the Google Groups
> "AMPL Modeling Language" group.
> To post to this group, send email to ampl@....
> To unsubscribe from this group, send email to
> ampl+unsubscribe@....
> For more options, visit this group at
> http://groups.google.com/group/ampl?hl=.
>

[AMPL 3008] Converting if-then-else statement to linear equations

2009-11-13T15:32:22Z

Hi,

I'm trying to implement the following condition in AMPL+CPLEX
solver: (t[i,m] >= a[i,m]*y[i,m]) , in this condition, variables "t"
and "a" are numbers and variable "y" in binary.

I try to implement this in AMPL like this:
-------------------------------------------------------------------------------------
subject to ......... : t[i,m]>= (if y[i,m]=1 then a[i,m] else 0);
-------------------------------------------------------------------------------------

but I receive the following error in the AMPL:
CPLEX 11.2.1: /tmp/at13284.nl contains a nonquadratic nonlinear
constraint.

Then I tried to implement the constraint as linear equations so I
define a new variable named "ya" and I wrote the conditions as
following:

subject to contition1 .....: t[i,m]>= ya[i,m];
subject to contition2 .....: a[i,m]>= ya[i,m];
subject to contition3 .....: ya[i,m]>= 0;
subject to contition4 .....: M*y[i,m] >= ya[i,m];
subject to contition5 .....: M*(1-y[i,m])>=a[i,m]-ya[i,m];

M is an arbitrary big number. With this conditions, if y[i,m]=0 then
with condition 3 & 4 we can claim ya[i,m]=0 and if y[i,m]=1 then with
condition 2 & 5 we can claim ya[i,m]=a[i,m]. BUT when I try to solve
my ILP, I receive the following errors in AMPL:
presolve, variable ya[46,3,2]:
impossible deduced bounds: lower = 0, upper = -2.1338e-11
presolve, variable ya[46,3,1]:
impossible deduced bounds: lower = 0, upper = -2.1338e-11
presolve, variable ya[46,2,2]:
impossible deduced bounds: lower = 0, upper = -0.000546142
presolve, variable ya[46,2,1]:
impossible deduced bounds: lower = 0, upper = -0.000546142
presolve, variable ya[46,1,2]:
impossible deduced bounds: lower = 0, upper = -0.00157774

What is the problem?? Why I can't have if-then-else statement in my
code??

Thanks all,

--

You received this message because you are subscribed to the Google Groups "AMPL Modeling Language" group.
To post to this group, send email to ampl@....
To unsubscribe from this group, send email to ampl+unsubscribe@....
For more options, visit this group at http://groups.google.com/group/ampl?hl=.