|
file | benders_gcg.c [code] |
| GCG Benders' decomposition algorithm.
|
|
file | benders_gcg.h [code] |
| GCG Benders' decomposition.
|
|
file | bendersplugins.c [code] |
| SCIP plugins for the master problem running in Benders' decomposition mode.
|
|
file | bendersplugins.h [code] |
| SCIP plugins for the master problem running in Benders' decomposition mode.
|
|
file | bliss_automorph.cpp [code] |
| automorphism recognition of SCIPs
|
|
file | bliss_automorph.h [code] |
| automorphism recognition of SCIPs
|
|
file | bliss_automorph.hpp [code] |
| automorphism recognition (C++ interface)
|
|
file | branch_bpstrong.c [code] |
| generic branch-and-price strong branching heuristics
|
|
file | branch_bpstrong.h [code] |
| generic branch and price strong branching as described in Pecin, D., Pessoa, A., Poggi, M., Uchoa, E. Improved branch-cut-and-price for capacitated vehicle routing. In: Math. Prog. Comp. 9:61-100. Springer (2017).
|
|
file | branch_empty.c [code] |
| branching rule for the original problem while real branching is applied in the master
|
|
file | branch_empty.h [code] |
| branching rule for original problem in GCG while real branching is in the master
|
|
file | branch_generic.c [code] |
| branching rule based on vanderbeck's generic branching scheme
|
|
file | branch_generic.h [code] |
| branching rule based on vanderbeck's generic branching scheme
|
|
file | branch_orig.c [code] |
| branching rule for the original problem in GCG
|
|
file | branch_orig.h [code] |
| branching rule for original problem in GCG
|
|
file | branch_relpsprob.c [code] |
| generalized reliable pseudo costs branching rule
|
|
file | branch_relpsprob.h [code] |
| reliable pseudo costs branching rule
|
|
file | branch_ryanfoster.c [code] |
| branching rule for original problem in GCG implementing the Ryan and Foster branching scheme
|
|
file | branch_ryanfoster.h [code] |
| branching rule for original problem in GCG implementing the Ryan and Foster branching scheme
|
|
file | class_conspartition.cpp [code] |
| class representing a partition of a set of constraints
|
|
file | class_conspartition.h [code] |
| class representing a partition of a set of constraints
|
|
file | class_detprobdata.cpp [code] |
| class storing partialdecomps and the problem matrix
|
|
file | class_detprobdata.h [code] |
| class storing partialdecs and the problem matrix
|
|
file | class_indexpartition.cpp [code] |
| generalization of ConsPartition and VarPartition
|
|
file | class_indexpartition.h [code] |
| generalization of ConsPartition and VarPartition
|
|
file | class_partialdecomp.cpp [code] |
| class storing incomplete decompositions
|
|
file | class_partialdecomp.h [code] |
| class storing (potentially incomplete) decompositions
|
|
file | class_pricingcontroller.cpp [code] |
| pricing controller managing the pricing strategy
|
|
file | class_pricingcontroller.h [code] |
| pricing controller managing the pricing strategy
|
|
file | class_pricingtype.cpp [code] |
| abstraction for SCIP pricing types
|
|
file | class_pricingtype.h [code] |
| abstraction for SCIP pricing types
|
|
file | class_stabilization.cpp [code] |
| class with functions for dual variable smoothing
|
|
file | class_stabilization.h [code] |
| class with functions for dual variable smoothing
|
|
file | class_varpartition.cpp [code] |
| class representing a partition of a set of variables
|
|
file | class_varpartition.h [code] |
| class representing a partition of a set of variables
|
|
file | clscons_consnamelevenshtein.cpp [code] |
| classifies constraints according to levenshtein distance graph of their names
|
|
file | clscons_consnamelevenshtein.h [code] |
| classifies constraints according to levenshtein distance graph of their names
|
|
file | clscons_consnamenonumbers.cpp [code] |
| classifies constraints according to names (without digits)
|
|
file | clscons_consnamenonumbers.h [code] |
| classifies constraints according to names (without digits)
|
|
file | clscons_gamsdomain.cpp [code] |
| Classifies by domains from which constraints are created TODO: what is together in one class?
|
|
file | clscons_gamsdomain.h [code] |
| Classifies by domains from which constraints are created TODO: what is together in one class?
|
|
file | clscons_gamssymbol.cpp [code] |
| gamssymbol constraint classifier (classifies by corresponding GAMS symbol)
|
|
file | clscons_gamssymbol.h [code] |
| Constraints which have the same symbol are put into same class.
|
|
file | clscons_miplibconstypes.cpp [code] |
| classifies constraints according to their miplib constypes
|
|
file | clscons_miplibconstypes.h [code] |
| classifies constraints according to their miplib constypes
|
|
file | clscons_nnonzeros.cpp [code] |
| classifies constraints according to their nonzero entries
|
|
file | clscons_nnonzeros.h [code] |
| classifies constraints according to their nonzero entries
|
|
file | clscons_scipconstypes.cpp [code] |
| classifies constraints according to their scip constypes
|
|
file | clscons_scipconstypes.h [code] |
| classifies constraints according to their scip constypes
|
|
file | clsvar_gamsdomain.cpp [code] |
| Classifies by domains from which variables are created TODO: what is together in one class?
|
|
file | clsvar_gamsdomain.h [code] |
| Classifies by domains from which variables are created TODO: what is together in one class?
|
|
file | clsvar_gamssymbol.cpp [code] |
| variables which have the same symbol are put into same class
|
|
file | clsvar_gamssymbol.h [code] |
| variables which have the same symbol are put into same class
|
|
file | clsvar_objvalues.cpp [code] |
| classifies variables according to their objective function values
|
|
file | clsvar_objvalues.h [code] |
| classifies variables according to their objective function values
|
|
file | clsvar_objvaluesigns.cpp [code] |
| classifies variables according to their objective function value signs
|
|
file | clsvar_objvaluesigns.h [code] |
| classifies variables according to their objective function value signs
|
|
file | clsvar_scipvartypes.cpp [code] |
| classifies variables according to their scip vartypes
|
|
file | clsvar_scipvartypes.h [code] |
| classifies variables according to their scip vartypes
|
|
file | colpool.c [code] |
| methods for storing cols in a col pool (based on SCIP's cut pool)
|
|
file | colpool.h [code] |
| internal methods for storing cols in a col pool
|
|
file | cons_decomp.cpp [code] |
| constraint handler for structure detection
|
|
file | cons_decomp.h [code] |
| constraint handler for structure detection
|
|
file | cons_decomp.hpp [code] |
| C++ interface of cons_decomp.
|
|
file | cons_integralorig.c [code] |
| constraint handler for enforcing integrality of the transferred master solution in the original problem
|
|
file | cons_integralorig.h [code] |
| constraint handler for the integrality constraint
|
|
file | cons_masterbranch.c [code] |
| constraint handler for storing the branching decisions at each node of the tree
|
|
file | cons_masterbranch.h [code] |
| constraint handler for storing the branching decisions at each node of the tree
|
|
file | cons_origbranch.c [code] |
| constraint handler for storing the branching decisions at each node of the tree
|
|
file | cons_origbranch.h [code] |
| constraint handler for storing the branching decisions at each node of the tree
|
|
file | dec_compgreedily.cpp [code] |
| detector compgreedily (assigns the open cons and open vars of the partialdec greedily)
|
|
file | dec_compgreedily.h [code] |
| compgreedily detector
|
|
file | dec_connected_noNewLinkingVars.cpp [code] |
| detector connected_noNewLinkingVars (assigns all dependent open conss and vars and completes the partialdec by bfs)
|
|
file | dec_connected_noNewLinkingVars.h [code] |
| connected_noNewLinkingVars detector
|
|
file | dec_connectedbase.cpp [code] |
| detector connectedbase (completes the partialdec by bfs)
|
|
file | dec_connectedbase.h [code] |
| connectedbase detector
|
|
file | dec_consclass.cpp [code] |
| detector consclass (put your description here)
|
|
file | dec_consclass.h [code] |
| consclass detector
|
|
file | dec_constype.cpp [code] |
| detector constype (put your description here)
|
|
file | dec_constype.h [code] |
| constype detector
|
|
file | dec_dbscan.cpp [code] |
| detector DBSCAN
|
|
file | dec_dbscan.h [code] |
| detector for diagonal (bordered) structures via DBSCAN clustering algorithm
|
|
file | dec_densemasterconss.cpp [code] |
| detector densemasterconss (put your description here)
|
|
file | dec_densemasterconss.h [code] |
| densemasterconss detector
|
|
file | dec_generalmastersetcover.cpp [code] |
| detector for set covering constraints
|
|
file | dec_generalmastersetcover.h [code] |
| generalmastersetcover detector
|
|
file | dec_generalmastersetpack.cpp [code] |
| detector for set packing constraints
|
|
file | dec_generalmastersetpack.h [code] |
| generalmastersetpack detector
|
|
file | dec_generalmastersetpart.cpp [code] |
| detector for set partitioning constraints
|
|
file | dec_generalmastersetpart.h [code] |
| generalmastersetpart detector
|
|
file | dec_hcgpartition.cpp [code] |
| arrowhead and bordered detector via graph partitioning (uses hmetis)
|
|
file | dec_hcgpartition.h [code] |
| arrowhead and bordered detector via graph partitioning (uses hmetis)
|
|
file | dec_hrcgpartition.cpp [code] |
| arrowhead and bordered detector via graph partitioning (uses hmetis)
|
|
file | dec_hrcgpartition.h [code] |
| arrowhead and bordered detector via graph partitioning (uses hmetis)
|
|
file | dec_hrgpartition.cpp [code] |
| arrowhead and bordered detector via graph partitioning (uses hmetis)
|
|
file | dec_hrgpartition.h [code] |
| arrowhead and bordered detector via graph partitioning (uses hmetis)
|
|
file | dec_isomorph.cpp [code] |
| detector for pricing problems that can be aggregated (uses bliss)
|
|
file | dec_isomorph.h [code] |
| detector for pricing problems that can be aggregated (uses bliss)
|
|
file | dec_mastersetcover.cpp [code] |
| detector mastersetcover (sets setcovering and logicor constraint to master)
|
|
file | dec_mastersetcover.h [code] |
| mastersetcover detector
|
|
file | dec_mastersetpack.cpp [code] |
| detector mastersetpack (sets setpacking constraints to master)
|
|
file | dec_mastersetpack.h [code] |
| mastersetpack detector
|
|
file | dec_mastersetpart.cpp [code] |
| detector mastersetpart (set setpartitioning constraints to master)
|
|
file | dec_mastersetpart.h [code] |
| mastersetpart detector
|
|
file | dec_mst.cpp [code] |
| minimum spanning tree clustering detector
|
|
file | dec_mst.h [code] |
| detector for diagonal (bordered) structures via Minimum Spanning Tree clustering algorithm
|
|
file | dec_neighborhoodmaster.cpp [code] |
| detector neighborhoodmaster (This detector calculates cons-cons adjacency (if not already done), sorts constraints according size of neighborhood. Searching two consecutive constraints with largest size difference (according neighborhood size) in sorted constraints. All constraints having a larger neighborhood than the second one are assigned to the master)
|
|
file | dec_neighborhoodmaster.h [code] |
| neighborhoodmaster detector
|
|
file | dec_postprocess.cpp [code] |
| checks if there are master constraints that can be assigned to one block (without any other changes)
|
|
file | dec_postprocess.h [code] |
| postprocess detector
|
|
file | dec_staircase_lsp.cpp [code] |
| detector for staircase_lsp matrices
|
|
file | dec_staircase_lsp.h [code] |
| staircase compontent detector
|
|
file | dec_stairheur.cpp [code] |
| detector for staircase structures via ROC algorithms
|
|
file | dec_stairheur.h [code] |
| detector for staircase structures via ROC algorithms
|
|
file | dec_varclass.cpp [code] |
| detector varclass
|
|
file | dec_varclass.h [code] |
| varclass detector
|
|
file | decomp.c [code] |
| generic methods for working with different decomposition structures
|
|
file | decomp.h [code] |
| private methods for working with decomp structures
|
|
file | def.h [code] |
| common defines and data types used in all packages of GCG
|
|
file | dialog_explore.cpp [code] |
| dialog menu for exploring decompositions
|
|
file | dialog_explore.h [code] |
| dialog menu for exploring decompositions
|
|
file | dialog_gcg.c [code] |
| GCG user interface dialog.
|
|
file | dialog_gcg.h [code] |
| GCG user interface dialog.
|
|
file | dialog_graph.cpp [code] |
| A dialog to write graph representations of the matrix and read partitions as decompositions.
|
|
file | dialog_graph.h [code] |
| A dialog to write graph representations of the matrix and read partitions as decompositions.
|
|
file | dialog_master.c [code] |
| user interface dialog for master problem
|
|
file | dialog_master.h [code] |
| user interface dialog for master problem
|
|
file | disp_gcg.c [code] |
| GCG display columns.
|
|
file | disp_gcg.h [code] |
| GCG display columns.
|
|
file | disp_master.c [code] |
| master display columns
|
|
file | disp_master.h [code] |
| master display columns
|
|
file | event_bestsol.c [code] |
| eventhdlr to record the best primal bound for each heuristic
|
|
file | event_bestsol.h [code] |
| eventhdlr to record the best primal bound for each heuristic
|
|
file | event_display.c [code] |
| eventhdlr to disable the master display after the root node
|
|
file | event_display.h [code] |
| eventhdlr to disable the master display after the root node
|
|
file | event_mastersol.c [code] |
| eventhdlr to transfer solutions found in the original problem to the master problem
|
|
file | event_mastersol.h [code] |
| eventhdlr to transfer solutions found in the original problem to the master problem
|
|
file | event_relaxsol.c [code] |
| eventhandler to update the relaxation solution in the original problem when the master LP has been solved
|
|
file | event_relaxsol.h [code] |
| eventhandler to update the relaxation solution in the original problem when the master LP has been solved
|
|
file | event_solvingstats.c [code] |
| eventhdlr for writing various types of information during the solving process
|
|
file | event_solvingstats.h [code] |
| eventhdlr for writing various types of information during the solving process
|
|
file | gcg.h [code] |
| GCG interface methods.
|
|
file | gcg_general.c [code] |
| gcg general public methods
|
|
file | gcg_general.h [code] |
| gcg general public methods
|
|
file | gcgcol.c [code] |
| methods for working with gcg column structure
|
|
file | gcgcol.h [code] |
| private methods for working with gcg column data structure
|
|
file | gcggithash.c [code] |
| git hash methods
|
|
file | gcggithash.h [code] |
| git hash methods
|
|
file | gcgheur.c [code] |
| public methods for GCG heuristics
|
|
file | gcgplugins.c [code] |
| SCIP plugins for generic column generation.
|
|
file | gcgplugins.h [code] |
| SCIP plugins for generic column generation.
|
|
file | gcgpqueue.c [code] |
| methods for working with priority queue
|
|
file | gcgpqueue.h [code] |
| private methods for working with priority queue
|
|
file | gcgsepa.c [code] |
| public methods for GCG separators
|
|
file | gcgsort.c [code] |
| sorting methods, adapted from SCIP's sorttpl.c to include userdata
|
|
file | gcgsort.h [code] |
| sorting functions, adapted from SCIP's sorttpl to include userdata
|
|
file | gcgsorttpl.c [code] |
| template functions for sorting
|
|
file | gcgvar.c [code] |
| GCG variable access functions.
|
|
file | heur_gcgcoefdiving.c [code] |
| LP diving heuristic that chooses fixings w.r.t. the matrix coefficients.
|
|
file | heur_gcgcoefdiving.h [code] |
| LP diving heuristic that chooses fixings w.r.t. the matrix coefficients.
|
|
file | heur_gcgdins.c [code] |
| DINS primal heuristic (according to Ghosh)
|
|
file | heur_gcgdins.h [code] |
| DINS primal heuristic.
|
|
file | heur_gcgfeaspump.c [code] |
| Objective Feasibility Pump 2.0.
|
|
file | heur_gcgfeaspump.h [code] |
| Objective Feasibility Pump 2.0.
|
|
file | heur_gcgfracdiving.c [code] |
| LP diving heuristic that chooses fixings w.r.t. the fractionalities.
|
|
file | heur_gcgfracdiving.h [code] |
| LP diving heuristic that chooses fixings w.r.t. the fractionalities.
|
|
file | heur_gcgguideddiving.c [code] |
| LP diving heuristic that chooses fixings in direction of incumbent solutions.
|
|
file | heur_gcgguideddiving.h [code] |
| LP diving heuristic that chooses fixings in direction of incumbent solutions.
|
|
file | heur_gcglinesdiving.c [code] |
| LP diving heuristic that fixes variables with a large difference to their root solution.
|
|
file | heur_gcglinesdiving.h [code] |
| LP diving heuristic that fixes variables with a large difference to their root solution.
|
|
file | heur_gcgpscostdiving.c [code] |
| LP diving heuristic that chooses fixings w.r.t. the pseudo cost values.
|
|
file | heur_gcgpscostdiving.h [code] |
| LP diving heuristic that chooses fixings w.r.t. the pseudo cost values.
|
|
file | heur_gcgrens.c [code] |
| LNS heuristic that finds the optimal rounding to a given point.
|
|
file | heur_gcgrens.h [code] |
| LNS heuristic that finds the optimal rounding to a given point.
|
|
file | heur_gcgrins.c [code] |
| LNS heuristic that combines the incumbent with the LP optimum.
|
|
file | heur_gcgrins.h [code] |
| LNS heuristic that combines the incumbent with the LP optimum.
|
|
file | heur_gcgrounding.c [code] |
| LP gcgrounding heuristic that tries to recover from intermediate infeasibilities.
|
|
file | heur_gcgrounding.h [code] |
| LP gcgrounding heuristic that tries to recover from intermediate infeasibilities.
|
|
file | heur_gcgshifting.c [code] |
| LP gcgrounding heuristic that tries to recover from intermediate infeasibilities and shifts continuous variables.
|
|
file | heur_gcgshifting.h [code] |
| LP gcgrounding heuristic that tries to recover from intermediate infeasibilities and shifts continuous variables.
|
|
file | heur_gcgsimplerounding.c [code] |
| simple and fast LP rounding heuristic
|
|
file | heur_gcgsimplerounding.h [code] |
| simple and fast LP rounding heuristic
|
|
file | heur_gcgveclendiving.c [code] |
| LP diving heuristic that rounds variables with long column vectors.
|
|
file | heur_gcgveclendiving.h [code] |
| LP diving heuristic that rounds variables with long column vectors.
|
|
file | heur_gcgzirounding.c [code] |
| zirounding primal heuristic
|
|
file | heur_gcgzirounding.h [code] |
| zirounding primal heuristic
|
|
file | heur_greedycolsel.c [code] |
| greedy column selection primal heuristic
|
|
file | heur_greedycolsel.h [code] |
| greedy column selection primal heuristic
|
|
file | heur_mastercoefdiving.c [code] |
| master LP diving heuristic that chooses fixings w.r.t. the matrix coefficients
|
|
file | heur_mastercoefdiving.h [code] |
| master LP diving heuristic that chooses fixings w.r.t. the matrix coefficients
|
|
file | heur_masterdiving.c [code] |
| primal heuristic interface for LP diving heuristics on the master variables
|
|
file | heur_masterdiving.h [code] |
| primal heuristic interface for LP diving heuristics on the master variables
|
|
file | heur_masterfracdiving.c [code] |
| master LP diving heuristic that chooses fixings w.r.t. the fractionalities
|
|
file | heur_masterfracdiving.h [code] |
| master LP diving heuristic that chooses fixings w.r.t. the fractionalities
|
|
file | heur_masterlinesdiving.c [code] |
| LP diving heuristic that fixes variables with a large difference to their root solution.
|
|
file | heur_masterlinesdiving.h [code] |
| master LP diving heuristic that fixes variables with a large difference to their root solution
|
|
file | heur_mastervecldiving.c [code] |
| master LP diving heuristic that rounds variables with long column vectors
|
|
file | heur_mastervecldiving.h [code] |
| master LP diving heuristic that rounds variables with long column vectors
|
|
file | heur_origdiving.c [code] |
| primal heuristic interface for LP diving heuristics on the original variables
|
|
file | heur_origdiving.h [code] |
| primal heuristic interface for LP diving heuristics on the original variables
|
|
file | heur_relaxcolsel.c [code] |
| relaxation based column selection primal heuristic
|
|
file | heur_relaxcolsel.h [code] |
| relaxation based column selection primal heuristic
|
|
file | heur_restmaster.c [code] |
| Restricted Master Heuristic.
|
|
file | heur_restmaster.h [code] |
| Restricted Master Heuristic.
|
|
file | heur_setcover.c [code] |
| set covering primal heuristic according to Caprara, Fischetti, and Toth (1999)
|
|
file | heur_setcover.h [code] |
| set covering primal heuristic according to Caprara, Fischetti, and Toth (1999)
|
|
file | heur_xpcrossover.c [code] |
| Extreme Point Crossover.
|
|
file | heur_xpcrossover.h [code] |
| Extreme Point Crossover.
|
|
file | heur_xprins.c [code] |
| Extreme Point RINS.
|
|
file | heur_xprins.h [code] |
| Extreme Point RINS.
|
|
file | main.c [code] |
| Main file for C compilation.
|
|
file | masterplugins.c [code] |
| SCIP plugins for generic column generation.
|
|
file | masterplugins.h [code] |
| SCIP plugins for generic column generation.
|
|
file | misc.c [code] |
| miscellaneous methods
|
|
file | miscvisualization.cpp [code] |
| miscellaneous methods for visualizations
|
|
file | miscvisualization.h [code] |
| miscellaneous methods for visualizations
|
|
file | nodesel_master.c [code] |
| node selector for coordination of master and original formulation
|
|
file | nodesel_master.h [code] |
| Node selector for coordination of master and original formulation.
|
|
file | objdialog.cpp [code] |
| C++ wrapper for dialogs.
|
|
file | objdialog.h [code] |
| C++ wrapper for dialogs.
|
|
file | objpricer_gcg.h [code] |
| GCG variable pricer.
|
|
file | params_visu.c [code] |
| parameter settings for visualization readers
|
|
file | params_visu.h [code] |
|
file | presol_roundbound.c [code] |
| roundbound presolver: round fractional bounds on integer variables
|
|
file | presol_roundbound.h [code] |
| roundbound presolver: round fractional bounds on integer variables
|
|
file | pricer_gcg.cpp [code] |
| pricer for generic column generation
|
|
file | pricer_gcg.h [code] |
| GCG variable pricer.
|
|
file | pricestore_gcg.c [code] |
| methods for storing priced cols (based on SCIP's separation storage)
|
|
file | pricestore_gcg.h [code] |
| methods for storing priced cols (based on SCIP's separation storage)
|
|
file | pricingjob.c [code] |
| methods for working with pricing jobs
|
|
file | pricingjob.h [code] |
| private methods for working with pricing jobs, to be used by the pricing controller only
|
|
file | pricingprob.c [code] |
| methods for working with pricing problems
|
|
file | pricingprob.h [code] |
| private methods for working with pricing problems, to be used by the pricing controller only
|
|
file | pub_bliss.h [code] |
| helper functions for automorphism detection
|
|
file | pub_colpool.h [code] |
| public methods for storing cols in a col pool
|
|
file | pub_decomp.h [code] |
| public methods for working with decomposition structures
|
|
file | pub_gcgcol.h [code] |
| public methods for working with gcg columns
|
|
file | pub_gcgheur.h [code] |
| public methods for GCG heuristics
|
|
file | pub_gcgpqueue.h [code] |
|
file | pub_gcgsepa.h [code] |
| public methods for GCG separators
|
|
file | pub_gcgvar.h [code] |
| public methods for GCG variables
|
|
file | pub_pricingjob.h [code] |
| public methods for working with pricing jobs
|
|
file | pub_pricingprob.h [code] |
| public methods for working with pricing problems
|
|
file | pub_solver.h [code] |
|
file | reader_blk.cpp [code] |
| BLK file reader for structure information.
|
|
file | reader_blk.h [code] |
| BLK file reader for structure information.
|
|
file | reader_cls.cpp [code] |
| CLS reader for writing files containing classification data.
|
|
file | reader_cls.h [code] |
| CLS reader for writing files containing classification data.
|
|
file | reader_dec.cpp [code] |
| DEC file reader for structure information.
|
|
file | reader_dec.h [code] |
| DEC file reader for structure information.
|
|
file | reader_gp.cpp [code] |
| GP file reader writing decompositions to gnuplot files.
|
|
file | reader_gp.h [code] |
| GP file reader writing decompositions to gnuplot files.
|
|
file | reader_ref.c [code] |
| REF file reader for structure information.
|
|
file | reader_ref.h [code] |
| REF file reader for structure information.
|
|
file | reader_tex.cpp [code] |
| tex file reader for writing partialdecs to LaTeX files
|
|
file | reader_tex.h [code] |
| parameter settings for visualization readers
|
|
file | relax_gcg.c [code] |
| GCG relaxator.
|
|
file | relax_gcg.h [code] |
| GCG relaxator.
|
|
file | scip_misc.c [code] |
| various SCIP helper methods
|
|
file | scip_misc.h [code] |
| various SCIP helper methods
|
|
file | scoretype.c [code] |
|
file | scoretype.h [code] |
| miscellaneous methods for working with SCORETYPE
|
|
file | sepa_basis.c [code] |
| basis separator
|
|
file | sepa_basis.h [code] |
| basis separator
|
|
file | sepa_master.c [code] |
| master separator
|
|
file | sepa_master.h [code] |
| master separator
|
|
file | solver.c [code] |
| methods for GCG pricing solvers
|
|
file | solver.h [code] |
| public methods for GCG pricing solvers
|
|
file | solver_cliquer.c [code] |
| heuristic solver for pricing problems that solves independent set problems with cliquer
|
|
file | solver_cliquer.h [code] |
| heuristic solver for pricing problems that solves independent set problems with cliquer
|
|
file | solver_cplex.c [code] |
| cplex solver for pricing problems
|
|
file | solver_cplex.h [code] |
| cplex solver for pricing problems
|
|
file | solver_knapsack.c [code] |
| knapsack solver for pricing problems
|
|
file | solver_knapsack.h [code] |
| knapsack solver for pricing problems
|
|
file | solver_mip.c [code] |
| pricing solver solving the pricing problem as a sub-MIP, using SCIP
|
|
file | solver_mip.h [code] |
| mip solver for pricing problems
|
|
file | stat.c [code] |
| Some printing methods for statistics.
|
|
file | stat.h [code] |
| Prints information about the best decomposition.
|
|
file | struct_branchgcg.h [code] |
| data structures for branching rules
|
|
file | struct_colpool.h [code] |
| data structures for storing cols in a col pool
|
|
file | struct_consclassifier.h [code] |
| data structures for constraint classifiers
|
|
file | struct_decomp.h [code] |
| structure information for decomposition information in GCG projects
|
|
file | struct_detector.h [code] |
| data structures for detectors
|
|
file | struct_gcgcol.h [code] |
| data structure to store columns (solutions from a pricing problem)
|
|
file | struct_gcgpqueue.h [code] |
| data structure for priority queue
|
|
file | struct_pricestore_gcg.h [code] |
| datastructures for storing priced cols
|
|
file | struct_pricingjob.h [code] |
| data structure for pricing jobs
|
|
file | struct_pricingprob.h [code] |
| data structure to store pricing problem information
|
|
file | struct_solver.h [code] |
| data structures for solvers
|
|
file | struct_varclassifier.h [code] |
| data structures for variable classifiers
|
|
file | struct_vardata.h [code] |
| data structures for GCG variable data
|
|
file | type_branchgcg.h [code] |
| type definitions for branching rules in GCG projects
|
|
file | type_classifier.h [code] |
| type definitions for classifier in GCG project
|
|
file | type_colpool.h [code] |
| type definitions for storing cols in a col pool
|
|
file | type_consclassifier.h [code] |
| type definitions for constraints classifier in GCG projects
|
|
file | type_decomp.h [code] |
| type definitions for decomposition information in GCG projects
|
|
file | type_detector.h [code] |
| type definitions for detectors in GCG projects
|
|
file | type_gcgcol.h [code] |
| type definitions for gcg column data structure
|
|
file | type_gcgpqueue.h [code] |
| type definitions for priority queue
|
|
file | type_masterdiving.h [code] |
| type definitions for GCG diving heuristics on the master variables
|
|
file | type_origdiving.h [code] |
| type definitions for GCG diving heuristics on the original variables
|
|
file | type_parameter.h [code] |
| type definitions for parameters in GCG project
|
|
file | type_pricestore_gcg.h [code] |
| type definitions for storing priced cols
|
|
file | type_pricingjob.h [code] |
| type definitions for pricing job data structure
|
|
file | type_pricingprob.h [code] |
| type definitions for pricing problem data structure
|
|
file | type_pricingstatus.h [code] |
| type definitions for pricing status
|
|
file | type_scoretype.h [code] |
| type definition for score type
|
|
file | type_solver.h [code] |
| type definitions for pricing problem solvers in GCG project
|
|
file | type_varclassifier.h [code] |
| type definitions for variable classifier in GCG projects
|
|
file | wrapper_partialdecomp.h [code] |
| Provides wrapping to have Partialdecomps as parameters in C-conform function headers with C++ implementations.
|
|