Your SlideShare is downloading. ×
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Console manual impl
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Console manual impl

110

Published on

The IMPL console executable (IMPL.exe) can be called from any DOS command prompt window where its Intel Fortran source code can be found in Appendix A. The IMPL console is useful given that it allows …

The IMPL console executable (IMPL.exe) can be called from any DOS command prompt window where its Intel Fortran source code can be found in Appendix A. The IMPL console is useful given that it allows you to model and solve problems configured in an IML (Industrial Modeling Language) file. Problems coded using IPL (Industrial Programming Language) in many computer programming languages can use the IMPL console source code as a prototype.

The IMPL console reads several input files and writes several output files which are described in this document. There are several console flags that can be specified as command line arguments and are described below.

Published in: Engineering, Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
110
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
3
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1.                         i  M  P  l     Industrial  Modeling  &  Programming  Language     “Console  Manual"                       i  n  d  u  s  t  r  I  A  L  g  o  r  i  t  h  m  s    LLC.   www.industrialgorithms.com                 Version  1.0   April  2014   IAL-­‐IMPL-­‐CM-­‐1-­‐0.docx       Copyright  and  Property  of  Industrial  Algorithms  LLC.    
  • 2. Introduction     The  IMPL  console  executable  (IMPL.exe)  can  be  called  from  any  DOS  command  prompt  window  where   its  Intel  Fortran  source  code  can  be  found  in  Appendix  A.    The  IMPL  console  is  useful  given  that  it  allows   you  to  model  and  solve  problems  configured  in  an  IML  (Industrial  Modeling  Language)  file.    Problems   coded  using  IPL  (Industrial  Programming  Language)  in  many  computer  programming  languages  can  use   the  IMPL  console  source  code  as  a  prototype.     The  IMPL  console  reads  several  input  files  and  writes  several  output  files  which  are  described  in  this   document.    There  are  several  console  flags  that  can  be  specified  as  command  line  arguments  and  are   described  below.     IMPL  Console  Flags     There  are  twelve  (12)  flags  or  command  line  arguments  that  can  be  specified  and  they  are  as  follows   with  their  respective  possible  values  and  defaults  (shown  in  bolded  italics).     -feed = IMLfile The  feed  flag  value  must  specify  the  path  and  file  name  (without  the  *.iml  extension  or  file  type)  of  the   IML  file  to  be  modeled  and  solved.       -form = sparsic | symbolic For  linear  problems,  the  form  flag  values  of  sparsic  and  symbolic  are  equivalent  given  that  the   problem  matrix  has  no  nonlinear  or  non-­‐constant  derivatives  or  expressions  and  IMPL  supplies  all  of  the   first-­‐order  partial  derivatives  or  coefficients  analytically.    For  nonlinear  problems,  IMPL  represents  the   model  in  a  “sparsic”  form  where  only  the  sparsity-­‐pattern  is  supplied  by  IMPL  for  each  constraint  and   numerical  perturbations  are  used  to  compute  the  non-­‐constant  or  nonlinear  first-­‐order  partial   derivatives  using  machine-­‐coded  constraint  residual  calculations  i.e.,  the  constraint  equations  are  hard-­‐ coded  into  IMPL’s  native  computer  programming  language.    However,  IMPL  also  supports  a  “symbolic”   form  whereby  the  constraint  residual  calculations  are  computed  using  nonlinear  expressions  supplied  by   IMPL  in  a  byte-­‐coded  or  parsed  tokenized  format  sometimes  referred  to  as  postfix  or  reverse  Polish  
  • 3. notation  (RPN).    The  “symbolic”  form  is  useful  given  that  it  can  be  used  to  output  the  nonlinear   constraint  expressions  into  a  human-­‐readable  flat-­‐file.     -fit = discrete | distributed The  fit  flag  value  of  discrete assumes  a  uniform  digitization  of  time  i.e.,  discrete-­‐time  with  a  single   time-­‐period  duration  and  can  be  applied  to  quantity,  logistics  and  quality  types  of  problems  whereas  the   distributed  fit  flag  value  is  not  valid  for  logistics  problems  at  this  time.    IMPL’s  distributed-­‐time   formulation  is  similar  to  a  continuous-­‐time  model  with  a  common  or  global  time-­‐grid  except  that  in  the   former  the  time-­‐points  are  known  exogenously.     -filter = quantity | logistics | quality The  filter  flag  value  of  quantity  assumes  that  all  logic  variables  are  fixed  to  either  0  (zero)  or  1  (one)   and  there  are  no  quality  variables  present  and  solves  a  linear  programming  (LP)  problem.    The  filter  flag   value  of  logistics  solves  a  mixed-­‐integer  linear  programming  (MILP)  problem  where  the  logic  variables   are  finite  i.e.,  lie  between  0  or  1.    The  filter  flag  value  of  quality  solves  a  nonlinear  programming  (NLP)   problem  where  the  logic  variables  must  be  fixed  to  either  0  or  1.    A  fourth  filter  flag  value  of   qualogistics  is  possible  but  is  not  available  where  this  would  model  and  solve  a  mixed-­‐integer   nonlinear  programming  (MINLP)  problem  (future  implementation).       -focus = simulation | estimation | optimization The  focus  flag  value  allows  for  simulation  and  estimation  types  of  problems  but  currently  only  the   optimization  value  is  supported.     -factor = 1.0 The  factor  flag  value  is  a  real  positive  number  and  can  be  used  to  scale  quantity  variables  only  i.e.,  rates,   flows  and  holdups.     -factorizer = semisolverless | y12m | ysmp | nspiv | ma28 | pardiso The  factorizer  flag  value  is  used  to  factorize  or  perform  LU  decomposition  on  a  square  system  or  set  of   linear  and/or  nonlinear  equations  if  it  exists.    If  the  number  of  free  and/or  finite  quantity  and  quality   variables  equals  the  number  of  linear  and  nonlinear  equality  constraints  then  simulation  using  direct   factorization  of  the  sparse  Jacobian  matrix  of  first-­‐order  partial  derivatives  can  be  used  to  solve  the  
  • 4. problem  ignoring  all  inequality  constraints  and  variable  bounds.    The  factorizer  flag  pardiso  requires  the   Intel  Math  Kernel  Library  (MKL)  to  execute  a  parallel  implementation  of  LU  decomposition.     -fork = solverless | coinmp | glpk | lpsolve | scip | cplex | gurobi | lindo | xpress ipopt | conopt | knitro slpqpe_coinmp | slpqpe_glpk | slpqpe_lpsolve | slpqpe_scip | slpqpe_cplex | slpqpe_gurobi | slpqpe_lindo | slpqpe_xpress secqpe_y12m | secqpe_ysmp | secqpe_nspiv | secqpe_ma28 | secqpe_pardiso secqpe_sorve | secqpe_y12m_sorve | secqpe_ysmp_sorve | secqpe_nspiv_sorve | secqpe_ma28_sorve | secqpe_pardiso_sorve The  fork  flag  value  is  used  to  solve  LP,  QP,  MILP  and  NLP  problems.    The  solvers  slpqpe_  solve  nonlinear   LP  or  QP  problems  using  the  various  LP  and  QP  solvers  suffixed.    The  solvers  secqpe_  solve  nonlinear   equality-­‐constrained  QP  problems  using  the  various  LU  decompositions  suffixed  which  are  useful  for   data  reconciliation  and  regression  problems  (i.e.,  least  squares,  error-­‐in-­‐variables  and  parameter   estimation  types  of  problems).    The  suffixed  solvers  with  _sorve perform  a  post  sensitivity  analysis  to   compute  the  observability,  redundancy  and  variability  estimates  using  the  known  sparse  Jacobian  matrix   from  the  secqpe_  solve.    If  variable  bounds  and  constraint  inequalities  are  required  then  solve  with  an   NLP  first  then  warm-­‐start  with  slpqpe_sorve  to  perform  the  post  sensitivity  analysis.     Note  that  the  solvers  scip, cplex, gurobi, lindo, xpress, conopt and  knitro  all  require   commercial  licensing  agreements  from  their  vendors.     -flashback = binaryfile | binaryram | flatfile The  flashback  flag  value  is  used  to  save  or  retain  integer-­‐feasible  solutions  found  during  the  branch-­‐and-­‐ bound  type  of  enumerative  searches  employed  in  MILP  solvers.    All  integer-­‐feasible  solutions  (variable   results  or  responses  only)  are  saved  to  binary  or  unformatted  files  with  extension  *.bdt  where  a  “_n”  is   suffixed  to  the  IML  file  problem  name  with  “n”  denoting  the  solution  number  found.    The  flashback  flag   value  of  binaryram  means  that  the  solution  is  also  saved  to  RAM  memory  and  a  value  of  flatfile  will   save  the  solution  in  a  formatted  *.exl  file.     -fanfare = 1073741823 (2^30 - 1)  
  • 5. The  fanfare  flag  value  is  an  integer  bit  mask  with  0  to  30  bits.    Depending  on  the  value  of  fanfare,  the   various  IMPL  output  files  will  be  written  to  the  same  directory  as  the  IML  file.    For  more  details  please   refer  to  Appendix  A.     -fuse = coldstart | warmstart The  fuse  flag  value  is  only  valid  for  nonlinear  problems  where  a  warmstart  will  use  the  solution  variable   result  values  from  a  previous  solve  (if  they  exist)  as  initial-­‐values  or  starting-­‐points  for  the  next  solve.     -frequency = 0 The  frequency  flag  value  sets  the  number  of  solving  cycles  within  a  solving  execution  or  run.    It  is   essentially  a  do-­‐loop  starting  from  1  to  frequency  which  will  randomize  the  initial-­‐values,  starting-­‐points   or  default-­‐results  starting  from  the  random  seed  setting  and  simply  incrementing  it  by  the  loop  iterate   or  counter  i.e.,  initial_value = (lower_bound+upper_bound)/2 + (upper_bound- lower_bound)*random_number(random_seed).     IMPL  Input  Files     IMPL.lic License  file  for  IMPL  that  must  be  located  in  the  same  directory  as  the  IMPL  executable.     IMPL.set | *.set Settings  file  for  IMPL  that  may  be  located  in  the  same  directory  as  the  IMPL  executable  or  another  *.set   file  located  in  the  same  directory  as  the  IML  file  with  the  same  name.     IMPL.mem | *.mem Memory  file  for  IMPL  that  may  be  located  in  the  same  directory  as  the  IMPL  executable  or  another   *.mem  file  located  in  the  same  directory  as  the  IML  file  with  the  same  name.    The  memory  file  is  used  to   allocate  the  various  resource-­‐entities  of  IMPL.     IMPL.solver | *.solver Individual  solver  settings  files  for  the  various  IMPL  solvers  and  they  may  be  located  in  the  same  directory   as  the  IMPL  executable  or  another  *.solver  file  located  in  the  same  directory  as  the  IML  file  with  the   same  name.  
  • 6.   *.iml Industrial  (input)  modeling  language  files  containing  the  IML  frames  configuring  a  problem.     *.oml Output  modeling  language  files  with  the  same  name  and  location  as  the  IML  file  where  selected  variable   results  and  constraint  residuals  can  be  written  to  user-­‐specified  files.     *.ups UOPSS  files  (or  universal  production/process  superstructure)  written  by  the  IALConstructer.py  Python   2.3.5  code  found  in  the  Dia  open-­‐source  application  which  can  be  included  into  any  IMF  file.    This  *.ups   file  can  contain  the  complete  or  partial  construction  data  of  the  network,  graph,  diagram  or  flowsheet  of   the  problem.     *.ilp | *.inl Foreign  files  with  scalar-­‐based  variable  and  constraint  names  can  be  used  to  extend  the  IMPL  modeling   with  user-­‐created  and/or  shared  variables  and  user-­‐created  constraints.    The  format  of  these  files  is   similar  to  the  CPLEX  LP  files  where  for  nonlinear  model  extensions,  the  *.inl  file  allows  nonlinear   expressions  to  be  specified.    If  a  quantity  or  logistics  (LP,  QP  or  MILP)  problem  is  being  solved  then  only   the  *.ilp  is  recognized  and  if  a  quality  (NLP)  problem  is  being  solved  then  only  *.inl  files  are  respected.       Both  the  *.ilp  and  *.inl  files  include  the  following  sections:  “Objective”,  “Constraints”  and  “Bounds”.       There  is  also  a  “Binaries”  section  for  *.ilp  files  only  and  both  files  must  have  the  last  statement  as  “End”   where  in-­‐line  comments  are  indicated  by  the  “”  backslash  character.     IMPL  Output  Files     *.io Input  and  output  file  containing  the  inputs  and  outputs  for  each  IML  file  problem  UOPSS  superstructure.     *.iod Input  and  output  data  file  containing  the  input  and  output  data  for  each  IML  file  problem  UOPSS   superstructure.  
  • 7.   *.oi Output  and  input  file  containing  the  outputs  to  inputs  for  each  IML  file  problem  UOPSS  superstructure.     *.exl Export  files  with  the  same  name  and  location  as  the  IML  file  where  selected  variable  result  values  are   written  in  various  EXL  frames  similar  to  the  IML  frames.     *.bdt Binary  (unformatted)  files  storing  the  independent  sets,  catalogs,  lists,  parameters  and  formulas.    These   unformatted  files  are  useful  when  re-­‐running  IMPL  without  having  to  re-­‐read  the  *.iml  file.     *_n.bdt Binary  (unformatted)  files  suffixed  by  an  integer-­‐feasible  solution  number  “_n”  with  the  same  name  and   location  as  the  IML  file  where  all  variable  results  for  a  single  integer-­‐feasible  solution  found  in  the  MILP   solvers  are  written  in  unformatted  form.     *.ldt Log  files  with  the  same  name  and  location  as  the  IML  file  where  IMPL  progress  messages  are  displayed  if   USELOGFILE = 1  is  set  else  all  messages  will  be  sent  to  the  console  or  command  prompt  window.     *.rdt Report  files  with  the  same  name  and  location  as  the  IML  file  where  IMPL  resource-­‐entity  details  are   displayed.     *.sdt Summary  files  with  the  same  name  and  location  as  the  IML  file  where  IMPL  modeling  and  presolving   details  are  displayed  such  as  the  number  of  variables,  constraints  and  derivatives  included  or  excluded   from  the  problem.     *.tdt Statics  files  with  the  same  name  and  location  as  the  IML  file  where  if  any  IMPL  presolved  constraints  are   found  to  be  infeasible  (i.e.,  violated  greater  than  a  tolerance)  at  a  solution,  are  displayed.      “Static”   constraints  are  IMPL’s  term  for  constraints  that  are  presolved  or  removed  from  the  problem  by  IMPL  
  • 8. before  the  solvers  (with  their  own  presolving)  are  called  where  “dynamic”  constraints  in  this  context   mean  constraints  that  are  variable  in  the  solver.    The  IMPL  presolver  may  or  may  not  “prempt”  the   presolving  if  an  infeasible  or  inconsistent  constraint  is  found.     *.jdt Sensitivity  or  derivatives  files  with  the  same  name  and  location  as  the  IML  file  where  the  first-­‐order   partial  derivative  sparse  Jacobian  matrix  elements  are  displayed.     *.ndt Symbolic  or  mnemonic  files  with  the  same  name  and  location  as  the  IML  file  where  a  human-­‐readable   form  of  both  the  linear  and  nonlinear  constraints  are  displayed  for  every  variable  and  constraint  known   to  the  problem.   *.imp, *.imv, *.imc Three  files  containing  all  of  the  parameters  (including  all  of  the  sets,  catalogs,  lists  and  formulas),   variables  and  constraints  created  by  IMPL  to  model  the  problem.    These  files  can  be  used  to  reference   the  names  found  in  the  *.dta  files  below.     *.dtr Series-­‐set  (or  range-­‐set)  files  with  the  same  name  and  location  as  the  IML  file  where  all  SERIES-­‐SET   resource-­‐entity  roster-­‐enumerations  are  output.     *.dts Simple-­‐set  files  with  the  same  name  and  location  as  the  IML  file  where  all  SIMPLE-­‐SET  resource-­‐entity   roster-­‐enumerations  are  output.     *.dty Symbol-­‐set    files  with  the  same  name  and  location  as  the  IML  file  where  all  SYMBOL-­‐SET  resource-­‐entity   roster-­‐enumerations  are  output.     *.dtg Catalog  files  with  the  same  name  and  location  as  the  IML  file  where  all  CATALOG  resource-­‐entity  roster-­‐ enumerations  are  output.    
  • 9. *.dtl List  files  with  the  same  name  and  location  as  the  IML  file  where  all  LIST  resource-­‐entity  roster-­‐ enumerations  are  output.     *.dtp Parameter    files  with  the  same  name  and  location  as  the  IML  file  where  all  PARAMETER  resource-­‐entity   roster-­‐enumerations  are  output.     *.dtv Variable    files  with  the  same  name  and  location  as  the  IML  file  where  all  VARIABLE  resource-­‐entity   roster-­‐enumerations  are  output.     *.dtw “Vetistic”  (vetting)  or  statistic  files  with  the  same  name  and  location  as  the  IML  file  where  all  VARIABLE   and  CONSTRAINT  resource-­‐entity  roster-­‐enumerations  are  output  when  the  solvers  suffixed  with  _sorve     are  used.    This  file  outputs  the  observability  and  redundancy  metrics,  variances,  “maximum  power”   gross-­‐error  detection  statistics  and  confidence-­‐intervals.     *.dtc Constraint    files  with  the  same  name  and  location  as  the  IML  file  where  all  CONSTRAINT  resource-­‐entity   roster-­‐enumerations  are  output.     *.dtf Formula    files  with  the  same  name  and  location  as  the  IML  file  where  all  FORMULA  resource-­‐entity   roster-­‐enumerations  are  output.     Appendix  A  –  IMPL  Console  Source  Code  in  Intel  Fortran  (IMPL.exe)     Provided  below  is  the  Intel  Fortran  source  code  which  calls  the  various  routines  found  in  the  IMPL   system  architecture  SIIMPLE  (Server,  Interacter,  Interfacer,  Modeler,  Presolver  Libraries).    We  have   included  this  source  code  to  show  how  to  call  IMPL  with  SIIMPL  from  other  computer  programming   languages  such  as  C,  C++,  C#,  Java,  Python,  Excel/VBA,  etc.    
  • 10. program IMPL use IFWIN use IMPLserver cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc c INDUSTRIAL ALGORITHMS LLC. CONFIDENTIAL & PROPRIETARY cccccccccccccccccccccccc cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc implicit none c Project "feed" data name which also includes the path. character(BASESTRINGLEN*LINESTRINGLENMULT) :: feed c Problem "fact" data name which also includes the path. character(BASESTRINGLEN*LINESTRINGLENMULT) :: fact c Data "face" or stream i.e., either "import/out" or "export/in". integer(4) :: face c Model "factor" or scaling for dominant or primary phenomenological dimension. real(8) :: factor c Model "sipher" (cipher, secret-code) for encryption and deencryption. integer(8) :: fob c Model "form "or structure i.e., either "sparsic" or "symbolic". integer(4) :: form c Model "fit" or slot usually the temporal dimension. integer(4) :: fit c Model "filter" or select. integer(4) :: filter c Model "focus" or syllabus. integer(4) :: focus c Model "filler" or supplemental pointing to the supplierlib() routine. integer(4) :: filler c Model "foreign" ILP or INL file. character(BASESTRINGLEN*LINESTRINGLENMULT) :: foreign c Semi-solve "factorizer" or semi-solver. integer(4) :: factorizer c Solve "fork" or solver. integer(4) :: fork c Solve fresh or "stale". integer(4) :: fresh c Savings format for intermediate integer-feasible solutions when they are found during the search. integer(4) :: flashback c Feedback or callback "summons" routine. integer(4) :: feedback c Model and solve fanfare or "show". integer(4) :: fanfare c Solve from a previously solved solution (and not necessarily converged) i.e., "fuse" this new solution c with a preceding solution ("warm-start" v. "cold-start"). integer(4) :: fuse c  Rerun/restart/repeat  the  modeling  and  solving  in  a  loop  a  specified  number  of  times  by  randomizing  the  initial-­‐   c  values  or  starting-­‐points  using  the  random-­‐seed.   c   c  The  frequency  ("stride")  is  the  number  of  cycles  plus  one  (+1)  per  execution  or  run  of  this  console  program  where     c  zero  (0)  means  only  the  initial,  starting  or  default  run  is  performed.                    integer(4)  ::  frequency                  integer(4)  ::  rseed    
  • 11. c Data frames separated by the ASCII NULL character i.e., CHAR(0) in fortran or "/n" in C. character(BASESTRINGLEN*PAGESTRINGLENMULT) :: frames integer(4) :: flag c Command line argument string value. character(BASESTRINGLEN*LINESTRINGLENMULT) :: sargument, sargument1, sargument2 interface function IMPLinterfaceri(fact,form,fit,filter,focus,face,factor,fob,frames) #if stdcalling == 1 cDEC$ ATTRIBUTES DLLIMPORT, STDCALL, REFERENCE, DECORATE, ALIAS : "IMPLinterfaceri" :: IMPLINTERFACERI #else cDEC$ ATTRIBUTES DLLIMPORT, ALIAS : "IMPLinterfaceri" :: IMPLINTERFACERI #endif integer(4) :: IMPLinterfaceri character(*), intent(in) :: fact cDEC$ ATTRIBUTES REFERENCE :: fact integer(4), intent(in) :: form cDEC$ ATTRIBUTES VALUE :: form integer(4), intent(in) :: fit cDEC$ ATTRIBUTES VALUE :: fit integer(4), intent(in) :: filter cDEC$ ATTRIBUTES VALUE :: filter integer(4), intent(in) :: focus cDEC$ ATTRIBUTES VALUE :: focus integer(4), intent(in) :: face cDEC$ ATTRIBUTES VALUE :: face real(8), intent(in) :: factor cDEC$ ATTRIBUTES VALUE :: factor integer(8), intent(in) :: fob cDEC$ ATTRIBUTES VALUE :: fob character(*), intent(in) :: frames cDEC$ ATTRIBUTES REFERENCE :: frames end function IMPLinterfaceri function IMPLinterfacere(fact,form,fit,filter,focus,face,factor,fob,frames) #if stdcalling == 1 cDEC$ ATTRIBUTES DLLIMPORT, STDCALL, REFERENCE, DECORATE, ALIAS : "IMPLinterfacere" :: IMPLINTERFACERE #else cDEC$ ATTRIBUTES DLLIMPORT, ALIAS : "IMPLinterfacere" :: IMPLINTERFACERE #endif integer(4) :: IMPLinterfacere character(*), intent(in) :: fact cDEC$ ATTRIBUTES REFERENCE :: fact integer(4), intent(in) :: form cDEC$ ATTRIBUTES VALUE :: form integer(4), intent(in) :: fit cDEC$ ATTRIBUTES VALUE :: fit integer(4), intent(in) :: filter cDEC$ ATTRIBUTES VALUE :: filter integer(4), intent(in) :: focus cDEC$ ATTRIBUTES VALUE :: focus integer(4), intent(in) :: face cDEC$ ATTRIBUTES VALUE :: face real(8), intent(in) :: factor cDEC$ ATTRIBUTES VALUE :: factor integer(8), intent(in) :: fob cDEC$ ATTRIBUTES VALUE :: fob character(*), intent(in) :: frames cDEC$ ATTRIBUTES REFERENCE :: frames end function IMPLinterfacere function IMPLmodelerv(fact,form,fit,filter,focus,filler,foreign,force) #if stdcalling == 1 cDEC$ ATTRIBUTES DLLIMPORT, STDCALL, REFERENCE, DECORATE, ALIAS : "IMPLmodelerv" :: IMPLMODELERV #else cDEC$ ATTRIBUTES DLLIMPORT, ALIAS : "IMPLmodelerv" :: IMPLMODELERV #endif integer(4) :: IMPLmodelerv character(*), intent(in) :: fact cDEC$ ATTRIBUTES REFERENCE :: fact integer(4), intent(in) :: form cDEC$ ATTRIBUTES VALUE :: form integer(4), intent(in) :: fit cDEC$ ATTRIBUTES VALUE :: fit integer(4), intent(in) :: filter cDEC$ ATTRIBUTES VALUE :: filter integer(4), intent(in) :: focus cDEC$ ATTRIBUTES VALUE :: focus integer(4), intent(in) :: filler cDEC$ ATTRIBUTES REFERENCE :: filler character(*), optional, intent(in) :: foreign cDEC$ ATTRIBUTES REFERENCE :: foreign integer(4), optional, intent(in) :: force cDEC$ ATTRIBUTES REFERENCE :: force end function IMPLmodelerv function IMPLmodelerc(fact,form,fit,filter,focus,filler,foreign,force) #if stdcalling == 1 cDEC$ ATTRIBUTES DLLIMPORT, STDCALL, REFERENCE, DECORATE, ALIAS : "IMPLmodelerc" :: IMPLMODELERC #else
  • 12. cDEC$ ATTRIBUTES DLLIMPORT, ALIAS : "IMPLmodelerc" :: IMPLMODELERC #endif integer(4) :: IMPLmodelerc character(*), intent(in) :: fact cDEC$ ATTRIBUTES REFERENCE :: fact integer(4), intent(in) :: form cDEC$ ATTRIBUTES VALUE :: form integer(4), intent(in) :: fit cDEC$ ATTRIBUTES VALUE :: fit integer(4), intent(in) :: filter cDEC$ ATTRIBUTES VALUE :: filter integer(4), intent(in) :: focus cDEC$ ATTRIBUTES VALUE :: focus integer(4), intent(in) :: filler cDEC$ ATTRIBUTES REFERENCE :: filler character(*), optional, intent(in) :: foreign cDEC$ ATTRIBUTES REFERENCE :: foreign integer(4), optional, intent(in) :: force cDEC$ ATTRIBUTES REFERENCE :: force end function IMPLmodelerc function IMPLpresolver(fact,form,fit,filter,focus,factorizer,fork,fresh,flashback,feedback) #if stdcalling == 1 cDEC$ ATTRIBUTES DLLIMPORT, STDCALL, REFERENCE, DECORATE, ALIAS : "IMPLpresolver" :: IMPLPRESOLVER #else cDEC$ ATTRIBUTES DLLIMPORT, ALIAS : "IMPLpresolver" :: IMPLPRESOLVER #endif integer(4) :: IMPLpresolver character(*), intent(in) :: fact cDEC$ ATTRIBUTES REFERENCE :: fact integer(4), intent(in) :: form cDEC$ ATTRIBUTES VALUE :: form integer(4), intent(in) :: fit cDEC$ ATTRIBUTES VALUE :: fit integer(4), intent(in) :: filter cDEC$ ATTRIBUTES VALUE :: filter integer(4), intent(in) :: focus cDEC$ ATTRIBUTES VALUE :: focus integer(4), intent(in) :: factorizer cDEC$ ATTRIBUTES VALUE :: factorizer integer(4), intent(in) :: fork cDEC$ ATTRIBUTES VALUE :: fork integer(4), intent(in) :: fresh cDEC$ ATTRIBUTES VALUE :: fresh integer(4), intent(in) :: flashback cDEC$ ATTRIBUTES VALUE :: flashback integer(4), intent(in) :: feedback cDEC$ ATTRIBUTES REFERENCE :: feedback end function IMPLpresolver end interface c Integer pointer to modeling subroutine location. integer(4) :: ptr_IMPLmodelerc c Temporary allocatable storage when required. integer(4), allocatable :: ival(:) real(8), allocatable :: rval(:) character(BASESTRINGLEN), allocatable :: sval(:) c Miscellaneous. integer(4) :: i, rtnstat, lun character(BASESTRINGLEN*LINESTRINGLENMULT) :: logmessage character(BASESTRINGLEN) :: setting character(BASESTRINGLEN) :: startdate, finishdate, sizelimits, hostname, username c Timings for performance monitoring or profiling. c c * Note that to compute running times then use the following code. c c ftime = DCLOCK() c dttime = ftime-stime c ttime = ttime+dttime c stime = ftime c c * Note that CPU_TIME() returns the sum of time over all threads which does return the elapsed time. c Instead DCLOCK() returns the elapsed time and requires module IFPORT. real(8) :: stime, ftime, dttime, ttime, ttime2 c Start the clock. ttime = 0 stime = DCLOCK() cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc c Specify a version number for which will be maintained as a standalone entity. c c Year.Month.DayIncrement i.e., 2007-12-05 5th increment per day = 7.12.055 (major.minor.update release). c c This versioning scheme is simple and accurate and only useful for tracking changes continuously. It is
  • 13. c not a snapshot or build release number with "major.minor.patch" release structure. c * Note that "-1" means to write to standard output which is usually the screen. rtnstat = IMPLwritebanner(-1) write(*,"(1X,A)")"<<< i M P l - E x e c u t a b l e (console)" write(*,"(1X,A)")"<<<" write(*,"(1X,A)")"<<< Release # 1.0" write(*,"(1X,A)")"<<< Version # 12.5.141" write(*,"(1X,A)")"<<<" write(*,"(1X,4A)")"<<< Last Compiled: ",__DATE__," ",__TIME__ write(*,"(1X,A)")"<<<" cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc c Parse the command line arguments for the required flags. feed = "c:IMPLIMLfile" fact = feed form = SPARSIC$ ! form = SYMBOLIC$ fit = DISCRETE$ ! fit = DISTRIBUTE$ filter = QUANTITY$ ! filter = LOGISTICS$ ! filter = QUALITY$ c Simulation, Estimation and Optimization "Interoperability". ! focus = SIMULATION$ ! focus = ESTIMATION$ focus = OPTIMIZATION$ factor = 1d+0 factorizer = SEMISOLVERLESS$ ! factorizer = Y12M$ ! factorizer = YSMP$ ! factorizer = NSPIV$ ! factorizer = MA28$ ! factorizer = PARDISO$ fork = SOLVERLESS$ ! fork = COINMP$ ! fork = GLPK$ ! fork = LPSOLVE$ ! fork = SCIP$ ! fork = CPLEX$ ! fork = GUROBI$ ! fork = LINDO$ ! fork = OPTONOMY$ ! fork = XPRESS$ !SQP's ! fork = IPOPT$ ! fork = CONOPT$ ! fork = KNITRO$ ! fork = NOVA$ ! fork = WORHP$ !SLP's ! fork = SLPQPE_COINMP$ ! fork = SLPQPE_GLPK$ ! fork = SLPQPE_LPSOLVE$ ! fork = SLPQPE_SCIP$ ! fork = SLPQPE_CPLEX$ ! fork = SLPQPE_GUROBI$ ! fork = SLPQPE_OPTONOMY$ ! fork = SLPQPE_XPRESS$ ! fork = SLPQPE_IPOPT$ ! fork = SECQPE_Y12M$ ! fork = SECQPE_YSMP$ ! fork = SECQPE_NSPIV$ ! fork = SECQPE_MA28$ ! fork = SECQPE_PARDISO$ ! fork = SECQPE_SORVE$ ! fork = SECQPE_Y12M_SORVE$ ! fork = SECQPE_YSMP_SORVE$ ! fork = SECQPE_NSPIV_SORVE$ ! fork = SECQPE_MA28_SORVE$ ! fork = SECQPE_PARDISO_SORVE$ c Suitability (svve), Steadyability (ssde) and Scrumability (sfcme). ! fork = SVVE$ ! fork = SSDE$ ! fork = SFCME$
  • 14. fanfare = SHOWALL$ fuse = COLDSTART$ ! fuse = WARMSTART$ frequency = 0 fob = 0 frames = CHAR(0) c Get the library and function addresses for the filler, supplemental, external modeler, etc. which will provide the c necessary modeling for "black-blank" unit-operations. c c * Note that if the filler or supplemental routine is not found, then the return status is either negative or zero (0) and c hence filler = 0. filler = loadlibrary("C:IndustrialAlgorithmsPlatformIMPLIMPLsupplierDebugIMPLsupplier.dll"//CHAR(0)) if (filler > 0) then filler = getprocaddress(filler,"IMPLsupplierlib"//CHAR(0)) else filler = 0 end if fresh = FIRSTSESSION$ c Save, cache, store, persist, etc. integer-feasible solutions to an *.exl file as well as the default *.bdt binary file. flashback = FLATFILE$ c Point to the "recall()" routine provided by the "server". feedback = LOC(IMPLrecall) c The command line arguments (flags) can be specified as follows: c c * Note that if the second argument (after the "=" sign) is not recognizable as a valid value then an exception or c error occurs. c c impl.exe -feed="" c -form=sparsic c -fit=discrete c -filter=logistics c -focus=optimization c -factor=1 c -factorizer=y12m c -fork=lpsolve c -flashback=flatfile c -fanfare=1073741823 c -fuse=cold c -frequency=0 do i = 1,COMMAND_ARGUMENT_COUNT() call GET_COMMAND_ARGUMENT(i,sargument) sargument1 = sargument(1:INDEX(sargument,"=")) sargument2 = sargument(INDEX(sargument,"=")+1:BASESTRINGLEN*LINESTRINGLENMULT) select case (sargument1) case ("-feed=") if (TRIM(sargument2) /= "") then feed = TRIM(sargument2) fact = feed else write(*,*)"<<< %ERROR% - unknown -feed= argument present." stop end if write(*,*)"<<< feed = ",TRIM(sargument2) write(*,*)"<<< fact = ",TRIM(sargument2) case ("-form=") if (TRIM(sargument2) == "sparsic") then form = SPARSIC$ elseif (TRIM(sargument2) == "symbolic") then form = SYMBOLIC$ else write(*,*)"<<< %ERROR% - unknown -form= argument present." stop end if write(*,*)"<<< form = ",TRIM(sargument2)," = ",form case ("-fit=") if (TRIM(sargument2) == "discrete") then fit = DISCRETE$ elseif (TRIM(sargument2) == "distribute") then fit = DISTRIBUTE$ else write(*,*)"<<< %ERROR% - unknown -fit= argument present."
  • 15. stop end if write(*,*)"<<< fit = ",TRIM(sargument2)," = ",fit case ("-filter=") if (TRIM(sargument2) == "quantity") then filter = QUANTITY$ elseif (TRIM(sargument2) == "logistics") then filter = LOGISTICS$ elseif (TRIM(sargument2) == "quality") then filter = QUALITY$ else write(*,*)"<<< %ERROR% - unknown -filter= argument present." stop end if write(*,*)"<<< filter = ",TRIM(sargument2)," = ",filter case ("-focus=") if (TRIM(sargument2) == "simulation") then focus = SIMULATION$ elseif (TRIM(sargument2) == "estimation") then focus = ESTIMATION$ elseif (TRIM(sargument2) == "optimization") then focus = OPTIMIZATION$ else write(*,*)"<<< %ERROR% - unknown -focus= argument present." stop end if write(*,*)"<<< focus = ",TRIM(sargument2)," = ",focus case ("-factor=") if (TRIM(sargument2) /= "") then read(sargument2,*)factor factor = ABS(MIN(INFIN,factor)) else write(*,*)"<<< %ERROR% - no -factor= argument present." stop end if write(*,*)"<<< factor = ",factor case ("-factorizer=") if (TRIM(sargument2) == "") then factorizer = SEMISOLVERLESS$ elseif (TRIM(sargument2) == "y12m") then factorizer = Y12M$ elseif (TRIM(sargument2) == "ysmp") then factorizer = YSMP$ elseif (TRIM(sargument2) == "nspiv") then factorizer = NSPIV$ elseif (TRIM(sargument2) == "ma28") then factorizer = MA28$ elseif (TRIM(sargument2) == "pardiso") then factorizer = PARDISO$ else write(*,*)"<<< %ERROR% - unknown -factorizer= argument present." stop end if write(*,*)"<<< factorizer = ",TRIM(sargument2)," = ",factorizer case ("-fork=") if (TRIM(sargument2) == "") then fork = SOLVERLESS$ elseif (TRIM(sargument2) == "coinmp") then fork = COINMP$ elseif (TRIM(sargument2) == "glpk") then fork = GLPK$ elseif (TRIM(sargument2) == "lpsolve") then fork = LPSOLVE$ elseif (TRIM(sargument2) == "scip") then fork = SCIP$ elseif (TRIM(sargument2) == "cplex") then fork = CPLEX$ elseif (TRIM(sargument2) == "gurobi") then fork = GUROBI$ elseif (TRIM(sargument2) == "xpress") then fork = XPRESS$ elseif (TRIM(sargument2) == "conopt") then fork = CONOPT$ elseif (TRIM(sargument2) == "ipopt") then fork = IPOPT$ elseif (TRIM(sargument2) == "knitro") then fork = KNITRO$ elseif (TRIM(sargument2) == "nova") then fork = NOVA$ elseif (TRIM(sargument2) == "worhp") then
  • 16. fork = WORHP$ elseif (TRIM(sargument2) == "slpqpe_coinmp") then fork = SLPQPE_COINMP$ elseif (TRIM(sargument2) == "slpqpe_glpk") then fork = SLPQPE_GLPK$ elseif (TRIM(sargument2) == "slpqpe_lpsolve") then fork = SLPQPE_LPSOLVE$ elseif (TRIM(sargument2) == "slpqpe_scip") then fork = SLPQPE_SCIP$ elseif (TRIM(sargument2) == "slpqpe_cplex") then fork = SLPQPE_CPLEX$ elseif (TRIM(sargument2) == "slpqpe_gurobi") then fork = SLPQPE_GUROBI$ elseif (TRIM(sargument2) == "slpqpe_optonomy") then fork = SLPQPE_OPTONOMY$ elseif (TRIM(sargument2) == "slpqpe_xpress") then fork = SLPQPE_XPRESS$ elseif (TRIM(sargument2) == "secqpe_y12m") then fork = SECQPE_Y12M$ elseif (TRIM(sargument2) == "secqpe_ysmp") then fork = SECQPE_YSMP$ elseif (TRIM(sargument2) == "secqpe_nspiv") then fork = SECQPE_NSPIV$ elseif (TRIM(sargument2) == "secqpe_ma28") then fork = SECQPE_MA28$ elseif (TRIM(sargument2) == "secqpe_pardiso") then fork = SECQPE_PARDISO$ elseif (TRIM(sargument2) == "secqpe_sorve") then fork = SECQPE_SORVE$ elseif (TRIM(sargument2) == "secqpe_y12m_sorve") then fork = SECQPE_Y12M_SORVE$ elseif (TRIM(sargument2) == "secqpe_ysmp_sorve") then fork = SECQPE_YSMP_SORVE$ elseif (TRIM(sargument2) == "secqpe_nspiv_sorve") then fork = SECQPE_NSPIV_SORVE$ elseif (TRIM(sargument2) == "secqpe_ma28_sorve") then fork = SECQPE_MA28_SORVE$ elseif (TRIM(sargument2) == "secqpe_pardiso_sorve") then fork = SECQPE_PARDISO_SORVE$ else write(*,*)"<<< %ERROR% - unknown -fork= argument present." stop end if write(*,*)"<<< fork = ",TRIM(sargument2)," = ",fork case ("-flashback=") if (TRIM(sargument2) == "") then flashback = BINARYFILE$ elseif (TRIM(sargument2) == "binaryfile") then flashback = BINARYFILE$ elseif (TRIM(sargument2) == "binaryram") then flashback = BINARYRAM$ elseif (TRIM(sargument2) == "flatfile") then flashback = FLATFILE$ else write(*,*)"<<< %ERROR% - unknown -flashback= argument present." stop end if write(*,*)"<<< flashback = ",TRIM(sargument2)," = ",flashback case ("-fanfare=") if (TRIM(sargument2) /= "") then read(sargument2,*)fanfare fanfare = ABS(fanfare) show$ = fanfare end if write(*,*)"<<< fanfare = ",TRIM(sargument2)," = ",fanfare case ("-fuse=") if (TRIM(sargument2) == "cold") then fuse = COLDSTART$ elseif (TRIM(sargument2) == "warm") then fuse = WARMSTART$ else write(*,*)"<<< %ERROR% - unknown -fuse= argument present." stop end if write(*,*)"<<< fuse = ",TRIM(sargument2)," = ",fuse case ("-frequency=") if (TRIM(sargument2) /= "") then read(sargument2,*)frequency frequency = ABS(frequency) else write(*,*)"<<< %ERROR% - no -frequency= argument present." stop end if
  • 17. write(*,*)"<<< frequency = ",frequency end select end do show$ = fanfare start$ = fuse stride$ = frequency c Specify the foreign ILP or INL file and if it exists, it will be used to augment or extend the matrix. foreign = TRIM(fact)//".ilp" if ((filter == QUALITY$) .or. (filter == QUALOGISTICS$)) then foreign = TRIM(fact)//".inl" end if supplementary$ = foreign c If "symbolic-form" specified but the solving-system is of the "sparsic-form" only then solve the c "sparsic-form". c c * Note that at the moment only IPOPT and SLPQPE can be of both the "sparsic" and "symbolic" forms. if ((fork == CONOPT$) .or. (fork == KNITRO$) .or. & (fork == NOVA$) .or. (fork == WORHP$)) then form = SPARSIC$ end if c Only allow "symbolic-form" with XPRESS-SLP and LINDO-SLP given that these are not possible to be called c using "sparsic-form". if ((fork == XPRESS$) .or. (fork == LINDO$)) then form = SYMBOLIC$ end if c Only allow discrete-time for logistics. if (filter == LOGISTICS$) then fit = DISCRETE$ end if c Only allow our nonlinear SLPQPE_ solver as the fork if filter equal "quality" and a LP solver has been specified. if (filter == QUALITY$) then if (fork == COINMP$) then fork = SLPQPE_COINMP$ elseif (fork == GLPK$) then fork = SLPQPE_GLPK$ elseif (fork == LPSOLVE$) then fork = SLPQPE_LPSOLVE$ elseif (fork == SCIP$) then fork = SLPQPE_SCIP$ elseif (fork == CPLEX$) then fork = SLPQPE_CPLEX$ elseif (fork == GUROBI$) then fork = SLPQPE_GUROBI$ end if end if write(*,*)"<<<" write(*,*)"<<<",TRIM(fact) write(*,*)"<<<" c Initialize or establish the environment using the settings and license files. rtnstat = IMPLroot(fact) if (rtnstat == INNON) then write(*,*)"<<< %ERROR% - Invalid or missing license file." stop elseif (rtnstat > 0) then write(*,*)"<<< %ERROR% - Missing settings file." stop elseif (rtnstat < 0) then write(*,*)"<<< %WARNING% - Number of missing settings = ",-rtnstat end if logmessage = "<<<" rtnstat = IMPLwritelog(logmessage) logmessage = "<<< Root successful." rtnstat = IMPLwritelog(logmessage) c Initialize or allocate the global memory using the memory file. rtnstat = IMPLreserve(fact,ALL) if (rtnstat == INNON) then write(*,*)"<<< %ERROR% - Invalid or missing license file." stop elseif (rtnstat > 0) then write(*,*)"<<< %ERROR% - Missing memory file." stop elseif (rtnstat < 0) then
  • 18. write(*,*)"<<< %WARNING% - Missing memory setting." end if logmessage = "<<< Reserve successful." rtnstat = IMPLwritelog(logmessage) ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<<" write(*,*)"<<< Initialization time = ",dttime write(*,*)"<<<" c "Interface" the industrial/manufacturing optimization problem data. c c Interfacing the problem means reading in, inputing or importing the problem from the industrial/manufacturing c modeling language file (*.iml). face = IMPORT$ frames = CHAR(0) rtnstat = IMPLinterfaceri(fact,form,fit,filter,focus,face,factor,fob,frames) if (rtnstat == INNON) then write(*,*)"<<< %ERROR% - Invalid arguments." stop elseif (rtnstat > 0) then write(*,*)"<<< %ERROR% - Issue parsing import-file on line = ",rtnstat stop elseif (rtnstat < 0) then write(*,*)"<<< %WARNING% - Issue parsing import-file on line = ",ABS(rtnstat) end if rtnstat = IMPLreassure() if (rtnstat /= 0) then write(*,*)"<<< %ERROR% - Memory violation for resource-entity type = ",TRIM(IMPLreason(rtnstat)) stop end if logmessage = "<<< Reassure successful." rtnstat = IMPLwritelog(logmessage) ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<<" write(*,*)"<<< Import time = ",dttime write(*,*)"<<<" c "Serialize" or persist the problem-data i.e., sets, catalogs, lists, parameters and formulas representing the model-data c (master-data) and cycle-data (transactional-data). c c * Note that the "problem-data" (model-data and cycle-data) is converted to "matrix-data" in the "modeler" where it c creates/generates the variables (columns), constraints (rows) and derivatives (Jacobian/Hessian) (and expressions). rtnstat = IMPLrender(fact,ALL) if (rtnstat == 0) then logmessage = "<<< Render successful." rtnstat = IMPLwritelog(logmessage) else logmessage = "<<< Render unsuccessful." rtnstat = IMPLwritelog(logmessage) end if c "Model" the industrial/manufacturing optimization problem (IOP/MOP). c c Modeling the problem creates/generates the variables and constraints and any dependent sets, catalogs, lists and parameters c necessary to model all of the physical (structural), procedural (operational), projectional and phenomenological details. c In addition, the derivatives and expressions are also created or generated in the "modeler". c First, model the sets, catalogs, lists and parameters ("setup"). rtnstat = IMPLmodelerv(fact,form,fit,filter,focus,filler,foreign,force=PARAMETER) if (rtnstat == INNON) then write(*,*)"<<< %ERROR% - Invalid arguments." stop end if ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<<" write(*,*)"<<< Model (Sets, Lists, Parameters) time = ",dttime ttime2 = dttime c Second, model the variables ("specify"). rtnstat = IMPLmodelerv(fact,form,fit,filter,focus,filler,foreign,force=VARIABLE) if (rtnstat == INNON) then write(*,*)"<<< %ERROR% - Invalid arguments." stop end if ftime = DCLOCK() dttime = ftime-stime
  • 19. ttime = ttime+dttime stime = ftime write(*,*)"<<< Model (Variables) time = ",dttime ttime2 = ttime2 + dttime c If this is a "warm-start" then open the variables' results data file if it exists and read in the result values c for the "original" problem i.e., previous solution-data. if ((fuse == WARMSTART$) .and. (fork /= SECQPE_SORVE$)) then lun = INILUN INQUIRE(UNIT=lun,OPENED=rtnstat) do while (rtnstat) lun = lun + 1 INQUIRE(UNIT=lun,OPENED=rtnstat) end do open(UNIT=lun, & FILE=TRIM(fact)//"_vv.dta", & STATUS="OLD", & ACCESS="SEQUENTIAL", & ACTION="READ", & FORM="FORMATTED", & SHARED, & IOSTAT=rtnstat) if (rtnstat == 0) then allocate(rval(1:vvc)) do i = 1,vvc read(lun,*)rval(i) end do close(lun) rtnstat = IMPLrevise2(VARIABLE,vvc,1,0,rval(1:vvc)) deallocate(rval) end if end if c Third (last), model the constraints ("specificate/simulate/stipulate"). c c * Note that only in the constraints section of the modeling do we require the formulas. rtnstat = IMPLmodelerc(fact,form,fit,filter,focus,filler,foreign,force=CONSTRAINT) if (rtnstat == INNON) then write(*,*)"<<< %ERROR% - Invalid arguments." stop elseif (rtnstat > 0) then write(*,*)"<<< %ERROR% - Invalid input." stop end if if ((fuse == WARMSTART$) .and. (fork == SECQPE_SORVE$)) then lun = INILUN INQUIRE(UNIT=lun,OPENED=rtnstat) do while (rtnstat) lun = lun + 1 INQUIRE(UNIT=lun,OPENED=rtnstat) end do open(UNIT=lun, & FILE=TRIM(fact)//"_vv.dta", & STATUS="OLD", & ACCESS="SEQUENTIAL", & ACTION="READ", & FORM="FORMATTED", & SHARED, & IOSTAT=rtnstat) if (rtnstat == 0) then allocate(rval(1:vvc)) do i = 1,vvc read(lun,*)rval(i) end do close(lun) rtnstat = IMPLrevise2(VARIABLE,vvc,1,0,rval(1:vvc)) deallocate(rval) end if end if ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<< Model (Constraints) time = ",dttime ttime2 = ttime2 + dttime write(*,*)"<<< Model time = ",ttime2 write(*,*)"<<<" rtnstat = IMPLreassure() if (rtnstat /= 0) then write(*,*)"<<< %ERROR% - Memory violation for resource-entity type = ",TRIM(IMPLreason(rtnstat)) stop end if logmessage = "<<< Reassure successful." rtnstat = IMPLwritelog(logmessage) c "Interface" the superstructure data i.e., export or write out the *.io, *.oi and *.iod files. face = INOUT$ rtnstat = IMPLinterfacere(fact,form,fit,filter,focus,face,factor,fob,frames)
  • 20. face = OUTIN$ rtnstat = IMPLinterfacere(fact,form,fit,filter,focus,face,factor,fob,frames) face = INOUTDATA$ rtnstat = IMPLinterfacere(fact,form,fit,filter,focus,face,factor,fob,frames) c "Presolve" and "solve" the industrial/manufacturing optimization problem (IOP/MOP). rtnstat = IMPLpresolver(fact,form,fit,filter,focus,factorizer,fork,fresh,flashback,feedback) if (rtnstat == INNON) then write(*,*)"<<< %ERROR% - Invalid arguments." stop elseif (rtnstat > 0) then write(*,*)"<<< %ERROR% - Invalid input." stop elseif (rtnstat < 0) then write(*,*)"<<< %ERROR% - Not all variables/constraints converged - see *.tdt file." flag = 1 rtnstat = IMPLstatics(fact,CONTOL,flag) end if setting = "ECLOSURE2" write(*,*)"<<<" write(*,*)"<<< Solve closure = ",IMPLretrieveSTATISTIC(setting) write(*,*)"<<<" ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<<" write(*,*)"<<< Solve time = ",dttime write(*,*)"<<<" c Rerun/restart/repeat IMPL using different random-seeds by restoring the model-data and cycle-data from the c binary/unformatted *.bdt file (see the render() routine which writes this file). c c This is useful for non-convex nonlinear (quality) that exhibit several local optima. setting = "RANDSEED" rseed = INT(IMPLretrieveSETTING(setting)) do i = 1,frequency rtnstat = IMPLroot(fact) rtnstat = IMPLrefresh(ALL) rtnstat = IMPLrestore(fact,ALL) rtnstat = IMPLreceiveSETTING(setting,DBLE(rseed+i)) rtnstat = IMPLmodelerv(fact,form,fit,filter,focus,filler,foreign,force=PARAMETER) rtnstat = IMPLmodelerv(fact,form,fit,filter,focus,filler,foreign,force=VARIABLE) rtnstat = IMPLmodelerc(fact,form,fit,filter,focus,filler,foreign,force=CONSTRAINT) rtnstat = IMPLpresolver(fact,form,fit,filter,focus,factorizer,fork,fresh,flashback,feedback) end do c Save the solution-data ("original" problem) for the next run or execution if the warm-start is activated. if (fuse == WARMSTART$) then lun = INILUN INQUIRE(UNIT=lun,OPENED=rtnstat) do while (rtnstat) lun = lun + 1 INQUIRE(UNIT=lun,OPENED=rtnstat) end do open(UNIT=lun, & FILE=TRIM(fact)//"_vv.dta", & STATUS="UNKNOWN", & ACCESS="SEQUENTIAL", & ACTION="WRITE", & FORM="FORMATTED", & SHARED, & IOSTAT=rtnstat) if (rtnstat == 0) then allocate(rval(1:vvc)) call IMPLreview2(VARIABLE,vvc,1,0,rval(1:vvc)) do i = 1,vvc write(lun,*)rval(i) end do deallocate(rval) close(lun) end if end if c "Interface" the solution data i.e., export or write out the solution(s) in the *.exl file and using c *.oml file then "output" the selected solution variables results to the files specified. frames = CHAR(0) face = EXPORT$ rtnstat = IMPLinterfacere(fact,form,fit,filter,focus,face,factor,fob,frames) face = OUTPUT$ rtnstat = IMPLinterfacere(fact,form,fit,filter,focus,face,factor,fob,frames) ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<<"
  • 21. write(*,*)"<<< Export time = ",dttime write(*,*)"<<<" ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<<" write(*,*)"<<< Serialization time = ",dttime write(*,*)"<<<" c "Show" the various data for problem-solving, debugging and troubleshooting. if (BTEST(fanfare,SHOWREPORT$)) then rtnstat = IMPLreport(fact) logmessage = "<<< Write report successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWSUMMARY$)) then rtnstat = IMPLsummary(fact) logmessage = "<<< Write summary successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWSTATICS$)) then flag = 1 rtnstat = IMPLstatics(fact,CONTOL,flag) logmessage = "<<< Write statics successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWSLACKNESS$)) then if (filter == QUALITY$) then ptr_IMPLmodelerc = LOC(IMPLmodelerc) rtnstat = IMPLslackness(fact,ptr_IMPLmodelerc,0d+0) logmessage = "<<< Write slackness successful." rtnstat = IMPLwritelog(logmessage) end if end if if (BTEST(fanfare,SHOWSCALINGS$)) then if ((form == SPARSIC$) .and. (filter == QUALITY$)) then rtnstat = IMPLscalings(fact) logmessage = "<<< Write scalings successful." rtnstat = IMPLwritelog(logmessage) end if end if if (BTEST(fanfare,SHOWSERIESSET$)) then rtnstat = IMPLwriteall(fact,SERIESSET,0,0) logmessage = "<<< Writeall series-set successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWSIMPLESET$)) then rtnstat = IMPLwriteall(fact,SIMPLESET,0,0) logmessage = "<<< Writeall simple-set successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWSYMBOLSET$)) then rtnstat = IMPLwriteall(fact,SYMBOLSET,0,0) logmessage = "<<< Writeall symbol-set successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWCATALOG$)) then rtnstat = IMPLwriteall(fact,CATALOG,0,0) logmessage = "<<< Writeall catalog successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWLIST$)) then rtnstat = IMPLwriteall(fact,LIST,0,0) logmessage = "<<< Writeall list successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWPARAMETER$)) then rtnstat = IMPLwriteall(fact,PARAMETER,0,0) logmessage = "<<< Writeall parameter successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWVARIABLE$)) then rtnstat = IMPLwriteall(fact,VARIABLE,0,0) logmessage = "<<< Writeall variable successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWCONSTRAINT$)) then rtnstat = IMPLwriteall(fact,CONSTRAINT,0,0) logmessage = "<<< Writeall constraint successful." rtnstat = IMPLwritelog(logmessage) end if if (BTEST(fanfare,SHOWFORMULA$)) then rtnstat = IMPLwriteall(fact,FORMULA,0,0) logmessage = "<<< Writeall formula successful." rtnstat = IMPLwritelog(logmessage) end if c Show the model sensitivity with sparsity-pattern. if (BTEST(fanfare,SHOWDERIVATIVE$)) then ptr_IMPLmodelerc = LOC(IMPLmodelerc)
  • 22. flag = WRITESENSITIVITY rtnstat = IMPLwritesensitivity(fact,ptr_IMPLmodelerc,flag) logmessage = "<<< Write sensitivity successful." rtnstat = IMPLwritelog(logmessage) end if c Show model symbology with all variables and constraints as infix expressions. if (BTEST(fanfare,SHOWEXPRESSION$)) then if ((form == SYMBOLIC$) .or. & (filter == QUANTITY$) .or. (filter == LOGISTICS$)) then ptr_IMPLmodelerc = LOC(IMPLmodelerc) flag = WRITESYMBOLOGY rtnstat = IMPLwritesymbology(fact,ptr_IMPLmodelerc,flag) logmessage = "<<< Write symbology successful." rtnstat = IMPLwritelog(logmessage) end if end if c Show model sensability matrices i.e., A, B, C, Q, xm and z data files. if ((focus == ESTIMATION$) .and. (fork /= SVVE$) .and. (fork /= SSDE$)) then flag=0 rtnstat = IMPLwritesplitability(fact,ptr_IMPLmodelerc,flag) logmessage = "<<< Writeall splitability successful." rtnstat = IMPLwritelog(logmessage) end if c Deallocate global internal memory. rtnstat = IMPLrelease(ALL) if (rtnstat == 0) then logmessage = "<<< Release successful." rtnstat = IMPLwritelog(logmessage) else logmessage = "<<< Release unsuccessful." rtnstat = IMPLwritelog(logmessage) end if ftime = DCLOCK() dttime = ftime-stime ttime = ttime+dttime stime = ftime write(*,*)"<<<" write(*,*)"<<< Total time = ",ttime write(*,*)"<<<" c Finally, completely setup the problem again and show the symbolic representation of the problem if the form is "sparsic" c and the filter is "quality". if (BTEST(fanfare,SHOWEXPRESSION$)) then if ((form == SPARSIC$) .and. (filter == QUALITY$)) then rtnstat = IMPLroot(fact) rtnstat = IMPLreserve(fact,ALL) rtnstat = IMPLrestore(fact,ALL) form = SYMBOLIC$ rtnstat = IMPLmodelerv(fact,form,fit,filter,focus,filler,foreign,force=PARAMETER) rtnstat = IMPLmodelerv(fact,form,fit,filter,focus,filler,foreign,force=VARIABLE) rtnstat = IMPLmodelerc(fact,form,fit,filter,focus,filler,foreign,force=CONSTRAINT) fork = SOLVERLESS$ fresh = FIRSTSESSION$ rtnstat = IMPLpresolver(fact,form,fit,filter,focus,factorizer,fork,fresh,flashback,feedback) flag = WRITESYMBOLOGY rtnstat = IMPLwritesymbology(fact,ptr_IMPLmodelerc,flag) rtnstat = IMPLrelease(ALL) logmessage = "<<< Write symbology successful." rtnstat = IMPLwritelog(logmessage) end if end if end program IMPL

×