
    khQ                        d dl Z d dlZd dlZd dlZd dlZd dlmZ ddlmZm	Z	m
Z
mZmZmZ ddlmZmZmZmZmZ ddlmZmZmZ ddlmZmZmZ dd	lmZmZ ej8                  d
k\  rd Znd Zej<                  Z G d de      Zd Z eeeeeeeeeed
Z!e ed      e ed      e ed      iZ"e ed      e ed      e ed      iZ#edediZ$ G d de      Z% G d de      Z&y)    N)uuid4   )sparsectypesArrayFillPulpSolverErrorLpSolverLpSolver_CMDclock   )LpStatusNotSolvedLpStatusOptimalLpStatusInfeasibleLpStatusUnboundedLpStatusUndefined)LpContinuousLpBinary	LpInteger)LpConstraintEQLpConstraintLELpConstraintGE)
LpMinimize
LpMaximize)   r   c                     t        | d      S )Nzutf-8)bytesxs    x/var/www/html/SchoolMeal/SchoolMeal/pds_admin_SchoolMeal/Backend/venv/lib/python3.12/site-packages/pulp/apis/copt_api.py<lambda>r      s    a)     c                     | S N r   s    r   r   r       s     r    c                   H    e Zd ZdZd Z	 	 	 	 	 	 	 d	dZd Zd Zd Zd Z	d Z
y)
COPT_CMDz&
    The COPT command-line solver
    Nc                 b    t        j                  | ||||g        || _        || _        || _        y)z0
        Initialize command-line solver
        N)r	   __init__mipstartlogfilesolverparams)	selfpath	keepFilesmipmsg	mip_start	warmStartr)   paramss	            r   r'   zCOPT_CMD.__init__,   s2     	dD)S#rB!"r    c                 $    | j                  d      S )z0
        The default path of 'copt_cmd'
        copt_cmd)executableExtensionr+   s    r   defaultPathzCOPT_CMD.defaultPath@   s     ''
33r    c                 8    | j                  | j                        S )z1
        True if 'copt_cmd' is available
        )
executabler,   r6   s    r   	availablezCOPT_CMD.availableF   s     tyy))r    c                    | j                         s$t        dj                  | j                              | j                  st               j                  }t        j                  j                  | j                  dj                  |            }t        j                  j                  | j                  dj                  |            }t        j                  j                  | j                  dj                  |            }n-|j                  }|j                  dd      }|dz   }|dz   }|d	z   }|j                  |d
      }| j                  }|dz  }|d|z   dz   z  }|j                         r)| j                  r| j                  ||       |d|z   dz   z  }| j                   |dj                  | j                         z  }| j"                  7| j"                  j%                         D ]  \  }	}
|dj                  |	|
      z  } |j                         r| j&                  s|dz  }n|dz  }|d|z   dz   z  }|dz  }	 t        j(                  |       | j*                  rd}nt-        t        j.                  d      }t1        j2                  |d||      }||j5                          |dk7  r$t        dj                  | j                              t        j                  j7                  |      st8        }n| j;                  |      \  }}| j                  s |||fD ]  }	 t        j(                  |        |t<        k(  r|j?                         ||_         |S #  Y xY w#  Y JxY w)z
        Solve a well formulated LP problem

        This function borrowed implementation of CPLEX_CMD.actualSolve and
        GUROBI_CMD.actualSolve, with some modifications.
        z!COPT_PULP: Failed to execute '{}'z
{}-pulp.lpz{}-pulp.solz{}-pulp.mst _z-pulp.lpz	-pulp.solz	-pulp.mstr   )writeSOSz -c z"read ;zread Nzset logfile {};zset {0} {1};zoptimizelp;z	optimize;zwrite zexit"wT)shellstdoutstderrr   )!r:   r   formatr,   r-   r   hexosjointmpDirnamereplacewriteLPisMIPr(   writemstr)   r*   itemsr.   remover/   opendevnull
subprocesscallcloseexistsr   readsolr   assignVarsValsstatus)r+   lpuuidtmpLptmpSoltmpMsttmpNamelpvars	solvecmdsparnameparvalmsgpipercrX   valuesoldfiles                   r   actualSolvezCOPT_CMD.actualSolveL   s    ~~!"E"L"LTYY"WXX~~7;;DGGLLl.A.A$.GHEWW\\$++}/C/CD/IJFWW\\$++}/C/CD/IJF ggGooc3/Gj(E{*F{*FEA. II	V	X%++	88:$--MM&&)6)C//I<<#*11$,,??I(#'#4#4#:#:#< D^227FCC	D 88:dhh&I$IX&,,	W		IIf 88G2::s+G__Yd77SMMO 7!"E"L"LTYY"WXXww~~f%&F!\\&1NFF~~!662 IIg& _$f% 	G	2s   ;M MMM"c                 F   t        |      5 }	 t        |       t        }i }|D ],  }|d   dk7  s|j                         \  }}t        |      ||<   . 	 ddd       ||fS # t        $ r) t        j                  d       t
        i fcY cddd       S w xY w# 1 sw Y   fS xY w)z)
        Read COPT solution file
        z#COPT_PULP: No solution was returnedNr   #)	rP   nextStopIterationwarningswarnr   r   splitfloat)r+   filenamesolfilerX   re   linevarnamevarvals           r   rV   zCOPT_CMD.readsol   s     (^ 	4w-W %FF 47c>&*jjlOGV&+FmF7O4	4 v~ ! -CD(",,	4 	4-	4 v~s2   BAB#B&BBBBB c                 ^   |D cg c]/  }|j                         |j                  |j                         f1 }}g }|D ]&  \  }}|j                  dj                  ||             ( t	        |d      5 }|j                  dj                  |             ddd       yc c}w # 1 sw Y   yxY w)z+
        Write COPT MIP start file
        Nz{0} {1}r@   
T)valuerI   appendrD   rP   writerG   )	r+   rp   r_   vmstvalsmstliners   rt   mstfiles	            r   rM   zCOPT_CMD.writemst   s     17P1!''):OAFFAGGI&PP& 	>OGVNN9++GV<=	> (C  	.GMM$))G,-	. Q
	.s   BB4!B##B,)Nr   TTFFN)__name__
__module____qualname____doc__rI   r'   r7   r:   rg   rV   rM   r#   r    r   r%   r%   %   sE     D #(4*Wr*r    r%   c                     ddl m }  d}d}t        j                  d      }t        j                  dk(  r( | t        j
                  j                  |dd            }nt        j                  dk(  r( | t        j
                  j                  |d	d
            }nFt        j                  dk(  r( | t        j
                  j                  |d	d            }nt        d      |r|d   }|t        d      t        j                  dk(  r!t        j                  j                  |      }|S t        j                  j                  |      }|S )z=
    Load COPT shared library in all supported platforms
    r   )globN	COPT_HOMEwin32binzcopt.dlllinuxlibz
libcopt.sodarwinzlibcopt.dylibz'COPT_PULP: Unsupported operating systemz^COPT_PULP: Failed to locate solver library, please refer to COPT manual for installation guide)r   rF   getenvsysplatformr,   rG   r   ctypeswindllLoadLibrarycdll)r   libfilelibpathlibhomecoptlibs        r   COPT_DLL_loadlibr      s
    GGii$G
||wrww||GUJ?@		 rww||GULAB		!rww||GUODEGHH !*A
 	

 <<7"mm//8G N kk--g6GNr    )
r   r   r   r               	   
   CBIELGc                      e Zd ZdZd Z	  e       Zej                  Zej                  Z
ej                  Zej                  Zej                  Zej"                  Zej&                  Zej*                  Zej.                  Zej2                  Zej6                  Zej:                  Zej>                  Z ejB                  Z"ejF                  Z$ejJ                  Z&ejN                  Z(ejR                  Z*ejV                  Z,ejZ                  Z.ej^                  Z0ejb                  Z2ejf                  Z4ejj                  Z6ejn                  Z8ejr                  Z:	 	 	 	 	 ddZ;d Z<d Z=d Z>d Z?d Z@d	 ZAd
 ZBd ZCd ZDd ZEd ZFy# eG$ rZHeHZI	 d Z<d Z=Y dZH[HydZH[Hww xY w)COPT_DLLz)
    The COPT dynamic library solver
    Nc                 z   t        j                  | ||       d| _        d| _        || _        | j                          |5| j                  | j                  t        |            }|dk7  rt        d      | j                  s| j                  dd       |j                         D ]  \  }}	| j                  ||	        y)z0
            Initialize COPT solver
            Nr   z!COPT_PULP: Failed to set log fileLogging)r   r'   coptenvcoptprobr(   create
SetLogFilecoptstrr   r/   setParamrN   )
r+   r.   r/   r0   r1   r)   r2   rd   ra   rb   s
             r   r'   zCOPT_DLL.__init__?  s     dC-  DL DM &DM KKM "__T]]GG4DE7)*MNN 88i+#)<<> /gv./r    c                      y)z>
            True if dynamic library is available
            Tr#   r6   s    r   r:   zCOPT_DLL.availablee  s     r    c                    | j                  |      \  }}}}}}}}	}
}}}}}}}}| j                  | j                  |||||||	|
||||||d||      }|dk7  rt        d      |j	                         r(| j
                  r| j                  r|j                         D ci c]0  }|j                         | j                  |   |j                         2 }}|rt        t        |j                               t        j                        }t        t        |j                               t        j                         }| j#                  | j                  t%        |      ||      }|dk7  rt        d      | j'                  | j                        }|dk7  r}t        d      |j	                         r7| j
                  s+| j)                  | j                        }|dk7  r6t        d      | j)                  | j                        }|dk7  rt        d      | j+                  |||      }|j                         D ]	  }d|_         |S c c}w )	z
            Solve a well formulated LP/MIP problem

            This function borrowed implementation of CPLEX_DLL.actualSolve,
            with some modifications.
            Nr   z!COPT_PULP: Failed to load problemz.COPT_PULP: Failed to add MIP start informationz*COPT_PULP: Failed to solve the MIP problemz$COPT_PULP: Failed to solve MIP as LPz)COPT_PULP: Failed to solve the LP problemF)extractLoadProbr   r   rL   r.   r(   	variablesrw   v2nr   listkeysr   c_intre   c_doubleAddMipStartlenSolveSolveLpgetsolutionmodified)r+   rY   ncolnrownnonzobjsenobjconstcolcostcolbegcolcntcolindcolvalcoltypecollbcolubrowsenserowrhscolnamerownamerd   rz   mstdictmstkeysr{   rX   vars                             r   rg   zCOPT_DLL.actualSolvek  s?   4 R % %B( Qw%&IJJxxzdhh== "$7790 QWWY.G  "1$w||~2F"U"1 !12FOO# "-- MM3w<' 7"1 P# 
 ZZ.7)*VWWDHH\\$--07)*PQQ \\$--07)*UVV %%b$5F ||~ %$% MUs   5H<c                    t        |j                               t              }t        |j                        }t	        j
                  |z         }t	        j
                  |z         }t	        j
                  |z         }t	        j                  |z         }t	        j                  |z         }t	        j
                  |z         }	t	        j                  |z         }
t	        j                  |z         }t        j                  t        t        |            t        t        |                  }t        |j                     }t	        j
                  d      }t        fdt        |      D              | _        t        fdt        |      D              | _        t        fdt        |      D              | _        i | _        i | _        || _        || _        |j*                  j-                         D ]  \  }}||| j                  |   <    |j                         D ]  }t/        |j0                        || j                  |   <   |j2                  |j2                  || j                  |   <   nd|| j                  |   <   |j4                  |j4                  || j                  |   <   d|| j                  |   <    |j7                         r9|j                         D ]%  }t8        |j:                     || j                  |   <   ' nd}d}|j                  D ]s  }|j                  |   j<                   |	|<   t>        |j                  |   j                     |
|<   t/        |      ||<   || j"                  |<   || j$                  |<   |d	z  }u |jA                         D ]3  \  }}}|jC                  | j"                  |   | j                  |   |       5 |jE                         \  }}}}}tG        |t        jH                        }tG        |t        jH                        }tG        |t        jH                        }tG        |t        j
                        }||||||||||||||
|	||fS )
z
            Extract data from PuLP lp structure

            This function borrowed implementation of LpSolver.getCplexStyleArrays,
            with some modifications.
                    c              3   ,   K   | ]  }|   |f  y wr"   r#   .0icolss     r   	<genexpr>z#COPT_DLL.extract.<locals>.<genexpr>  s     ?ad1gq\?   c              3   @   K   | ]  }|   j                   |f  y wr"   )rI   r   s     r   r   z#COPT_DLL.extract.<locals>.<genexpr>  s      Hq$q',,!2 Hs   c              3   ,   K   | ]  }||   f  y wr"   r#   r   s     r   r   z#COPT_DLL.extract.<locals>.<genexpr>  s     >QQQL>r   Ngꌠ9Y>)gꌠ9Y>)Fr   r   )%r   r   r   constraintsr   r   c_charc_char_pr   Matrixrange
coptobjsensensedictr   vname2nn2vc2nn2c	addedVars	addedRows	objectiverN   r   rI   lowBoundupBoundrL   	coptctypecatconstant
coptrsensecoefficientsaddcol_based_arraysr   r   )r+   rY   r   r   r   r   r   r   r   r   r   r   spmatr   r   colvalr   idxrowcoeffr   _colbeg_colcnt_colind_colvalr   r   r   r   r   s                                 @r   r   zCOPT_DLL.extract  s    'Dt9Dr~~&D__t+.E__t+.E-0G}}t+.G-0Goo,/F,/H-0GMM$uT{"3T%+5FGE  )Fs+H ?5;?@DH HE$K HIDL>%+>>DHDHDH!DN!DN LL..0 -S),&- ||~ 0)0):&<<++.<<E$((3-(+0E$((3-(;;*+.;;E$((3-(+/E$((3-(0 xxz<<> @C-6sww-?GDHHSM*@  C~~ !~~c2;;;s *2>>#+>+D+D E&s| # #q $&??#4 CS%		$((3-c):EBC 9>8N8N8P5E7GWg$Wfll;F$Wfll;F$Wfll;F$Wfoo>F # r    c                 n   | j                          t        j                         | _        t        j                         | _        | j                  t        | j                              }|dk7  rt        d      | j                  | j                  t        | j                              }|dk7  rt        d      y)z
            Create COPT environment and problem

            This function borrowed implementation of CPLEX_DLL.grabLicense,
            with some modifications.
            r   z'COPT_PULP: Failed to create environmentz#COPT_PULP: Failed to create problemN)	deleter   c_void_pr   r   	CreateEnvbyrefr   
CreateProbr+   rd   s     r   r   zCOPT_DLL.create4  s     KKM!??,DL"OO-DM dll 34BQw%&OPP uT]]/CDBQw%&KLL r    c                 $    | j                          y)z6
            Destructor of COPT_DLL class
            N)r   r6   s    r   __del__zCOPT_DLL.__del__K  s     KKMr    c                 $   | j                   | j                  w| j                  t        | j                              }|dk7  rt	        d      | j                  t        | j                               }|dk7  rt	        d      d| _         d| _        yyy)z
            Release COPT problem and environment

            This function borrowed implementation of CPLEX_DLL.releaseLicense,
            with some modifications.
            Nr   z#COPT_PULP: Failed to delete problemz'COPT_PULP: Failed to delete environment)r   r   
DeleteProbr  r   	DeleteEnvr  s     r   r   zCOPT_DLL.deleteQ  s     ||'DMM,E__U4==%9:7)*OPP ^^E$,,$787)*STT  $ $ -F'r    c           	         t        j                         }t        j                  |z         }t        j                  |z         }t        j                  |z         }t        j                  |z         }i }	i }
i }i }|j                         r4| j                  r't        j                         }| j                  | j                  t        d      t        |            }|dk7  rt        d      | j                  | j                  t        d      t        |            }|dk7  rt        d      |j                  dk(  s|j                  dk(  rd| j                  | j                  t        |            }|dk7  rt        d      t        |      D ]!  }||   |	| j                  |   j                  <   # |j                  |	       nm| j                  | j                  t        d      t        |            }|dk7  rt        d	      |j                  dk(  r| j!                  | j                  t        |      t        |      t        |      t        |            }|dk7  rt        d
      t        |      D ]@  }||   |	| j                  |   j                  <   ||   |
| j                  |   j                  <   B t        |      D ],  }||   || j"                  |   <   ||   || j"                  |   <   . |j                  |	       |j%                  |
       |j'                  |       |j)                  |       d|_        |j-                         D ]	  }d|_         t0        j3                  |j                  t4              |_        |j6                  S )zGet problem solution

            This function borrowed implementation of CPLEX_DLL.findSolutionValues,
            with some modifications.
            	MipStatusr   z#COPT_PULP: Failed to get MIP status	HasMipSolz1COPT_PULP: Failed to check if MIP solution existsr   z%COPT_PULP: Failed to get MIP solutionLpStatusz"COPT_PULP: Failed to get LP statusz$COPT_PULP: Failed to get LP solutionTF)r   r   r   rL   r.   
GetIntAttrr   r   r  r   rw   GetSolutionr   r   rI   rW   GetLpSolutionr   assignVarsDjassignConsPiassignConsSlack	resolveOKr   
isModified
coptlpstatgetr   rX   )r+   rY   ncolsnrowsrX   r   djpislackvar_xvar_djcon_pi	con_slack	hasmipsolrd   r   r   s                    r   r   zCOPT_DLL.getsolutionh  s    \\^F5(+A//E),B//E),B__u,/EEFFIxxzdhh"LLN	__T]]GK4H%PV-X7)*OPP__MM7;#7y9I 7)K 
 <<1$	1(<))$--qBBQw-.UVV"5\ 723A$dhhqk../7 !!%( __T]]GJ4GvW7)*NOO <<1$++uQxuuRy%PR)B Qw-.TUU"5\ 923A$dhhqk../35a5txx{//09
 #5\ :.0etxx{+16q	$((1+.:
 !!%(''""9-  BL||~ '!&' #v||5FGBI99r    c                 (   t        |      }t        j                  j                  |      \  }}|st	        d      |t        d      k(  r| j                  | j                  |      }n|t        d      k(  r| j                  | j                  |      }n|t        d      k(  r| j                  | j                  |      }n|t        d      k(  r| j                  | j                  |      }n|t        d      k(  r| j                  | j                  |      }na|t        d      k(  r| j                  | j                  |      }n6|t        d      k(  r| j                  | j                  |      }nt	        d	      |d
k7  rt	        dj                  |            y)zM
            Write problem, basis, parameter or solution to file
            z/COPT_PULP: Failed to determine output file typez.mpsz.lpz.binz.solz.basz.mstz.parz COPT_PULP: Unsupported file typer   z$COPT_PULP: Failed to write file '{}'N)r   rF   r,   splitextr   WriteMpsr   WriteLpWriteBinWriteSol
WriteBasisWriteMst
WriteParamrD   )r+   rp   	file_path	file_namefile_extrd   s         r   ry   zCOPT_DLL.write  sI     )I"$''"2"29"=Ix%&WXXWV_,]]4==)<WU^+\\$--;WV_,]]4==)<WV_,]]4==)<WV_,__T]]I>WV_,]]4==)<WV_,__T]]I>%&HIIQw%:AA(K  r    c                 z   t        j                         }t        |      }| j                  | j                  |t        |            }|dk7  rt        dj                  |            |j                  dk(  rP| j                  | j                  |t        j                  |            }|dk7  rt        dj                  |            y|j                  dk(  rP| j                  | j                  |t        j                  |            }|dk7  rt        dj                  |            yt        dj                  |            )z7
            Set parameter to COPT problem
            r   (COPT_PULP: Failed to check type for '{}'z.COPT_PULP: Failed to set double parameter '{}'r   z/COPT_PULP: Failed to set integer parameter '{}'!COPT_PULP: Invalid parameter '{}'N)r   r   r   SearchParamAttrr   r  r   rD   rw   SetDblParamr   SetIntParam)r+   rI   r   par_typepar_namerd   s         r   r   zCOPT_DLL.setParam  s%    ||~Ht}H%%dmmXuXOBQw%>EEhO  ~~"%%dmmXvs?ST7)HOO$   1$%%dmmXv||C?PQ7)IPP$   &7>>xH r    c                    t        j                         }t        j                         }t        j                         }t        |      }| j	                  | j
                  |t        |            }|dk7  rt        dj                  |            |j                  dk(  rS| j                  | j
                  |t        |            }|dk7  rt        dj                  |            |j                  }|S |j                  dk(  rS| j                  | j
                  |t        |            }|dk7  rt        dj                  |            |j                  }|S t        dj                  |            )z8
            Get current value of parameter
            r   r/  z.COPT_PULP: Failed to get double parameter '{}'r   z/COPT_PULP: Failed to get integer parameter '{}'r0  )r   r   r   r   r1  r   r  r   rD   rw   GetDblParamGetIntParam)r+   rI   
par_dblval
par_intvalr4  r5  rd   retvals           r   getParamzCOPT_DLL.getParam  sR     *JJ||~Ht}H%%dmmXuXOBQw%>EEhO  ~~"%%dmmXuZ?PQ7)HOO$  (--F  M 1$%%dmmXuZ?PQ7)IPP$  (--F M	 &7>>xH r    c                    t        j                         }t        j                         }t        j                         }t        |      }| j	                  | j
                  |t        |            }|dk7  rt        dj                  |            |j                  dk(  rS| j                  | j
                  |t        |            }|dk7  rt        dj                  |            |j                  }|S |j                  dk(  rS| j                  | j
                  |t        |            }|dk7  rt        dj                  |            |j                  }|S t        dj                  |            )z6
            Get attribute of the problem
            r   r/  r   z.COPT_PULP: Failed to get double attribute '{}'r   z/COPT_PULP: Failed to get integer attribute '{}'z!COPT_PULP: Invalid attribute '{}')r   r   r   r   r1  r   r  r   rD   rw   
GetDblAttrr  )r+   rI   attr_dblvalattr_intval	attr_type	attr_namerd   r;  s           r   getAttrzCOPT_DLL.getAttr#  sQ    !//+K ,,.KII %%dmmYi@PQBQw%>EEiP  !#__T]]Iu[?QR7)HOO%  )..F  M A%__T]]Iu[?QR7)IPP%  )..F M	 &7>>yI r    c                      yTrue if the solver is availableFr#   r6   s    r   r:   zCOPT_DLL.available      r    c                 2    t        d| j                         )"Solve a well formulated lp problemzCOPT_DLL: Not Available:
)r   err)r+   rY   s     r   rg   zCOPT_DLL.actualSolve  s    !$>txxj"IJJr    )TTFFN)Jr~   r   r   r   rI   r   r   COPT_CreateEnvr  COPT_DeleteEnvr	  COPT_CreateProbr  COPT_DeleteProbr  COPT_LoadProbr   COPT_AddColsAddColsCOPT_WriteMpsr$  COPT_WriteLpr%  COPT_WriteBinr&  COPT_WriteSolr'  COPT_WriteBasisr(  COPT_WriteMstr)  COPT_WriteParamr*  COPT_AddMipStartr   COPT_SolveLpr   
COPT_Solver   COPT_GetSolutionr  COPT_GetLpSolutionr  COPT_GetIntParamr8  COPT_SetIntParamr3  COPT_GetDblParamr7  COPT_SetDblParamr2  COPT_GetIntAttrr  COPT_GetDblAttrr>  COPT_SearchParamAttrr1  COPT_SetLogFiler   r'   r:   rg   r   r   r  r   r   ry   r   r<  rC  	ExceptionerJ  r#   r    r   r   r     s    Dx"$ **	**	,,
,,
((&&((&&((((,,
((,,
..&&""..22........,,
,,
!66,,
 $	/L	`	De	N	M.		%.N	`	> 	D(	T)	[  
KM		K
Ks   E4 4F9	FFr   c                   x    e Zd ZdZd Z	 ddla	 	 	 	 	 	 ddZd Zd ZddZ	d Z
dd	Zdd
Zy#  d ZddZY yxY w)COPTz
    The COPT Optimizer via its python interface

    The COPT variables are available (after a solve) in var.solverVar
    Constraints in constraint.solverConstraint
    and the Model is in prob.solverModel
    r   Nc           	      d   t        j                  | ||||||       t        j                         | _        | j                  j                         | _        | j                  s| j                  j                  dd       |j                         D ]!  \  }}	| j                  j                  ||	       # y)a  
            :param bool mip: if False, assume LP even if integer variables
            :param bool msg: if False, no log is shown
            :param float timeLimit: maximum time for solver (in seconds)
            :param float gapRel: relative gap tolerance for the solver to stop (in fraction)
            :param bool warmStart: if True, the solver will use the current value of variables as a start
            :param str logPath: path to the log file
            )r.   r/   	timeLimitgapRellogPathr1   r   r   N)
r   r'   coptpyEnvrr   createModelcoptmdlr/   r   rN   )
r+   r.   r/   rk  rl  r1   rm  solverParamskeyrw   s
             r   r'   zCOPT.__init__i  s    & ## ";;=DL<<335DL88%%i3*002 2
U%%c512r    c                    |j                   }|j                  }t        j                  j                  t
        t        j                  j                  t        t        j                  j                  t        t        j                  j                  t        t        j                  j                  t        t        j                  j                  t
        t        j                  j                  t
        t        j                  j                  t
        t        j                  j                   t
        t        j                  j"                  t
        i
}| j$                  rt'        d|       d|_        |j*                  D ]	  }d|_         |j/                  |t0              }|j3                  |       |t        k7  r|S |j5                  d|j7                               }t9        |j*                  |      D ]  \  }}||_         |j<                  s|j5                  d|j?                               }	t9        |j@                  jC                         |	      D ]  \  }
}||
_"         |j5                  d|j7                               }t9        |j*                  |      D ]  \  }}||_#         |j5                  d|j?                               }t9        |j@                  jC                         |      D ]  \  }
}||
_$         |S )NzCOPT status=TFValueSlackRedCostDual)%solverModelrX   rn  ri  	UNSTARTEDr   OPTIMALr   
INFEASIBLEr   	UNBOUNDEDr   
INF_OR_UNB	NUMERICAL	NODELIMITTIMEOUT
UNFINISHEDINTERRUPTEDr/   printr  
_variablesr  r  r   assignStatusgetInfogetVarszipvarValueismip
getConstrsr   re   r  r  r  )r+   rY   modelsolutionStatusCoptLpStatusr   rX   re   rw   slacksconstrredcostsdualss                r   findSolutionValueszCOPT.findSolutionValues  s6   NNE"\\N %%'8##_&&(:%%'8&&(:%%'8%%'8##%6&&(9''):L xxnn5BL}} '!&' "%%n6GHFOOF#(]]7EMMO<F!"--8 %
U$% ;;w0@0@0BC%()>)>)@&%I )MFE#(FL) !==EMMOD"%bmmX"> #JC"CF# fe.>.>.@A%()>)>)@%%H &MFE %FI& Mr    c                      y)rF  Tr#   r6   s    r   r:   zCOPT.available  s    r    c                 4   t                | _        |O|j                  j                  |t        j
                  j                  t        j
                  j                  z         |j                  j                          | xj                  t               z  c_        y)zSolves the problem with COPTN)	r
   	solveTimery  setCallbackrn  ri  CBCONTEXT_MIPRELAXCBCONTEXT_MIPSOLsolver+   rY   callbacks      r   
callSolverzCOPT.callSolver  sf    #gXDN#**KK22V[[5Q5QQ NN  "NNeg%Nr    c                 r   | j                   |_        |j                  t        k(  r)t        j
                  j                  |j                  _        | j                  r&|j                  j                  d| j                         | j                  j                  d      }| j                  j                  d      }|r|j                  j                  d|       |r|j                  j                  |       |j                         D ]  }|j                  }|t        j
                  j                   }|j                   }|t        j
                  j                  }|j"                  j                  |d      }t        j
                  j$                  }|j&                  t(        k(  r&| j*                  rt        j
                  j,                  }|j                  j/                  |||||j0                        |_         | j                  j                  dd	      rh|j4                  D ]?  }|j6                  | j                   j9                  |j2                  |j6                         A | j                   j;                          |j<                  j?                         D ]  \  }	}
t        jA                  |
jC                         D cg c]  }|j2                   c}tE        |
jG                                     }|
j                  tH        k(  rt        j
                  jJ                  }ng|
j                  tL        k(  rt        j
                  jN                  }n9|
j                  tP        k(  rt        j
                  jR                  }ntU        d
      |j                  jW                  |||
jX                   |	      |
_-         yc c}w )zU
            Takes the pulp lp model and translates it into a COPT model
            	TimeLimitrl  rm  RelGapNr   )vtypeobjrI   r1   Fz#Detected an invalid constraint type).rq  ry  r   r   rn  ri  MAXIMIZEobjsenserk  r   optionsDictr  
setLogFiler   r   INFINITYr   r   
CONTINUOUSr   r   r.   INTEGERaddVarrI   	solverVarr  r  setMipStartloadMipStartr   rN   LinExprr   r   re   r   
LESS_EQUALr   GREATER_EQUALr   EQUALr   	addConstrr   solverConstraint)r+   rY   rl  rm  r   r   r   r  varTyperI   
constraintrz   exprrelations                 r   buildSolverModelzCOPT.buildSolverModel  s    "\\BNxx:%*0++*>*>'~~''T^^D%%))(3F&&**95G''&9))'2||~ <<# & 4 44H++?$kk22Gll&&sC0 ++0077i'DHH$kk11G " 5 5gW#CHH !6 ! ##K7== NC||/00MN ))+$&NN$8$8$:  j~~*4//*;<QQ[[<d:CTCTCV>W ##~5%{{55H%%7%{{88H%%7%{{00H)*OPP.0nn.F.F(Z%8%8$8$/
+<s   ;N4
c                     | j                  |       | j                  ||       | j                  |      }|j                  D ]	  }d|_         |j
                  j                         D ]	  }d|_         |S )z
            Solve a well formulated lp problem

            creates a COPT model, variables and constraints and attaches
            them to the lp model which it then solves
            r  F)r  r  r  r  r   r   re   )r+   rY   r  r  r   r  s         r   rg   zCOPT.actualSolve  sv     !!"%OOBO2!44R8N}} %$% nn335 ,
&+
#,!!r    c                 R   |j                   j                         D ]  }|j                  s|j                  t        k(  r|j
                   |j                  _        @|j                  t        k(  r|j
                   |j                  _	        p|j
                   |j                  _	        |j
                   |j                  _         | j                  ||       | j                  |      }|j                  D ]	  }d|_         |j                   j                         D ]	  }d|_         |S )z
            Solve a well formulated lp problem

            uses the old solver and modifies the rhs of the modified constraints
            r  F)r   re   r   r   r   r   r  ubr   lbr  r  r  )r+   rY   r  r  r  r   s         r   actualResolvezCOPT.actualResolve  s	    !nn335 N
&&!''>9:D:M:M9M
336#))^;:D:M:M9M
336:D:M:M9M
336:D:M:M9M
336N OOBO2!44R8N}} %$% nn335 ,
&+
#,!!r    c                      yrE  r#   r6   s    r   r:   zCOPT.available_  rG  r    c                     t        d      )rI  zCOPT: Not available)r   r  s      r   rg   zCOPT.actualSolvec  s    !"788r    )TTNNFNr"   )r~   r   r   r   rI   rn  r'   r  r:   r  r  rg   r  r#   r    r   ri  ri  O  sc     DR" "	2H/	b			&5	n	""	"q9		9s   . 	9ri  )'rF   r   r   rR   rl   rZ   r   corer   r   r   r   r	   r
   	constantsr   r   r   r   r   r   r   r   r   r   r   r   r   version_infor   r  r%   r   r  r   r   r   r   ri  r#   r    r   <module>r     s   	 
       : 9 F F . v)GG`| `F"N 
 '#,gclws|	 GCLGCLGCL
 !Z,
x D]"8 ]"r    