|
| 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.
|
| |