GCG Version 2.1.2

- changed interface to SCIP 4.0.0

code cleanup
- reallocate memory for original variable array in pricing variable data more efficiently
- reorder permutations in isomorph detector according to orbit size and add maxdecomps parameter

bug fixes
- fixed handling of fixed variables in decompositions
- update include method of solver template
- fix GCGconsGet*() methods such that negated variables are handled correctly
- fix bug in transformation of master solution to original solution
- small bugfix in method that creates column graph from matrix
- fixed memory errors in unit tests
- fix memory issue with GCG_COL's
- fix the deletion of old columns in the column pool
- fix propagation of original variable bounds to the pricing problems:
  propapagte bounds only if identical variables have the same bounds,
  throw an error message otherwise
- in case of global bound changes on original variables, check if the current relaxation
  solution satisfies the new bound, and mark it invalid if not
- stop the reduced cost pricing clock correctly
- free redundant decompositions correctly
- fix identity check of decompositions
- fix bug in createPolishedDecomp()
- fix bug in isomorph detector
- avoid numerical troubles by rounding integral pricing solutions if possible

GCG Version 2.1.1

code cleanup
- simplified logic when assigning variables to blocks

bug fixes
- use only one hashmap when initializing pricing problems
- small bugfix in set covering heuristic
- fixed a bug in original variable diving heuristics
- fixed a time limit issue concerning the master problem that was introduced by the SCIP reoptimization feature
- reorganized detector callbacks and thus fixed memory leaks when reading a new instance
- fixed memory allocation in basis separator

GCG Version 2.1.0

- column pool
- new set covering heuristic
- basis cuts separator
- numerical tolerances of the original problem are used in the master and pricing problems
- new compiler flag CPLEXSOLVER to solve pricing problems with CPLEX

code cleanup
- re-organized constraint handlers for managing branching decisions in original and master problems
- simplified code and reduced memory consumption in cutpacking detector

bug fixes
- GCG columns are freed correctly in the pricer

GCG Version 2.0.1

- decomposition and pricing problems are permuted when the permutation
  seed is set
- progress in dual bound is now displayed while solving the root node
- pricing solvers can be enabled or disabled via parameter
- display blocks found for decomposition in statistics
- new boundtype for fixed original variables due to branching
- use new GCG column structure instead SCIP solution structure in pricing

code cleanup
- simplify code in generic branching
- structure of method branchVar()

bug fixes
- fix bugs concerning stabilization
- disable stabilization when linking variables or variables belonging to no block are present
- CPLEX pricing solver is disabled as it is incompatible with generic branching
- fix memory issues
- fix bound propagation bugs
- fix bug in knapsack solver
- delete constraints added at presolving after the root node
- check feasibility of current solution in original problem if this fails in the transformed problem
- fix wrong aggregation when using bliss
- print warnings when pricing is aborted
- fix translation of original solution to master problem when pricing problems are aggregated
- better handling of infinite objective values in pricing

GCG Version 2.0
- GCG can now automatically create a decomposition to solve the LP with
  empty pricing problems. See the cons/decomp/createbasicdecomp parameter
- GCG can aggregate pricing problems using bliss which enables us to
  aggregate more pricing problems
- GCG can solve pricing problems in parallel
- GCG uses dual variable smoothing to stabilize dual values
- GCG can branch on integer aggregated problems using Vanderbeck's general
  branching rule
- GCG can solve integer knapsack problems as a dynamic program
- GCG features additional detectors which are able to detect significantly
  more structures such as staircase structures and problems that can be
- improved heuristics
- copy solutions from original problem to master problem
- improved handling of compile flags changes such as an automatic
  recompilation if, e.g., USRFLAGS change
- new solver for pricing problems that uses CPLEX to solve the MIP
  (enabled if LPS=cpx)

code cleanup
- moved some detection methods to a more global scope to make them reusable
- added testing framework to do regression testing (uses google test)
- extracted graph methods for reuse
- branching is now done in the master problem
- remove code that was never called
- Rename methods in order to state their intention
- provide a gcg.h file to easily use the most common methods

bug fixes
- memory allocation bugs
- bound change propagation fixes
- corrected copyright
- fixed a lot of code checker issues
- use an event handler to disable the master display
- override PARASCIP=true if OPENMP=true
- correct decomp documentation and simplify decomposition interfaces

GCG Version 1.1
- add staircase structure information
- add staircase structure detection
- the set partitioning detector can create decompositions with one block
- GCG is now separated in a library and a main file so that you can link
  against it

bug fixes
- decompositions are now correctly classified
- clean up lots of errors related to inconsistent decompositions
- safe handling of empty problems
- fix detection of identical pricingproblems for aggregation

code cleanup
- use DECfilloutDecdecompFromHashmaps where appropriate to remove redundant
- Provide DECfillOutFromConstoblock to enable creation of decomposition
  structures by just specifying constraint to block partition
- Add consistency check function for decompositions
- removed a bit of redundant and leftover code

GCG Version 1.0
- include variable deletion code
- add a block diagonal detector (cons_connected)
- add a new default constraint based decomposition format with reader (dec)
- added new heuristics gcgrins and xprins
- decompositions from multiple detectors are compared in cons_decomp.h
- added block diagonal detection code, GCG solves these more intelligently
- added detection of standard problems to block detection code
- add additional statistics
- structure information can now contain presolving information
- GCG works with SCIP version 3.0

- reworked decdecomp structure handling
- merge recent SCIP heuristic changes to their GCG counterparts

bug fixes
- try to deal with the time limit of the master by looping until the
  original instance hits the time limit
- try to avoid infeasible problems if the timelimit is hit during farkas
- fix bugs related to copying master solutions to the original problem
- fix bugs where solutions are not correctly freed
- fix bug: heuristics that use SCIPcopy really create a working copy
- fix propagation bugs
- fix issues with empty problems and problems solved in the root node
- rewrite relaxcolsel heuristic
- moved probing methods to relax_gcg.c and fixed heuristics to use them
- fix a vardata creation bug
- copy cuts in LNS heuristics correctly
- fixed bugs related to presolving
- fixed bugs related to linking variables
- fixed bugs in Ryan-Foster branching
- fix some memory issues

code cleanup
- updated the documentation
- cleaned up code (whitespace and code style changes)
- removed all vardata accesses from all files
- removed a lot of old code
- remove dead code and give the code some love
- refactored some parts to remove large methods
- cleaned up detector interface
- make sure code is clean with all our compilers and code checking tools

- adjusted default parameters
- improve memory handling by switching to buffer memory in appropriate cases
  and away from buffer in others

- make githash look nicer
- nicer decomposition output

Makefile and scripts
- add lint directory for static code analysis
- add SCIP target to makefile
- fix scripts for RWTH Aachens high performing cluster
- add possibility to create SCIP link automatically
- add small testset to enable small functionality tests
- add some modes to test script in order to create and collect
- fix clean rule to a safer version

GCG Version 0.9
- included new heuristics
- included new reader for the ref file format
- added support for linking variables
- added generalized reliability branching using probing
- added constraint handler to enforce integral original variables
- allow for unbounded pricing problems
- branch also on pseudosolutions
- support probing for heuristics
- GCG works with SCIP version 2.0

bug fixes
- fixed multiple bugs related to timing issues
- fixed bugs related to working with the presolved problem

- allow master to be accessed from the command line interface
- Change branding in interactive SHELL, display version and githash
- added more extensive test framework
- added gnuplot visualization reader
- added much more extensive documentation

GCG Version 0.81
- polished source code

bug fixes
- some

GCG Version 0.8
- fixed some bugs for solving MIPs when branching on variables that were
  directly transferred to the master problem

GCG Version 0.7
- some bugfixes

GCG Version 0.6
- implemented dialog handler for GCG
- added concept of pricing solvers
- statistics about pricing are displayed at the end of solving

- quite a few

GCG Version 0.5
- fixed problems with transfering bounds from the original program to the
  master program: when propagating a node, the bounds of all variables in
  the pricing problem and variables copied to the master are adjusted, for
  all master variables created by the pricer, it is checked whether they
  fulfill the current bounds
- fixed bug when disabling discretization approach

GCG Version 0.4
- working SCIP represents the original problem
- read in problem is standard format (e.g., .lp-file, .mps-file) and
  corresponding blk-file
- the master problem is represented by a relaxator, which replaces the LP-solving
- separation is done by a separator included in the master SCIP, which calls the
  SCIPseparateSol() method in the original SCIP
- branching is done simultaneously in the master and in the original SCIP
- variables in the master are extreme points of conv(X) (and extreme rays, but
  functionality currently not implemented) -> convexification approach
- many identical pricing problems -> fat too much effort for pricing,
  especially farkas pricing!
- 2 constraint handler assure that nodes in the master SCIP are linked to
  nodes in the original SCIP and vice versa
- branching rules are implemented as branching rules in the master that
  have to define the additional callbacks specified in "type_branchgcg.h"

- in blk-file constraints can be forced to be copied to the master problem;
  all other constraints are added to a block, if they only contain variables
  of this block
- added possibility to use discretization approach, variables in the
  master then represent integer points in X, integrality in the master is
- identification of identical blocks -> break symmetrie in the master
- 2 branching rules implemented so far:
  * branching on original variables (not possible if variable belongs to a
    block that has similar blocks in the problem), using pseudocost values
    to choose the variable to branch on
  * ryan-foster type of branching for identical blocks with set partitioning
- added GCGs own display plugin showing the number of LP iterations, of
  constraints, variables and cuts in the master