private void NEWDASH(frmCONOP frm, Graphics g, int rnki, int rnkj, int rnkt, int cl1, int cl2)
{
COMMOD COMMOD9 = COMMOD.Singleton();
double xrl, yrl;
//CPMS---------------------------------------------------
//CPMS Used for MID events that always lie in a white range!
//CPMS other unpaired events must be BLACKED out
//CPMS rnki - the old dash position in range
//CPMS rnkj - the key to event (row) number
//CPMS rnkt - and the new dash position
xrl = 0.0;
yrl = 0.0;
//cpms fix the row to modify
yrl = (double)((COMMOD9.IROWS[COMMOD9.LSTPERM[rnkj], 0] + 1) * COMMOD9.YSPAN / COMMOD9.YROWS);
//white-out/blackout the old dash
xrl = (double)(rnki + 1) * COMMOD9.XSPAN / (double)COMMOD9.NEVNT;
frm.SetColor(cl1);
DASH(frm, g, xrl, yrl);
//draw the new red dash
xrl = (double)(rnkt + 1) * COMMOD9.XSPAN / (double)COMMOD9.NEVNT;
frm.SetColor(cl2);
DASH(frm, g, xrl, yrl);
frm.SetColor(15);
}
private void EDITCHT(frmCONOP frm, Graphics g, int ranki, int rankj)
{
COMMOD COMMOD9 = COMMOD.Singleton();
int rankt;
int typei, typej, typet;
// limits of screen resolution: maxx maxy
// margins outside graph box: top btm lft rit
int scl = 0;
int top = 0;
int btm = 50;
int lft = 100;
int rit = 0;
//CPMS---------------------------------------------------------------------
//CPMS Edit the range lines
typei = COMMOD9.IROWS[COMMOD9.LSTPERM[ranki], 1];
typej = COMMOD9.IROWS[COMMOD9.LSTPERM[rankj], 1];
//CPMS---------------------------------------------------------------------
//CPMS CASE 1 ranki moves up to j; intermediates move down 1 rank
//CPMS---------------------------------------------------------------------
if (ranki < rankj)
{
//edit ranki to rankj regardless of neighborhood size
if ((typei == 1) || (typei == 2) || (typei == 11) || (typei == 12))
{
//ranki is a paired range end; edit bar
//if ranki is a FAD or MAX; range base must be blanked up to rankj
//if ranki is a last; range top must be extended in white/gold
frm.SetColor(0);
if (typei == 2) frm.SetColor(15);
if (typei == 12) frm.SetColor(14);
CLIP(frm, g, ranki, ranki, rankj);
}
else if ((typei > 3) || (typei < 1))
{
//ranki is an unpaired event; move dash up
NEWDASH(frm, g, ranki, ranki, rankj, 0, 14);
}
else if (typei == 3)
{
NEWDASH(frm, g, ranki, ranki, rankj, 15, 12);
}
//CPMS if ranks j and i switch
if (COMMOD9.NABRGEN > 1)
{
//edit rankj to ranki
if ((typej == 1) || (typej == 2) || (typej == 11) || (typej == 12))
{
//rankj is a paired range end; edit bar
//if rankj is a first: extend base of range bar
//if ranki is a last; blank out range end
frm.SetColor(15);
if (typej == 11) frm.SetColor(14);
if (typej == 2) frm.SetColor(0);
if (typej == 12) frm.SetColor(0);
CLIP(frm, g, ranki, rankj, rankj);
}
else if ((typej > 3) || (typej < 1))
{
//rankj is an unpaired event; move dash down
NEWDASH(frm, g, rankj, rankj, ranki, 0, 14);
}
else if (typej == 3)
{
NEWDASH(frm, g, rankj, rankj, ranki, 15, 12);
}
}
//CPMS if making big single moves
if (COMMOD9.NABRGEN == 1)
{
rankt = ranki + 1;
while (rankt <= rankj)
{
typet = COMMOD9.IROWS[COMMOD9.LSTPERM[rankt], 1];
//move all intermediate events down 1 rank
if ((typet == 1) || (typet == 2) || (typet == 11) || (typet == 12))
{
//if rankt is a first; extend the range bar down 1 rank
//if rankt is a last; blank range bar down one rank from top
frm.SetColor(15);
if (typet == 11) frm.SetColor(14);
if (typet == 2) frm.SetColor(0);
if (typet == 12) frm.SetColor(0);
CLIP(frm, g, rankt - 1, rankt, rankt);
}
else if ((typet > 3) || (typet < 1))
{
//rankt is an unpaired event, move dash down 1
NEWDASH(frm, g, rankt, rankt, rankt - 1, 0, 14);
}
else if (typet == 3)
{
NEWDASH(frm, g, rankt, rankt, rankt - 1, 15, 12);
}
rankt++;
}
}
}
else if (ranki > rankj)
{
//CPMS----------------------------------------------------------------------
//CPMS CASE 2 ranki moves down to j and intermediate ranks move up 1 rank
//CPMS----------------------------------------------------------------------
//edit ranki to rankj regardless of neighborhood size
if ((typei == 1) || (typei == 2) || (typei == 11) || (typei == 12))
{
//ranki is a paired range end; edit bar
//if ranki is a first; extend base of range bar
//if ranki is a last; blank out range end
frm.SetColor(15);
if (typei == 11) frm.SetColor(14);
if (typei == 2) frm.SetColor(0);
if (typei == 12) frm.SetColor(0);
CLIP(frm, g, rankj, ranki, ranki);
}
else if ((typei > 3) || (typei < 1))
{
//ranki is an unpaired event; move dash down
NEWDASH(frm, g, ranki, ranki, rankj, 0, 14);
}
else if (typei == 3)
{
NEWDASH(frm, g, ranki, ranki, rankj, 15, 15);
}
//CPMS if ranks j and i switch:
if (COMMOD9.NABRGEN > 1)
{
//edit rankj to ranki if making double switch
if ((typej == 1) || (typej == 2) || (typej == 11) || (typej == 12))
{
//rankj is a paired range end; edit bar
//if rankj is a first; range base must be blanked up to ranki
//if rankj is a last; range top must be extended
frm.SetColor(0);
if (typej == 2) frm.SetColor(15);
if (typej == 12) frm.SetColor(14);
//move to left end (j) of modification
CLIP(frm, g, rankj, rankj, ranki);
}
else if ((typej > 3) || (typej < 1))
{
//rankj is an unpaired event; move dash up
NEWDASH(frm, g, rankj, rankj, ranki, 0, 14);
}
else if (typej == 3)
{
NEWDASH(frm, g, rankj, rankj, ranki, 15, 12);
}
}
//if making big single moves (BIGNABR)
if (COMMOD9.NABRGEN == 1)
{
rankt = ranki - 1;
while (rankt >= rankj)
{
typet = COMMOD9.IROWS[COMMOD9.LSTPERM[rankt], 1];
//intermediate ranks move up 1 rank
if ((typet == 1) || (typet == 2) || (typet == 11) || (typet == 12))
{
//if rankt is a first; blank out range start
//if rankt is a last; extend end of range bar
frm.SetColor(0);
if (typet == 2) frm.SetColor(15);
if (typet == 12) frm.SetColor(14);
//move to left end (t) of modification
CLIP(frm, g, rankt, rankt, rankt + 1);
}
else if ((typet > 3) || (typet < 1))
{
//rankt is an unpaired event, move dash up 1
NEWDASH(frm, g, rankt, rankt, rankt + 1, 0, 14);
}
else if (typet == 3)
{
NEWDASH(frm, g, rankt, rankt, rankt + 1, 15, 12);
}
rankt--;
}
}
}
//CPMS--------------------------------
//CPMS restore default graphics mode
frm.SetColor(15);
}
private void DRAWTEMP(frmCONOP frm, Graphics g)
{
COMMOD COMMOD9 = COMMOD.Singleton();
string cnt;
string cool;
frm.SetColor(15);
cool = string.Format("{0:0.000000000}", COMMOD9.T);
cnt = string.Format("{0}", COMMOD9.NTRIES);
cool = "temp: " + cool.Trim() + " [null: " + cnt.Trim() + "]";
cnt = string.Format("{0:0.00000}", COMMOD9.Rx);
cool = cool.Trim() + " {ratio: " + cnt.Trim() + "}";
g.DrawString(cool.Trim(), frm.MSG_FONT_S, frm.DW_Brush, (int)(COMMOD9.maxx / 1.5), (int)(COMMOD9.maxy - 12));
}
//---------------------------------------------------------------
//Subroutine to draw a range chart that illustrates the sequence
//of observed events in one feasible solution
//
//May be "animated" using editcht which alters the range chart to
//reflect sequence changes made by GONABR.FOR
//
//Programmer: Pete Sadler
//Last Modified: January 11 1997
//---------------------------------------------------------------
private void DRAWCHT(frmCONOP frm, Graphics g, int trj, int[] HPERM)
{
COMMOD COMMOD9 = COMMOD.Singleton();
int I, typsc;
int dinc, horscl, font, topfont, dum1, dum2;
double xreal, yreal;
//CPMS--WINDOWS Font Management
int numfonts, index;
int horiz, vert;
int scl, top, btm, lft, rit;
//C----------------------------------------------------------------------
//CPMS limits of screen resolution: maxx maxy
//CPMS margins outside graph box: top btm lft rit
//C----------------------------------------------------------------------
string ltr;
string xtitle = "";
string ytitle = "";
string etitl = "";
//CPMS----------------------------------------------
//CPMS TRJ.LT.2 redraw whole graph
//CPMS TRJ.EQ.2 refresh range lines
//CPMS TRJ.EQ.3 skeleton graph for event plots
//CPMS----------------------------------------------
scl = 0;
top = 0;
btm = 50;
lft = 100;
rit = 0;
//CPMS-----------------------------------------------
horiz = 0;
vert = -90;//900 in Fortran
I = 1 - 1;//<=HXD
Brush brush = frm.MSG_BRUSH_WHITE;
Pen pen = new Pen(brush);
Label100:
//CPMS-----------------------------------------
if (trj != 2)
{
//pause to allow viewing of previous graph
//clear the screen
g.Clear(frm.BackColor);
//draw the axis with current font
XSCALE(frm, g, COMMOD9.NEVNT, COMMOD9.maxx, COMMOD9.maxy, lft, rit, btm);
}
//CPMS---------------------------------------------------------------------
if (trj != 3)
{
//CPMS Draw full range lines for paired events only
//C if number of available lines is less than the number of taxa+others
//C then the following needs to be rewritten so that
//C 1. it allots one line to each event
//C 2. it stops drawing event ranges after the bottom line on the screen
for (scl = 0; scl < COMMOD9.NEVNT; scl++)
{
if ((COMMOD9.IROWS[HPERM[scl], 1] == 1) ||
(COMMOD9.IROWS[HPERM[scl], 1] == 11))
{
//draw full white/gold line for FADs and MAXsonly, to represent
//FAD-LAD pairs or FAD-MID-LAD triplets, or MAX-MIN pairs
brush = frm.MSG_BRUSH_WHITE;
pen = new Pen(brush);
if (COMMOD9.IROWS[HPERM[scl], 1] == 11)
{
brush = frm.MSG_BRUSH_14;
pen = new Pen(brush);
}
//they will be clipped to range length below
//other lines are blanks, awaiting a colored dash
//if this is the Ith taxon, vchange the line color
if ((trj == 0) && (COMMOD9.IROWS[HPERM[scl], 2] == I))
{
brush = frm.MSG_BRUSH_11;
pen = new Pen(brush);
Helper.GETEVNT(HPERM[scl], ref etitl, 1, 1, 0, 0, 0, 1);
g.TranslateTransform((int)(lft / 2), (int)(COMMOD9.maxy - btm));
g.RotateTransform(vert);
g.DrawString(etitl, frm.MSG_FONT_S, brush, 0, 0);
g.ResetTransform();
}
yreal = (double)(COMMOD9.IROWS[HPERM[scl], 0] + 1) * COMMOD9.YSPAN / COMMOD9.YROWS;
g.DrawLine(pen, lft, top + (int)(yreal), COMMOD9.maxx - rit, top + (int)(yreal));
}
}
//CPMS---------------------------------------------------------------------
//CPMS Clip the range lines
//CPMS
//CPMS the horizontal position is given by IROWS(HPERM(scl),1
//CPMS the end to cut is given by IROWS(HPERM(scl),2
//CPMS the length of cut is given by position in HPERM (i.e. scl)
brush = frm.MSG_BRUSH;
pen = new Pen(brush);
for (scl = 0; scl < COMMOD9.NEVNT; scl++)
{
typsc = COMMOD9.IROWS[HPERM[scl], 1];
xreal = (double)(scl + 1) * COMMOD9.XSPAN / (double)(COMMOD9.NEVNT);
yreal = (double)(COMMOD9.IROWS[HPERM[scl], 0] + 1) * COMMOD9.YSPAN / COMMOD9.YROWS;
if ((typsc == 1) || (typsc == 11))
{
//paired event - FAD or MAX - cut from left
g.DrawLine(pen, lft, top + (int)(yreal), lft + (int)(xreal), top + (int)(yreal));
}
else if ((typsc == 2) || (typsc == 12))
{
// paired event - LAD or MIN - cut to right
g.DrawLine(pen, lft + (int)(xreal), top + (int)(yreal), COMMOD9.maxx - rit, top + (int)(yreal));
}
else if ((typsc >= 3) || (typsc < 1))
{
brush = frm.MSG_BRUSH_14;
pen = new Pen(brush);
if (typsc == 3)
{
brush = frm.MSG_BRUSH_12;
pen = new Pen(brush);
}
g.DrawLine(pen, lft + (int)(xreal) - 1, top + (int)(yreal), lft + (int)(xreal) + 1, top + (int)(yreal));
brush = frm.MSG_BRUSH;
pen = new Pen(brush);
}
}
}
if (trj != 2)
{
//Add the legend and scales
brush = frm.MSG_BRUSH_WHITE;
xtitle = "TIME SCALE WITH ONE UNIT FOR EVERY OBSERVED EVENT";
if (trj == 3)
{
ytitle = " Penalty vs Position of One Event in Sequence";
}
else
{
ytitle = "TAXON NUMBER";
}
g.DrawString(xtitle.Trim(), frm.MSG_FONT_XS, brush, (int)(COMMOD9.maxx / 1.7), (int)(COMMOD9.maxy - btm / 1.9));
if (trj == 3)
{
Helper.GETEVNT(COMMOD9.XEVNT, ref xtitle, 1, 1, 1, 1, 1, 1);
brush = frm.MSG_BRUSH_10;
g.DrawString(xtitle.Trim(), frm.MSG_FONT_XS, brush, 5, (int)(COMMOD9.maxy - 32));
}
brush = frm.MSG_BRUSH_12;
g.DrawString(COMMOD9.PROJNAME, frm.MSG_FONT_XS, brush, 5, (int)(COMMOD9.maxy - 12));
}
if (trj != 2)
{
brush = frm.MSG_BRUSH_WHITE;
if (trj == 3) { brush = frm.MSG_BRUSH_10; }
g.TranslateTransform((int)(lft / 2.7), (int)(COMMOD9.maxy - btm - 25));
g.RotateTransform(vert);
g.DrawString(ytitle.Trim(), frm.MSG_FONT_XS, brush, 0, 0);
g.ResetTransform();
if (COMMOD9.TRJGRF > 0 && trj == 1) { brush = frm.MSG_BRUSH_10; }
WRITEPEN(frm, g, brush, 1);
}
if (trj != 2)
{
//CALL setgtextvector(INT2(0),INT2(1))??
switch (COMMOD9.SOLVEF)
{
case 4:
case 5:
frm.SetColor(1);
g.DrawString("Squeeze Penalty", frm.MSG_FONT_XS, frm.DW_Brush,
(int)(lft / 2.7), (int)(COMMOD9.maxy - btm - 240));
break;
case 6:
case 7:
frm.SetColor(1);
g.DrawString("Shrink Penalty", frm.MSG_FONT_XS, frm.DW_Brush,
(int)(lft / 2.7), (int)(COMMOD9.maxy - btm - 240));
break;
case 8:
case 9:
frm.SetColor(1);
g.DrawString("Tease (" + COMMOD9.STAKNAME + ") Penalty", frm.MSG_FONT_XS, frm.DW_Brush,
(int)(lft / 2.7), (int)(COMMOD9.maxy - btm - 240));
break;
}
if ((COMMOD9.SOLVEF != 2) && (COMMOD9.SOLVEF != 4) && (COMMOD9.SOLVEF != 6) &&
(COMMOD9.SOLVEF != 8))
{
frm.SetColor(4);
g.TranslateTransform((int)(lft / 4), (int)(COMMOD9.maxy - btm - 190));
g.RotateTransform(vert);
g.DrawString("COOLING SCHEDULE", frm.MSG_FONT_XS, frm.DW_Brush, 0, 0);
g.ResetTransform();
g.DrawString("zero temp", frm.MSG_FONT_S, frm.DW_Brush, (int)(lft / 10), (int)(COMMOD9.maxy - btm));
if (COMMOD9.PAUSF == 5)
{
//track NTRIES
if (COMMOD9.NTRIES > 0)
{
COMMOD9.CNTRIES = COMMOD9.NTRIES;
}
else
{
COMMOD9.LSTRIES = COMMOD9.CNTRIES;
}
DRAWTEMP(frm, g);
}
}
frm.SetColor(15);
}
if (trj != 2)
{
if (trj < 2)
{
//label every 10th taxon
for (scl = 9; scl < COMMOD9.NEVNT - COMMOD9.NSPC - COMMOD9.NMIDS; scl += 10)
{
yreal = (double)(scl + 1) * COMMOD9.YSPAN / COMMOD9.YROWS;
g.DrawString(string.Format("{0}", scl), frm.MSG_FONT_S, frm.DW_Brush,
lft - 25, top - (int)(yreal) - 5);
}
}
//CALL moveto(lft,top, xy)
}
if ((trj == 0) && (COMMOD9.PAUSF == 0))
{
//CALL NAVIKEY(I,NSPC,font,topfont,dinc,horscl,dum1,dum2,ltr)
//IF((I.eq.0).or.(ltr.eq.'Q'))return;
// GOTO 100
}
}
//cpms fills the EVERYBST array for BESTFILE
protected void FILLBEST(frmCONOP frm, Graphics g, int ISCOR, double RSCOR)
{
int X, Y;
//cpms - the penalty for the current solution
//cpms - goes into the BESTFILE
//CPMS*****************************************************
//CPMS run through the solution in sequence (EVERYBST cols)
//CPMS and enter the penalty for the appropriate
//CPMS event (EVERYBST rows), IF the best so far
//CPMS i.e. EVERYBST has IROWS order
COMMOD COMMOD9 = COMMOD.Singleton();
for (X = 0; X < COMMOD9.NEVNT; X++)
{
COMMOD9.EVERYBST[COMMOD9.PERM[X], X] =
Math.Min(COMMOD9.EVERYBST[COMMOD9.PERM[X], X], RSCOR);
//cpms update secondary penalty if necessary
//cpms SECNDBST stores secondary penalty BEFORE scaling: TO2PEN
if (COMMOD9.GRID2F == 1)
{
COMMOD9.SECNDBST[COMMOD9.PERM[X], X] =
Math.Min(COMMOD9.SECNDBST[COMMOD9.PERM[X], X], COMMOD9.TO2PEN);
}
// plot on screen if selected event
if ((ISCOR > 0) && (COMMOD9.PERM[X] == COMMOD9.XEVNT) && (COMMOD9.RUNGRF == 4))
{
frm.SetColor(10);
DRAWSCOR(frm, g, (double)(COMMOD9.NEVNT), (double)(COMMOD9.NEVNT - (X + 1)),
(double)ISCOR, RSCOR, 1, 2);
frm.SetColor(15);
}
}
if (COMMOD9.VERYBEST == COMMOD9.NXTPEN)
{
for (X = 0; X < COMMOD9.NEVNT; X++)
{
for (Y = 0; Y < COMMOD9.NSCT; Y++)
{
COMMOD9.HSCTRNG[X, Y, 0] =
Math.Max(COMMOD9.HSCTRNG[X, Y, 0], COMMOD9.HSCTSOL[X, Y]);
COMMOD9.HSCTRNG[X, Y, 1] =
Math.Min(COMMOD9.HSCTRNG[X, Y, 1], COMMOD9.HSCTSOL[X, Y]);
}
}
}
else if (COMMOD9.VERYBEST > COMMOD9.PEN)
{
for (X = 0; X < COMMOD9.NEVNT; X++)
{
for (Y = 0; Y < COMMOD9.NSCT; Y++)
{
COMMOD9.HSCTRNG[X, Y, 0] = COMMOD9.HSCTSOL[X, Y];
COMMOD9.HSCTRNG[X, Y, 1] = COMMOD9.HSCTSOL[X, Y];
}
}
COMMOD9.VERYBEST = Helper.MinVal(COMMOD9.EVERYBST);
}
}
public void RunItAndDraw(frmCONOP frm, Graphics g)
{
double DELTA;
double U;
int INNER, IRANK, JRANK, LAST, OUTER, NCTR, FIXM, NABRM;
int I, L, X, NCT;
//CPMS Declarations for graphics:
//CPMS PCT Percentage annealed
//CPMS INISCOR - extension penalty for initial solution
//CPMS BSTSCOR - best extension penalty to date
//CPMS SCORes do not include the smoothing factors
//CPMS I??SCOR - initial scores for scaling the screen plots
int INISCOR, ISMSCOR, ISQSCOR, ISHSCOR, ITSSCOR, INGSCOR;
int BSTSCOR, AUTSCOR;
double PCT;
int dummy, ulx, uly, lrx, lry, res, siz;
string SCORE;
int horiz, vert, div;
bool rndf, stepf, aimf, redf, trjf, algf, rlxf, rngf, hilf, s45f, s67f, s89f;
COMMOD COMMOD9 = COMMOD.Singleton();
//CPMS************************************************
//CPMS***PRELIMINARIES
//CPMS next section executes only once in a run
//CPMS------------------------------------------------
div = 0;
res = 0;
int scl = 0;
int top = 0;
int btm = 50;
int lft = 100;
int rit = 0;
//C initialize things for Intel 11.1
COMMOD9.UU = 0.0;
U = 0.0;
PCT = 0.0;
DELTA = 0.0;
INNER = 0;
IRANK = 0;
JRANK = 0;
LAST = 0;
OUTER = 0;
NCTR = 0;
FIXM = 0;
NABRM = 0;
I = 0;
L = 0;
X = 0;
NCT = 0;
//C initialized for Intel 9.0
horiz = 0;
vert = -90;//900 in Fortran
rndf = true;
INISCOR = 0;
ITSSCOR = 0;
ISMSCOR = 0;
ISQSCOR = 0;
ISHSCOR = 0;
INGSCOR = 0;
AUTSCOR = 0;
BSTSCOR = 0;
if ((COMMOD9.AUTF == 0) && (COMMOD9.CONTF == 0))
{
COMMOD9.BSTPEN = 0.0;
COMMOD9.BS2PEN = 0.0;
}
COMMOD9.TOOPEN = 0.0;
COMMOD9.TO2PEN = 0.0;
COMMOD9.TSPEN = 0.0;
COMMOD9.SMPEN = 0.0;
COMMOD9.SHPEN = 0.0;
COMMOD9.CRTPEN = 0.0;
COMMOD9.NEWRANK = 0;
//c NEWRANK is the rank to which the last (BIG|SML) mutation moved an event
//CPMS set the screen grabber corners
ulx = 0;
uly = 0;
lrx = COMMOD9.maxx - 1;
lry = COMMOD9.maxy - 1;
//C--------------------------------
//C set loop-accelerator flags
//C step-solutions (outer loop):
stepf = false;
if ((COMMOD9.STEPSOL.Substring(0, 3) != "OFF") && (COMMOD9.STEPSOL.Substring(0, 3) != "off"))
{
stepf = true;
}
//C aimed tempering (outer loop):
aimf = false;
if ((COMMOD9.SOLVEF == 3) && (COMMOD9.FIXF == 2)) aimf = true;
//C animated ranges:
rngf = false;
if ((COMMOD9.RUNGRF == 2) || (COMMOD9.RUNGRF == 5)) rngf = true;
//C penalty trajectory:
trjf = false;
if (((COMMOD9.RUNGRF == 2) || (COMMOD9.RUNGRF == 0)) && (COMMOD9.TRJGRF > 0)) trjf = true;
//C red temp curve (inner loop):
redf = false;
if (trjf)
{
if ((COMMOD9.RUNGRF != 0) && (COMMOD9.SOLVEF != 2) && (COMMOD9.SOLVEF != 4) &&
(COMMOD9.SOLVEF != 6) && (COMMOD9.SOLVEF != 8)) redf = true;
}
//C greedy algorithm:
algf = false;
if ((COMMOD9.SOLVEF == 2) || (COMMOD9.SOLVEF == 4) || (COMMOD9.SOLVEF == 6) ||
(COMMOD9.SOLVEF == 8)) algf = true;
//C relaxed fit update:
rlxf = false;
if ((COMMOD9.RUNGRF >= 4) || (COMMOD9.GRIDF == 1)) rlxf = true;
//C uphill moves in different color:
hilf = false;
if ((COMMOD9.SOLVEF != 2) && (COMMOD9.TRJGRF >= 3)) hilf = true;
//C SOLVEF 4 or 5 (squeeze):
s45f = false;
if ((COMMOD9.SOLVEF == 4) || (COMMOD9.SOLVEF == 5)) s45f = true;
//C SOLVEF 6 or 7 (shrink)
s67f = false;
if ((COMMOD9.SOLVEF == 6) || (COMMOD9.SOLVEF == 7)) s67f = true;
//C SOLVEF 8 or 9 (stack)
s89f = false;
if ((COMMOD9.SOLVEF == 8) || (COMMOD9.SOLVEF == 9)) s89f = true;
//C--------------------------------
//C set the initial temperature
NCTR = 0;
COMMOD9.CTRF = 0;
COMMOD9.NBETR = 0;
if (COMMOD9.CONTF == 1) goto Label111;
switch (COMMOD9.AUTF)
{
case 0:
//cpms not PAUSES='AUT','ADA'
COMMOD9.T = COMMOD9.STARTT;
break;
case 1:
//cpms still improving in last TRIALS - don't cool
//COMMOD9.T=COMMOD9.T;
COMMOD9.Rx = COMMOD9.R;
break;
case -1:
//cpms nothing better found in last TRIALS - cool
//c The following line cools by a fixed amount
//c T = T*R
//c In the alternative the size of the
//c cooling step increases as the
//c size of the null sets increases
//c for adaprive cooling
COMMOD9.Rx = COMMOD9.R;
if ((COMMOD9.ADAF == 1) && (COMMOD9.NTRIES > 0) && (COMMOD9.LSTRIES > 1))
{
L = COMMOD9.RANDOM.Next(Math.Min(COMMOD9.LSTRIES, 5) + 1);//<=HXD
COMMOD9.Rx = Math.Pow(COMMOD9.R, L);
COMMOD9.NTRIES = COMMOD9.NTRIES + (L - 1);
}
COMMOD9.T = COMMOD9.T * COMMOD9.Rx;
break;
}
Label111:
PCT = COMMOD9.NINNER * COMMOD9.NOUTER;
//C--------------------------------------------------------
//CPMS alter OUTF so that GETPEN does not write to outmain
//CPMS
//** OUTF = OUTF-100
//CPMS
//C COMPUTE THE BEST PLACEMENTS THAT COMPLY WITH STARTING PERM
//C "INIPERM" AND RESULTING PENALTY.
//C PUT THE placements in SCTSOL and the PENALTY IN PEN
//C
//C for the first permutation, we need a complete solution.
//C for subsequent perms, we may use reoptimization.
//C---------------------------------------------------------
if (COMMOD9.PENF <= 1)
{
Helper.GETPEN(COMMOD9.INIPERM, ref COMMOD9.NXTPEN);
}
else if (COMMOD9.PENF >= 2)
{
Helper.DEMPEN(COMMOD9.INIPERM, ref COMMOD9.NXTPEN);
}
//CPMS*********************************************
//CPMS PRELIMINARIES - not included in loops
Helper.CopyArray(COMMOD9.INIPERM, ref COMMOD9.PERM);
Helper.CopyArray(COMMOD9.INIPERM, ref COMMOD9.LSTPERM);
Helper.CopyArray(COMMOD9.INIPERM, ref COMMOD9.PXLPERM);
if (COMMOD9.CONTF == 0) Helper.CopyArray(COMMOD9.INIPERM, ref COMMOD9.BSTPERM);
COMMOD9.PEN = COMMOD9.NXTPEN;
COMMOD9.INIPEN = COMMOD9.NXTPEN;
INISCOR = (int)COMMOD9.INIPEN;
AUTSCOR = (int)COMMOD9.NXTPEN;
if (COMMOD9.AUTF == 0)
{
if (COMMOD9.CONTF == 0) COMMOD9.BSTPEN = COMMOD9.NXTPEN;
}
else
{
if (COMMOD9.CONTF == 0) COMMOD9.BSTPEN = COMMOD9.AUTPEN;
}
BSTSCOR = (int)COMMOD9.BSTPEN;
//Helper.DOTOO();
COMMOD9.NGTPEN = COMMOD9.NGHPEN;
INGSCOR = (int)COMMOD9.NGTPEN;
if ((COMMOD9.AUTF == 0) && (COMMOD9.CONTF == 0))
{
COMMOD9.BS2PEN = COMMOD9.TOOPEN;
COMMOD9.SQBST = COMMOD9.SQPEN;
COMMOD9.SHBST = COMMOD9.SHPEN;
COMMOD9.TSBST = COMMOD9.TSPEN;
}
ISQSCOR = (int)COMMOD9.SQPEN;
ISHSCOR = (int)COMMOD9.SHPEN;
COMMOD9.TSLST = COMMOD9.TSPEN;
ITSSCOR = (int)COMMOD9.TSPEN;
ISMSCOR = (int)COMMOD9.SMPEN;
if ((COMMOD9.KSM > 0.0) && (COMMOD9.PENF < 2))
{
ISMSCOR = (int)(COMMOD9.SMPEN / COMMOD9.KSM);
INISCOR = (int)(COMMOD9.PEN - COMMOD9.SMPEN);
BSTSCOR = (int)(COMMOD9.BSTPEN - COMMOD9.SMPEN);
}
if (COMMOD9.CTRF == 1)
{
NCT = NCT + 1;
COMMOD9.CTRF = 0;
}
if (COMMOD9.GRID2F == 1)
{
//cpms make sure that the .gr2 file records initial permutation
for (X = 0; X < COMMOD9.NEVNT; X++)
{
//cpms update secondary penalty
COMMOD9.SECNDBST[COMMOD9.PERM[X], X] =
Math.Min(COMMOD9.SECNDBST[COMMOD9.PERM[X], X], COMMOD9.TO2PEN);
}
}
//C-----------------------------------------------------------------------
//C to speed up reoptimization (in EVALUATE), keep track of
//C the last action taken during annealing.
//C if the new PERM was accepted,
//C SCTSOL and HSCTSOL will already be the same, and there is no need
//C to copy SCTSOL to HSCTSOL before reoptimization.
//C if the new permutation is not accepted, copy SCTSOL to HSCTSOL
//C use the flag LAST:
//C LAST = 1, accepted the new PERM
//C LAST = 0, did not accept the new PERM
//C since GETPEN calculates HSCTSOL, and we assign that to SCTSOL,
//C initialize it to 1.
//C-----------------------------------------------------------------------
//C put the initial perm in PERM, the initial penalty in PEN, and
//C USE PERM AND PEN AS THE INITIAL "BEST" VALUES
//C-----------------------------------------------------------------------
Helper.CopyArray(COMMOD9.HSCTSOL, ref COMMOD9.SCTSOL);
Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
LAST = 1;
COMMOD9.XPOSN = 0;
if (COMMOD9.FIXF == 3)
{
for (COMMOD9.XPOSN = 0; COMMOD9.XPOSN < COMMOD9.NEVNT; COMMOD9.XPOSN++)
{
if (COMMOD9.PERM[COMMOD9.XPOSN] == COMMOD9.XEVNT) break;
}
}
//HACK:OMIT MANY LINES
//CPMS --if plotting during run-----------------
if (rngf)
{
if (COMMOD9.CONTF == 1)
{
DRAWCHT(frm, g, 1, COMMOD9.INIPERM);
}
else
{
DRAWCHT(frm, g, 1, COMMOD9.BSTPERM);
}
}
else if (COMMOD9.RUNGRF == 4)
{
if (COMMOD9.CONTF == 1)
{
DRAWCHT(frm, g, 3, COMMOD9.INIPERM);
}
else
{
DRAWCHT(frm, g, 3, COMMOD9.BSTPERM);
}
}
else if (COMMOD9.MOVEF == 1)
{
//CALL EDITDIVE(0) ????
}
if (((COMMOD9.RUNGRF == 2) || (COMMOD9.RUNGRF >= 4)) && (COMMOD9.TRJGRF > 0))
{
//---if filling curves, decrease INISCOR to enlarge lower half of curve
if ((COMMOD9.RUNGRF == 4) && (COMMOD9.INIGEN != 2)) INISCOR = (int)(INISCOR / 2);
//---if tracking secondary penalties
//---scale them to half screen height
switch (COMMOD9.SOLVEF)
{
case 4:
case 5:
if (COMMOD9.INIGEN != 2) ISQSCOR = ISQSCOR * 2;
break;
case 6:
case 7:
if (COMMOD9.INIGEN != 2) ISHSCOR = ISHSCOR * 2;
break;
case 8:
case 9:
if (COMMOD9.INIGEN != 2) ITSSCOR = ITSSCOR * 2;
break;
}
if (COMMOD9.NEGATF > 0) INGSCOR = INGSCOR * 4;
//CPMS ---if starting from a previous solution on file--------------
if (COMMOD9.INIGEN == 2)
{
//starting from file gives a low initial penalty and the search
//frequently climbs higher; so the initial penalty is scaled to
//half the screen height!
INISCOR = INISCOR * 2;
//and the secondary penalty is scaled to 2/3 screen height
ISQSCOR = (int)((double)(ISQSCOR) * 1.3);
ISHSCOR = (int)((double)(ISHSCOR) * 1.3);
ITSSCOR = (int)((double)(ITSSCOR) * 1.3);
//and any negative penalty is scaled to 1/3 height
INGSCOR = (int)((double)(INGSCOR) * 3);
frm.SetColor(10);
if (COMMOD9.AUTF == 0) rndf = false;
YSCALE(frm, g, INISCOR, COMMOD9.maxx, COMMOD9.maxy, top, btm, lft - 1, res, rndf);
frm.SetColor(8);
SCORE = string.Format("{0}", INISCOR);
LBLSCOR(frm, g, SCORE, 0);
//label the initial penalty
if (COMMOD9.AUTF == 0) frm.SetColor(10);
SCORE = string.Format("{0}", AUTSCOR);
LBLSCOR(frm, g, SCORE, 1000 * (INISCOR - AUTSCOR) / INISCOR);
if (COMMOD9.AUTF != 0)
{
//label the best score (carried forward)
frm.SetColor(10);
SCORE = string.Format("{0}", BSTSCOR);
LBLSCOR(frm, g, SCORE, 1000 * (INISCOR - BSTSCOR) / INISCOR);
}
}
else//---else if starting from scratch------
{
//make top of y-axis a round number
//with resolution "res"
res = 0;
frm.SetColor(10);
YSCALE(frm, g, INISCOR, COMMOD9.maxx, COMMOD9.maxy, top, btm, lft - 1, res, rndf);
}
// plot the initial penalties:
// the next line had ninner twice: a mistake?
if ((COMMOD9.NINNER > 0) && (COMMOD9.NOUTER > 0) && (rngf))
{
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(INISCOR), (double)(BSTSCOR), 2, 1);
if (COMMOD9.NEGATF > 0)
{
//plot negative penalty in brown
frm.SetColor(6);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(INGSCOR), (double)(COMMOD9.NGHPEN), 0, 1);
}
//plot secondary penalties in dark blue
frm.SetColor(1);
switch (COMMOD9.SOLVEF)
{
case 1:
case 2:
case 3:
break;
case 4:
case 5:
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ISQSCOR), (double)(COMMOD9.SQPEN), 2, 1);
break;
case 6:
case 7:
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ISHSCOR), (double)(COMMOD9.SHPEN), 2, 1);
break;
case 8:
case 9:
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ITSSCOR), (double)(COMMOD9.TSPEN), 2, 1);
break;
}
frm.SetColor(15);
}
else if ((COMMOD9.NINNER > 0) && rlxf) //ELSE IF((NINNER.GT.0.).AND.(NINNER.GT.0.).AND.rlxf) THEN <=HXD??
{
FILLBEST(frm, g, INISCOR, (double)BSTSCOR);
}
else
{
frm.SetColor(15);
return;//???<=HXD
}
}
if (COMMOD9.RUNGRF == 4)
{
//plot the xevnt position
frm.SetColor(8);
for (I = 0; I < COMMOD9.NEVNT; I++)
{
if (INISCOR > (int)(COMMOD9.EVERYBST[COMMOD9.XEVNT, I]))
{
DRAWSCOR(frm, g, (double)COMMOD9.NEVNT, (double)(COMMOD9.NEVNT - (I + 1)),
(double)(INISCOR), COMMOD9.EVERYBST[COMMOD9.XEVNT, I], 1, 1);
}
}
frm.SetColor(0);
}
//cpms---reset CONTF after first pass through--------------
COMMOD9.CONTF = 0;
//CPMS*******************************************************************
//CPMS MAIN LOOPS
//C The following lines are executed with every trial!!
//C Analyse a big sequence of neighbors ('permutations').
//C Compute the penalty and decide whether to accept the new perm
//C according to the SOLVER option
//C-------------------------------------------------------------
//CPMS---Store two run parameters in case the last temper quench is
//CPMS to be "aimed" into the optimum with different parameters
//CPMS and the program must reset for another "RPT" run.
FIXM = COMMOD9.FIXF;
NABRM = COMMOD9.NABRGEN;
//Helper.Write("\n ");
//if (COMMOD9.PAUSF != 5)
//{
// Console.BackgroundColor = ConsoleColor.Blue;
//}
//CPMS**START THE OUTER LOOP***************
for (OUTER = 0; OUTER < (int)COMMOD9.NOUTER; OUTER++)
{
//CPMS check for "AIM"ed tempering
if ((aimf) && (OUTER == (int)COMMOD9.NOUTER - 1))
{
COMMOD9.FIXF = 0;
COMMOD9.NABRGEN = 2;
}
//CPMS write out best solution so far if requested
if ((stepf) && (COMMOD9.CDF != 1)) Helper.STEPOUT(COMMOD9.BSTPERM);
if ((stepf) && (COMMOD9.CDF != 1)) Helper.TRAJOUT();
//CPMS*****START THE INNER LOOP*********
for (INNER = 0; INNER < (int)COMMOD9.NINNER; INNER++)
{
PCT = PCT - 1;
//Draw the red temperature trajectory on the screen
//if not "greedy" or "squeeze" or "shrink" or "tease"
if (redf)
{
frm.SetColor("BB0000");
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, COMMOD9.STARTT, COMMOD9.T, 0, 1);
frm.SetColor(15);
}
//CPMS-----------------------------------------------------
//CPMS GENERATE A NEIGHBOR AS A CANDIDATE PERMUTATION
//CPMS after saving current state of secondary penalty
COMMOD9.TSLST = COMMOD9.TSPEN;
Helper.GONABR(ref IRANK, ref JRANK);
//CPMS****** This replaces the old calculation of PROB after penalty totalling
//CPMS****** It allows NEWPEN to exit the section loop as soon as the critical
//CPMS****** penalty size (CRTPEN) is reached.
//CPMS****** NEWPEN takes advantage of this, but NWDMPEN does not.....yet
//CPMS****** for a riley test, running time drops from 1.133 to 1.117 mins.
COMMOD9.UU = COMMOD9.RANDOM.NextDouble();
//if(COMMOD9.PEN>4000 && COMMOD9.PEN<5000)
// Helper.Write(" T={0} UU={1} Pen={2} ", COMMOD9.T,COMMOD9.UU,COMMOD9.PEN);
COMMOD9.CRTPEN = COMMOD9.PEN - (COMMOD9.T * Math.Log(COMMOD9.UU));
//if (COMMOD9.PEN > 4000 && COMMOD9.PEN < 5000)
// Helper.Write("CRTPEN={0}\n", COMMOD9.CRTPEN);
if (COMMOD9.PENF <= 1)
{
Helper.NEWPEN(IRANK, JRANK, COMMOD9.PERM, ref COMMOD9.NXTPEN);
}
else if (COMMOD9.PENF >= 2)
{
Helper.NWDMPEN(IRANK, JRANK, COMMOD9.PERM, ref COMMOD9.NXTPEN);
}
DELTA = COMMOD9.NXTPEN - COMMOD9.PEN;
//C-----------------------------------------------------------------------
//C DETERMINE WHETHER TO ACCEPT THE NEW PERM OR KEEP THE
//C OLD ONE
//C PEN is the previous penalty
//C NXTPEN is the candidate to replace PEN
//C DELTA is the difference
//C-----------------------------------------------------------------------
//C-----------------------------------------------------------------------
//c set the flag LAST to 0, saying that the new PERM
//C has not been accepted yet
//C
//C IF THE NEW PERM IS BETTER (OR AS GOOD and not "GREEDY"),
//C 1. ACCEPT IT, keep PERM, update PEN, TOOPEN and SCTSOL, AND
//C 2. SEE IF IT IS BEST SO FAR
//C IF IT IS, UPDATE THE BEST SO FAR (BSTPERM AND BSTPEN)
//C If a "SQUEEZE" run, accept only if squeeze penalty is not worse
//C-----------------------------------------------------------------------
LAST = 0;
//CPMS ? replace the next IF with DELTA.LE.0
//CPMS i.e. always accept an equally good move and save the checking time
//CPMS ?? leads to lots of repetitions
//CPMS ??? what is the snag for greedy?
//c /////////////////////////////////////////
//CPMS IF NEW SEQUENCE HAS SAME OR LOWER PENALTY
if ((DELTA < 0.0) ||
((DELTA == 0.0) && ((COMMOD9.SOLVEF < 2) ||
((s89f) && (COMMOD9.TSPEN <= COMMOD9.TSBST)) ||
((s67f) && (COMMOD9.SHPEN <= COMMOD9.SHBST)) ||
((s45f) && (COMMOD9.SQPEN <= COMMOD9.SQBST)))))
{
if (COMMOD9.MOVEF == 1)
{
//CALL EDITDIVE(1) ************************
}
if (COMMOD9.NEGATF > 0)
{
frm.SetColor(6);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(INGSCOR), (double)(COMMOD9.NGHPEN), 0, 1);
frm.SetColor(15);
}
frm.SetColor(1);
switch (COMMOD9.SOLVEF)
{
case 4:
case 5:
//plot sqpen in dark blue, if sqpen is unchanged
//primary penalty is not worse
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ISQSCOR), (double)(COMMOD9.SQPEN), 0, 1);
break;
case 6:
case 7:
//plot shpen in dark blue, if shpen is unchanged
//primary penalty is not worse
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ISHSCOR), (double)(COMMOD9.SHPEN), 0, 1);
break;
case 8:
case 9:
//plot tspen in dark blue, if tspen is unchanged
//primary penalty is not worse
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ITSSCOR), (double)(COMMOD9.TSPEN), 0, 1);
break;
}
frm.SetColor(15);
if (COMMOD9.CTRF == 1)
{
NCT = NCT + 1;
COMMOD9.CTRF = 0;
}
//update the penalties
COMMOD9.PEN = COMMOD9.NXTPEN;
COMMOD9.ASPNPEN = COMMOD9.SPANPEN;
Helper.DOTOO();
if (COMMOD9.PENF < 2)
{
Helper.CopyArray(COMMOD9.HSCTSOL, ref COMMOD9.SCTSOL);
}
Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
LAST = 1;
//if this is very best so far
if ((COMMOD9.PEN < COMMOD9.BSTPEN) || ((COMMOD9.PEN == COMMOD9.BSTPEN) &&
(((s89f) && (COMMOD9.TSPEN < COMMOD9.TSBST)) ||
((s67f) && (COMMOD9.SHPEN < COMMOD9.SHBST)) ||
((s45f) && (COMMOD9.SQPEN < COMMOD9.SQBST)))))
{
siz = 2;
if (COMMOD9.PEN == COMMOD9.BSTPEN) siz = 1;
if (COMMOD9.NEGATF > 0)
{
frm.SetColor(6);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(INGSCOR), (double)(COMMOD9.NGHPEN), 0, 1);
frm.SetColor(15);
}
//change color for secondary penalty
frm.SetColor(9);
switch (COMMOD9.SOLVEF)
{
case 4:
case 5:
if ((COMMOD9.SQPEN < COMMOD9.SQBST) || (COMMOD9.PEN < COMMOD9.BSTPEN))
{
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ISQSCOR), (double)(COMMOD9.SQPEN), 1, 1);
}
break;
case 6:
case 7:
if ((COMMOD9.SHPEN < COMMOD9.SHBST) || (COMMOD9.PEN < COMMOD9.BSTPEN))
{
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ISHSCOR), (double)(COMMOD9.SHPEN), 1, 1);
}
break;
case 8:
case 9:
if ((COMMOD9.TSPEN < COMMOD9.TSBST) || (COMMOD9.PEN < COMMOD9.BSTPEN))
{
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(ITSSCOR), (double)(COMMOD9.TSPEN), 1, 1);
}
break;
}
frm.SetColor(15);
COMMOD9.SQBST = COMMOD9.SQPEN;
COMMOD9.SHBST = COMMOD9.SHPEN;
COMMOD9.TSBST = COMMOD9.TSPEN;
COMMOD9.BSTPEN = COMMOD9.PEN;
COMMOD9.NBETR = COMMOD9.NBETR + 1;
COMMOD9.BS2PEN = COMMOD9.TOOPEN;
COMMOD9.NGTPEN = COMMOD9.NGHPEN;
BSTSCOR = (int)COMMOD9.BSTPEN;
if ((COMMOD9.KSM > 0.00) && (COMMOD9.PENF < 2)) BSTSCOR = BSTSCOR - (int)COMMOD9.SMPEN;
Helper.CopyArray(COMMOD9.PERM, ref COMMOD9.BSTPERM);
if (trjf)
{
//update trajectory on range graph
frm.SetColor(10);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)INISCOR, (double)BSTSCOR, siz, 1);
frm.SetColor(15);
//if smoothing, show smoothing penalty term too
if ((COMMOD9.KSM > 0.00) && (COMMOD9.PENF < 2))
{
BSTSCOR = (int)(COMMOD9.SMPEN / COMMOD9.KSM);
frm.SetColor(2);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)ISMSCOR, (double)BSTSCOR, 0, 1);
BSTSCOR = (int)(COMMOD9.BSTPEN - COMMOD9.SMPEN);
frm.SetColor(15);
}
}
}
// END OF penalty updates for acceptance
// Now edit the range lines because switch was accepted
if (rngf)
{
EDITCHT(frm, g, IRANK, JRANK);
//plot uphill moves in contrasting color!!
if (hilf)
{
//update trajectory on range graph
frm.SetColor(8);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT, (double)(INISCOR), COMMOD9.PEN, 1, 1);
frm.SetColor(15);
}
}
// END OF ACCEPTANCE ROUTINES
// update the relaxed fit curves
if (rlxf)
{
FILLBEST(frm, g, INISCOR, COMMOD9.PEN);
}
}
else
{
//C-----------------------------------------------------------------------
//C LOOK FOR PROBABILISTIC GROUNDS TO ACCEPT
//C EVEN IF THE NEW PERM IS WORSE THAN "PERM",
//C ACCEPT IT WITH PROBABILITY "PROB"
//C PROB replaced by CRTPEN - the critical penalty at PROB
//C //////////////////////////////////////////////////////////////
//NOT AN IMPROVEMENT
if (COMMOD9.NUDGER)
{
COMMOD9.NUDGUP = false;
COMMOD9.NUDGDN = false;
}
//CPMS reject and reset for greedy algorithm
//cpms and shrinker and squeezer and teaser
if (algf)
{
Helper.CopyArray(COMMOD9.LSTPERM, ref COMMOD9.PERM);
COMMOD9.TSPEN = COMMOD9.TSLST;
if (trjf)
{
//update trajectory on range graph
frm.SetColor(8);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT,
(double)INISCOR, (double)(BSTSCOR), 0, 1);
frm.SetColor(15);
}
}
else
{
//cpms-----------for squeal and anneas and steal--------
//cpms adjust U downward if 2nd penalty improves
//cpms and up if the 2nd penalty worsens
//cpms adjust according to the new/old ratio squared
//cpms the adjustments are likely to be small
//cpms but they increase geometrically as the
//cpms impact on the secondary penalty increases
//cpms
//cpms the efficiency of the promary search is compromised
//cpms but the secondary penalty is not allowed to
//cpms increase uncontrollably
switch (COMMOD9.SOLVEF)
{
case 1:
case 2:
case 3:
case 4:
case 6:
case 8:
break;
case 5:
if (COMMOD9.SQPEN > 0)
U = U * Math.Pow((COMMOD9.SQPEN / COMMOD9.SQBST), 2);
break;
case 7:
if (COMMOD9.SHPEN > 0)
U = U * Math.Pow((COMMOD9.SHPEN / COMMOD9.SHBST), 2);
break;
case 9:
if (COMMOD9.TSPEN > 0)
U = U * Math.Pow((COMMOD9.TSPEN / COMMOD9.TSBST), 2);
break;
}
//cpms-------------------------------------------------
if (COMMOD9.NXTPEN < COMMOD9.CRTPEN)
{
//CPMS ACCEPT UPHILL STEP
//CPMS and check contraction
if (COMMOD9.CTRF == 1)
{
NCT = NCT + 1;
COMMOD9.CTRF = 0;
}
if (COMMOD9.NEGATF > 0)
{
frm.SetColor(6);
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT,
(double)INGSCOR, (double)COMMOD9.NGHPEN, 0, 1);
frm.SetColor(15);
}
frm.SetColor(9);
switch (COMMOD9.SOLVEF)
{
case 1:
case 2:
case 3:
case 4:
case 6:
case 8:
break;
case 5:
COMMOD9.SQBST = COMMOD9.SQPEN;
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT,
(double)ISQSCOR, (double)COMMOD9.SQPEN, 0, 1);
break;
case 7:
COMMOD9.SHBST = COMMOD9.SHPEN;
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT,
(double)ISHSCOR, (double)COMMOD9.SHPEN, 0, 1);
break;
case 9:
COMMOD9.TSBST = COMMOD9.TSPEN;
DRAWSCOR(frm, g, COMMOD9.NOUTER * COMMOD9.NINNER, PCT,
(double)ITSSCOR, (double)COMMOD9.TSPEN, 0, 1);
break;
}
frm.SetColor(15);
//update total penalty and secondary penalty
COMMOD9.PEN = COMMOD9.NXTPEN;
COMMOD9.ASPNPEN = COMMOD9.SPANPEN;
Helper.DOTOO();
if (COMMOD9.PENF < 2)
{
Helper.CopyArray(COMMOD9.HSCTSOL, ref COMMOD9.SCTSOL);
}
Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
LAST = 1;
//Edit the range lines because bad switch is accepted
if (rngf)
{
EDITCHT(frm, g, IRANK, JRANK);
}
//CPMS Load the EVERYBST array and add points to
//CPMS the event bathtub - needs to be a separate subroutine
if (rlxf)
{
FILLBEST(frm, g, INISCOR, COMMOD9.PEN);
//run through the solution in sequence (EVERYBST cols)
//and enter the penalty for the appropriate
//event (EVERYBST rows), IF the best so far
//i.e. EVERYBST has IROWS order
}
}
else
{
//C-----------------------------------------------------------------------
//CPMS REJECT UPHILL STEP reset PERM to previous order (any NABRGEN!)
//CPMS no boxes plotted on the run-time graphic
//CPMS no update to PEN or TOOPEN
//CPMS--------------------------------------------------------
Helper.CopyArray(COMMOD9.LSTPERM, ref COMMOD9.PERM);
COMMOD9.TSPEN = COMMOD9.TSLST;
COMMOD9.CTRF = 0;
}
}
}//END if ELSE DELTA>0
//cpms if tempering:
if (COMMOD9.SOLVEF == 3) COMMOD9.T = COMMOD9.T * COMMOD9.R;
System.Windows.Forms.Application.DoEvents();
System.Threading.Thread.Sleep(0);
}//CPMS*****end of inner loop**************
//C lower the temperature and do it again if annealing
//C heat to random temperature and quench again if tempering (solvef=3)
if (COMMOD9.SOLVEF == 3)
{
U = COMMOD9.RANDOM.NextDouble();
//c PCT/NINNER*NOUTER runs from 1.0 to 0.0
//c IF random number is larger, try again
//c reduces frequency of hot tempers later in run
COMMOD9.T = COMMOD9.STARTT * PCT / (COMMOD9.NINNER * COMMOD9.NOUTER) * U;
if (COMMOD9.PENF < 2)
{
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.PEN);
}
else if ((COMMOD9.PENF == 5) || (COMMOD9.PENF == 6))
{
Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.PEN);
}
else if (COMMOD9.PENF > 1)
{
Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.PEN);
}
Helper.CopyArray(COMMOD9.BSTPERM, ref COMMOD9.PERM);
Helper.CopyArray(COMMOD9.HSCTSOL, ref COMMOD9.SCTSOL);
Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
//refresh the range lines
if (rngf) DRAWCHT(frm, g, 2, COMMOD9.BSTPERM);
}
else
{
if (COMMOD9.AUTF == 0) COMMOD9.T = COMMOD9.T * COMMOD9.R;
if ((COMMOD9.AUTF == 0) && (COMMOD9.CDF != 1)) Helper.TRAJOUT();
}
}//cpms**end of outer loop*********************************************
COMMOD9.AUTPEN = COMMOD9.BSTPEN;
COMMOD9.NUDGUP = false;
COMMOD9.NUDGDN = false;
//CPMS Now turn to tasks completed only once per run, AFTER annealing
//cpms-----------------
//CPMS restore FIXF and NABRGEN
COMMOD9.FIXF = FIXM;
COMMOD9.NABRGEN = NABRM;
//CPMS-----------------------------------------------------------
//CPMS write out last solution tried if requested
if ((COMMOD9.STEPSOL.Substring(0, 3) == "LST") ||
(COMMOD9.STEPSOL.Substring(0, 3) == "lst"))
{
if (COMMOD9.CDF != 1) Helper.STEPOUT(COMMOD9.LSTPERM);
if (COMMOD9.CDF != 1) Helper.TRAJOUT();
}
//C--------------------------------------------------------------
//C save value of PENF
LAST = COMMOD9.PENF;
//CPMS Try to prevent the remaining tasks from
//c running during auto-cooling until about to stop
if ((COMMOD9.PAUSF == 5) && (COMMOD9.NTRIES < COMMOD9.NSTOP - 1))
{
COMMOD9.NUDGUP = false;
COMMOD9.NUDGDN = false;
goto Label33;
}
//C after all NOUTER*NINNER passes through the loop,
//CPMS make sure that HSCTSOL reflects the best solution
//CPMS rather than the last tried
//CPMS and that HSCTSOL is last set according to correct penalty
//CPMS i.e. lvlpen if PENF=1, intpen for all other cases
if (COMMOD9.PENF == 1)
{
COMMOD9.PENF = -1;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.RVLPEN);
if (LAST == -1) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 0;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.INTPEN);
if (LAST == 0) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 1;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.LVLPEN);
if (LAST == 1) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
}
else if (COMMOD9.PENF == 0)
{
COMMOD9.PENF = -1;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.RVLPEN);
if (LAST == -1) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 1;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.LVLPEN);
if (LAST == 1) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 0;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.INTPEN);
if (LAST == 0) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
}
else if (COMMOD9.PENF == -1)
{
COMMOD9.PENF = 1;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.LVLPEN);
if (LAST == 1) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 0;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.INTPEN);
if (LAST == 0) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = -1;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.RVLPEN);
if (LAST == -1) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
}
COMMOD9.NGTPEN = COMMOD9.NGHPEN;
//CPMS GETPEN places local horizons to fit the best sequence
//CPMS but the final penalty needs to be returned to its
//CPMS "democratic" value for an ordinal search
COMMOD9.PENF = 6;
if (COMMOD9.FB4LF != 0) Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.SEQPEN);
COMMOD9.PENF = 5;
Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.ROYPEN);
COMMOD9.PENF = 7;
Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.MOMPEN);
if (LAST == 7) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 4;
Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.RSCPEN);
if (LAST == 4) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 3;
Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.SPTPEN);
if (LAST == 3) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
COMMOD9.PENF = 2;
Helper.DEMPEN(COMMOD9.BSTPERM, ref COMMOD9.ORDPEN);
if (LAST == 2) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
if (LAST == 5) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
if ((LAST == 6) && (COMMOD9.FB4LF != 0)) Helper.CopyArray(COMMOD9.COLPEN, ref COMMOD9.SCJPEN);
//C SCJPEN now contains the primary section penalties
//C But this is pointless for Royal (PENF=5)
//C and for Sequel (PENF=6) so
//C the ordinal penalty is used instead
if (LAST > 2)
{
COMMOD9.PENF = 0;
Helper.GETPEN(COMMOD9.BSTPERM, ref COMMOD9.INTPEN);
//C COLPEN now contains the ordinal or interval penalties
//C whichever contrasts with the primary
}
//c restore PENF
COMMOD9.PENF = LAST;
switch (COMMOD9.PENF)
{
case -1://eventual
COMMOD9.BSTPEN = COMMOD9.RVLPEN;
break;
case 0://interval
COMMOD9.BSTPEN = COMMOD9.INTPEN;
break;
case 1://level
COMMOD9.BSTPEN = COMMOD9.LVLPEN;
break;
case 2://ordinal
COMMOD9.BSTPEN = COMMOD9.ORDPEN;
break;
case 3://spatial
COMMOD9.BSTPEN = COMMOD9.SPTPEN;
break;
case 4://rascal/rascer
COMMOD9.BSTPEN = COMMOD9.RSCPEN;
break;
case 5://royal (Coex)
COMMOD9.BSTPEN = COMMOD9.ROYPEN;
break;
case 6://sequel (Fb4L)
if (COMMOD9.FB4LF != 0) COMMOD9.BSTPEN = COMMOD9.SEQPEN;
break;
case 7://momental
COMMOD9.BSTPEN = COMMOD9.MOMPEN;
break;
}
Label33:
if (((COMMOD9.RUNGRF == 2) || (COMMOD9.RUNGRF >= 4)) && (COMMOD9.TRJGRF > 0))
{
frm.SetColor(10);
BSTSCOR = (int)COMMOD9.BSTPEN;
SCORE = string.Format("{0}", BSTSCOR);
LBLSCOR(frm, g, SCORE, 1000 * (INISCOR - BSTSCOR) / INISCOR);
frm.SetColor(15);
}
//CPMS-------------------------------------------------------------
//CPMS transfer the number of contractions to a common variable
COMMOD9.CTRF = NCTR;
}
