Class GlopParameters

java.lang.Object
com.google.protobuf.AbstractMessageLite
com.google.protobuf.AbstractMessage
com.google.protobuf.GeneratedMessage
com.google.ortools.glop.GlopParameters
All Implemented Interfaces:
GlopParametersOrBuilder, com.google.protobuf.Message, com.google.protobuf.MessageLite, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, Serializable
@Generated public final class GlopParameters extends com.google.protobuf.GeneratedMessage implements GlopParametersOrBuilder
 next id = 73
Protobuf type operations_research.glop.GlopParameters
See Also:

  • Field Details

    • SCALING_METHOD_FIELD_NUMBER

      public static final int SCALING_METHOD_FIELD_NUMBER
      See Also:

    • FEASIBILITY_RULE_FIELD_NUMBER

      public static final int FEASIBILITY_RULE_FIELD_NUMBER
      See Also:

    • OPTIMIZATION_RULE_FIELD_NUMBER

      public static final int OPTIMIZATION_RULE_FIELD_NUMBER
      See Also:

    • REFACTORIZATION_THRESHOLD_FIELD_NUMBER

      public static final int REFACTORIZATION_THRESHOLD_FIELD_NUMBER
      See Also:

    • RECOMPUTE_REDUCED_COSTS_THRESHOLD_FIELD_NUMBER

      public static final int RECOMPUTE_REDUCED_COSTS_THRESHOLD_FIELD_NUMBER
      See Also:

    • RECOMPUTE_EDGES_NORM_THRESHOLD_FIELD_NUMBER

      public static final int RECOMPUTE_EDGES_NORM_THRESHOLD_FIELD_NUMBER
      See Also:

    • PRIMAL_FEASIBILITY_TOLERANCE_FIELD_NUMBER

      public static final int PRIMAL_FEASIBILITY_TOLERANCE_FIELD_NUMBER
      See Also:

    • DUAL_FEASIBILITY_TOLERANCE_FIELD_NUMBER

      public static final int DUAL_FEASIBILITY_TOLERANCE_FIELD_NUMBER
      See Also:

    • RATIO_TEST_ZERO_THRESHOLD_FIELD_NUMBER

      public static final int RATIO_TEST_ZERO_THRESHOLD_FIELD_NUMBER
      See Also:

    • HARRIS_TOLERANCE_RATIO_FIELD_NUMBER

      public static final int HARRIS_TOLERANCE_RATIO_FIELD_NUMBER
      See Also:

    • SMALL_PIVOT_THRESHOLD_FIELD_NUMBER

      public static final int SMALL_PIVOT_THRESHOLD_FIELD_NUMBER
      See Also:

    • MINIMUM_ACCEPTABLE_PIVOT_FIELD_NUMBER

      public static final int MINIMUM_ACCEPTABLE_PIVOT_FIELD_NUMBER
      See Also:

    • DROP_TOLERANCE_FIELD_NUMBER

      public static final int DROP_TOLERANCE_FIELD_NUMBER
      See Also:

    • USE_SCALING_FIELD_NUMBER

      public static final int USE_SCALING_FIELD_NUMBER
      See Also:

    • COST_SCALING_FIELD_NUMBER

      public static final int COST_SCALING_FIELD_NUMBER
      See Also:

    • INITIAL_BASIS_FIELD_NUMBER

      public static final int INITIAL_BASIS_FIELD_NUMBER
      See Also:

    • USE_TRANSPOSED_MATRIX_FIELD_NUMBER

      public static final int USE_TRANSPOSED_MATRIX_FIELD_NUMBER
      See Also:

    • BASIS_REFACTORIZATION_PERIOD_FIELD_NUMBER

      public static final int BASIS_REFACTORIZATION_PERIOD_FIELD_NUMBER
      See Also:

    • DYNAMICALLY_ADJUST_REFACTORIZATION_PERIOD_FIELD_NUMBER

      public static final int DYNAMICALLY_ADJUST_REFACTORIZATION_PERIOD_FIELD_NUMBER
      See Also:

    • SOLVE_DUAL_PROBLEM_FIELD_NUMBER

      public static final int SOLVE_DUAL_PROBLEM_FIELD_NUMBER
      See Also:

    • DUALIZER_THRESHOLD_FIELD_NUMBER

      public static final int DUALIZER_THRESHOLD_FIELD_NUMBER
      See Also:

    • SOLUTION_FEASIBILITY_TOLERANCE_FIELD_NUMBER

      public static final int SOLUTION_FEASIBILITY_TOLERANCE_FIELD_NUMBER
      See Also:

    • PROVIDE_STRONG_OPTIMAL_GUARANTEE_FIELD_NUMBER

      public static final int PROVIDE_STRONG_OPTIMAL_GUARANTEE_FIELD_NUMBER
      See Also:

    • CHANGE_STATUS_TO_IMPRECISE_FIELD_NUMBER

      public static final int CHANGE_STATUS_TO_IMPRECISE_FIELD_NUMBER
      See Also:

    • MAX_NUMBER_OF_REOPTIMIZATIONS_FIELD_NUMBER

      public static final int MAX_NUMBER_OF_REOPTIMIZATIONS_FIELD_NUMBER
      See Also:

    • LU_FACTORIZATION_PIVOT_THRESHOLD_FIELD_NUMBER

      public static final int LU_FACTORIZATION_PIVOT_THRESHOLD_FIELD_NUMBER
      See Also:

    • MAX_TIME_IN_SECONDS_FIELD_NUMBER

      public static final int MAX_TIME_IN_SECONDS_FIELD_NUMBER
      See Also:

    • MAX_DETERMINISTIC_TIME_FIELD_NUMBER

      public static final int MAX_DETERMINISTIC_TIME_FIELD_NUMBER
      See Also:

    • MAX_NUMBER_OF_ITERATIONS_FIELD_NUMBER

      public static final int MAX_NUMBER_OF_ITERATIONS_FIELD_NUMBER
      See Also:

    • MARKOWITZ_ZLATEV_PARAMETER_FIELD_NUMBER

      public static final int MARKOWITZ_ZLATEV_PARAMETER_FIELD_NUMBER
      See Also:

    • MARKOWITZ_SINGULARITY_THRESHOLD_FIELD_NUMBER

      public static final int MARKOWITZ_SINGULARITY_THRESHOLD_FIELD_NUMBER
      See Also:

    • USE_DUAL_SIMPLEX_FIELD_NUMBER

      public static final int USE_DUAL_SIMPLEX_FIELD_NUMBER
      See Also:

    • ALLOW_SIMPLEX_ALGORITHM_CHANGE_FIELD_NUMBER

      public static final int ALLOW_SIMPLEX_ALGORITHM_CHANGE_FIELD_NUMBER
      See Also:

    • DEVEX_WEIGHTS_RESET_PERIOD_FIELD_NUMBER

      public static final int DEVEX_WEIGHTS_RESET_PERIOD_FIELD_NUMBER
      See Also:

    • USE_PREPROCESSING_FIELD_NUMBER

      public static final int USE_PREPROCESSING_FIELD_NUMBER
      See Also:

    • USE_MIDDLE_PRODUCT_FORM_UPDATE_FIELD_NUMBER

      public static final int USE_MIDDLE_PRODUCT_FORM_UPDATE_FIELD_NUMBER
      See Also:

    • INITIALIZE_DEVEX_WITH_COLUMN_NORMS_FIELD_NUMBER

      public static final int INITIALIZE_DEVEX_WITH_COLUMN_NORMS_FIELD_NUMBER
      See Also:

    • EXPLOIT_SINGLETON_COLUMN_IN_INITIAL_BASIS_FIELD_NUMBER

      public static final int EXPLOIT_SINGLETON_COLUMN_IN_INITIAL_BASIS_FIELD_NUMBER
      See Also:

    • DUAL_SMALL_PIVOT_THRESHOLD_FIELD_NUMBER

      public static final int DUAL_SMALL_PIVOT_THRESHOLD_FIELD_NUMBER
      See Also:

    • PREPROCESSOR_ZERO_TOLERANCE_FIELD_NUMBER

      public static final int PREPROCESSOR_ZERO_TOLERANCE_FIELD_NUMBER
      See Also:

    • OBJECTIVE_LOWER_LIMIT_FIELD_NUMBER

      public static final int OBJECTIVE_LOWER_LIMIT_FIELD_NUMBER
      See Also:

    • OBJECTIVE_UPPER_LIMIT_FIELD_NUMBER

      public static final int OBJECTIVE_UPPER_LIMIT_FIELD_NUMBER
      See Also:

    • DEGENERATE_MINISTEP_FACTOR_FIELD_NUMBER

      public static final int DEGENERATE_MINISTEP_FACTOR_FIELD_NUMBER
      See Also:

    • RANDOM_SEED_FIELD_NUMBER

      public static final int RANDOM_SEED_FIELD_NUMBER
      See Also:

    • USE_ABSL_RANDOM_FIELD_NUMBER

      public static final int USE_ABSL_RANDOM_FIELD_NUMBER
      See Also:

    • NUM_OMP_THREADS_FIELD_NUMBER

      public static final int NUM_OMP_THREADS_FIELD_NUMBER
      See Also:

    • PERTURB_COSTS_IN_DUAL_SIMPLEX_FIELD_NUMBER

      public static final int PERTURB_COSTS_IN_DUAL_SIMPLEX_FIELD_NUMBER
      See Also:

    • USE_DEDICATED_DUAL_FEASIBILITY_ALGORITHM_FIELD_NUMBER

      public static final int USE_DEDICATED_DUAL_FEASIBILITY_ALGORITHM_FIELD_NUMBER
      See Also:

    • RELATIVE_COST_PERTURBATION_FIELD_NUMBER

      public static final int RELATIVE_COST_PERTURBATION_FIELD_NUMBER
      See Also:

    • RELATIVE_MAX_COST_PERTURBATION_FIELD_NUMBER

      public static final int RELATIVE_MAX_COST_PERTURBATION_FIELD_NUMBER
      See Also:

    • INITIAL_CONDITION_NUMBER_THRESHOLD_FIELD_NUMBER

      public static final int INITIAL_CONDITION_NUMBER_THRESHOLD_FIELD_NUMBER
      See Also:

    • LOG_SEARCH_PROGRESS_FIELD_NUMBER

      public static final int LOG_SEARCH_PROGRESS_FIELD_NUMBER
      See Also:

    • LOG_TO_STDOUT_FIELD_NUMBER

      public static final int LOG_TO_STDOUT_FIELD_NUMBER
      See Also:

    • CROSSOVER_BOUND_SNAPPING_DISTANCE_FIELD_NUMBER

      public static final int CROSSOVER_BOUND_SNAPPING_DISTANCE_FIELD_NUMBER
      See Also:

    • PUSH_TO_VERTEX_FIELD_NUMBER

      public static final int PUSH_TO_VERTEX_FIELD_NUMBER
      See Also:

    • USE_IMPLIED_FREE_PREPROCESSOR_FIELD_NUMBER

      public static final int USE_IMPLIED_FREE_PREPROCESSOR_FIELD_NUMBER
      See Also:

    • MAX_VALID_MAGNITUDE_FIELD_NUMBER

      public static final int MAX_VALID_MAGNITUDE_FIELD_NUMBER
      See Also:

    • DROP_MAGNITUDE_FIELD_NUMBER

      public static final int DROP_MAGNITUDE_FIELD_NUMBER
      See Also:

    • DUAL_PRICE_PRIORITIZE_NORM_FIELD_NUMBER

      public static final int DUAL_PRICE_PRIORITIZE_NORM_FIELD_NUMBER
      See Also:

  • Method Details

    • getDescriptor

      public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

    • internalGetFieldAccessorTable

      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
      Specified by:
      internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage

    • hasScalingMethod

      public boolean hasScalingMethod()
      optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
      Specified by:
      hasScalingMethod in interface GlopParametersOrBuilder
      Returns:
      Whether the scalingMethod field is set.

    • getScalingMethod

      public GlopParameters.ScalingAlgorithm getScalingMethod()
      optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
      Specified by:
      getScalingMethod in interface GlopParametersOrBuilder
      Returns:
      The scalingMethod.

    • hasFeasibilityRule

      public boolean hasFeasibilityRule()
       PricingRule to use during the feasibility phase.
      optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
      Specified by:
      hasFeasibilityRule in interface GlopParametersOrBuilder
      Returns:
      Whether the feasibilityRule field is set.

    • getFeasibilityRule

      public GlopParameters.PricingRule getFeasibilityRule()
       PricingRule to use during the feasibility phase.
      optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
      Specified by:
      getFeasibilityRule in interface GlopParametersOrBuilder
      Returns:
      The feasibilityRule.

    • hasOptimizationRule

      public boolean hasOptimizationRule()
       PricingRule to use during the optimization phase.
      optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
      Specified by:
      hasOptimizationRule in interface GlopParametersOrBuilder
      Returns:
      Whether the optimizationRule field is set.

    • getOptimizationRule

      public GlopParameters.PricingRule getOptimizationRule()
       PricingRule to use during the optimization phase.
      optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
      Specified by:
      getOptimizationRule in interface GlopParametersOrBuilder
      Returns:
      The optimizationRule.

    • hasRefactorizationThreshold

      public boolean hasRefactorizationThreshold()
       We estimate the factorization accuracy of B during each pivot by using
 the fact that we can compute the pivot coefficient in two ways:
 - From direction[leaving_row].
 - From update_row[entering_column].
 If the two values have a relative difference above this threshold, we
 trigger a refactorization.
      optional double refactorization_threshold = 6 [default = 1e-09];
      Specified by:
      hasRefactorizationThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the refactorizationThreshold field is set.

    • getRefactorizationThreshold

      public double getRefactorizationThreshold()
       We estimate the factorization accuracy of B during each pivot by using
 the fact that we can compute the pivot coefficient in two ways:
 - From direction[leaving_row].
 - From update_row[entering_column].
 If the two values have a relative difference above this threshold, we
 trigger a refactorization.
      optional double refactorization_threshold = 6 [default = 1e-09];
      Specified by:
      getRefactorizationThreshold in interface GlopParametersOrBuilder
      Returns:
      The refactorizationThreshold.

    • hasRecomputeReducedCostsThreshold

      public boolean hasRecomputeReducedCostsThreshold()
       We estimate the accuracy of the iteratively computed reduced costs. If
 it falls below this threshold, we reinitialize them from scratch. Note
 that such an operation is pretty fast, so we can use a low threshold.
 It is important to have a good accuracy here (better than the
 dual_feasibility_tolerance below) to be sure of the sign of such a cost.
      optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
      Specified by:
      hasRecomputeReducedCostsThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the recomputeReducedCostsThreshold field is set.

    • getRecomputeReducedCostsThreshold

      public double getRecomputeReducedCostsThreshold()
       We estimate the accuracy of the iteratively computed reduced costs. If
 it falls below this threshold, we reinitialize them from scratch. Note
 that such an operation is pretty fast, so we can use a low threshold.
 It is important to have a good accuracy here (better than the
 dual_feasibility_tolerance below) to be sure of the sign of such a cost.
      optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
      Specified by:
      getRecomputeReducedCostsThreshold in interface GlopParametersOrBuilder
      Returns:
      The recomputeReducedCostsThreshold.

    • hasRecomputeEdgesNormThreshold

      public boolean hasRecomputeEdgesNormThreshold()
       Note that the threshold is a relative error on the actual norm (not the
 squared one) and that edge norms are always greater than 1. Recomputing
 norms is a really expensive operation and a large threshold is ok since
 this doesn't impact directly the solution but just the entering variable
 choice.
      optional double recompute_edges_norm_threshold = 9 [default = 100];
      Specified by:
      hasRecomputeEdgesNormThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the recomputeEdgesNormThreshold field is set.

    • getRecomputeEdgesNormThreshold

      public double getRecomputeEdgesNormThreshold()
       Note that the threshold is a relative error on the actual norm (not the
 squared one) and that edge norms are always greater than 1. Recomputing
 norms is a really expensive operation and a large threshold is ok since
 this doesn't impact directly the solution but just the entering variable
 choice.
      optional double recompute_edges_norm_threshold = 9 [default = 100];
      Specified by:
      getRecomputeEdgesNormThreshold in interface GlopParametersOrBuilder
      Returns:
      The recomputeEdgesNormThreshold.

    • hasPrimalFeasibilityTolerance

      public boolean hasPrimalFeasibilityTolerance()
       This tolerance indicates by how much we allow the variable values to go out
 of bounds and still consider the current solution primal-feasible. We also
 use the same tolerance for the error A.x - b. Note that the two errors are
 closely related if A is scaled in such a way that the greatest coefficient
 magnitude on each column is 1.0.

 This is also simply called feasibility tolerance in other solvers.
      optional double primal_feasibility_tolerance = 10 [default = 1e-08];
      Specified by:
      hasPrimalFeasibilityTolerance in interface GlopParametersOrBuilder
      Returns:
      Whether the primalFeasibilityTolerance field is set.

    • getPrimalFeasibilityTolerance

      public double getPrimalFeasibilityTolerance()
       This tolerance indicates by how much we allow the variable values to go out
 of bounds and still consider the current solution primal-feasible. We also
 use the same tolerance for the error A.x - b. Note that the two errors are
 closely related if A is scaled in such a way that the greatest coefficient
 magnitude on each column is 1.0.

 This is also simply called feasibility tolerance in other solvers.
      optional double primal_feasibility_tolerance = 10 [default = 1e-08];
      Specified by:
      getPrimalFeasibilityTolerance in interface GlopParametersOrBuilder
      Returns:
      The primalFeasibilityTolerance.

    • hasDualFeasibilityTolerance

      public boolean hasDualFeasibilityTolerance()
       Variables whose reduced costs have an absolute value smaller than this
 tolerance are not considered as entering candidates. That is they do not
 take part in deciding whether a solution is dual-feasible or not.

 Note that this value can temporarily increase during the execution of the
 algorithm if the estimated precision of the reduced costs is higher than
 this tolerance. Note also that we scale the costs (in the presolve step) so
 that the cost magnitude range contains one.

 This is also known as the optimality tolerance in other solvers.
      optional double dual_feasibility_tolerance = 11 [default = 1e-08];
      Specified by:
      hasDualFeasibilityTolerance in interface GlopParametersOrBuilder
      Returns:
      Whether the dualFeasibilityTolerance field is set.

    • getDualFeasibilityTolerance

      public double getDualFeasibilityTolerance()
       Variables whose reduced costs have an absolute value smaller than this
 tolerance are not considered as entering candidates. That is they do not
 take part in deciding whether a solution is dual-feasible or not.

 Note that this value can temporarily increase during the execution of the
 algorithm if the estimated precision of the reduced costs is higher than
 this tolerance. Note also that we scale the costs (in the presolve step) so
 that the cost magnitude range contains one.

 This is also known as the optimality tolerance in other solvers.
      optional double dual_feasibility_tolerance = 11 [default = 1e-08];
      Specified by:
      getDualFeasibilityTolerance in interface GlopParametersOrBuilder
      Returns:
      The dualFeasibilityTolerance.

    • hasRatioTestZeroThreshold

      public boolean hasRatioTestZeroThreshold()
       During the primal simplex (resp. dual simplex), the coefficients of the
 direction (resp. update row) with a magnitude lower than this threshold are
 not considered during the ratio test. This tolerance is related to the
 precision at which a Solve() involving the basis matrix can be performed.

 TODO(user): Automatically increase it when we detect that the precision
 of the Solve() is worse than this.
      optional double ratio_test_zero_threshold = 12 [default = 1e-09];
      Specified by:
      hasRatioTestZeroThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the ratioTestZeroThreshold field is set.

    • getRatioTestZeroThreshold

      public double getRatioTestZeroThreshold()
       During the primal simplex (resp. dual simplex), the coefficients of the
 direction (resp. update row) with a magnitude lower than this threshold are
 not considered during the ratio test. This tolerance is related to the
 precision at which a Solve() involving the basis matrix can be performed.

 TODO(user): Automatically increase it when we detect that the precision
 of the Solve() is worse than this.
      optional double ratio_test_zero_threshold = 12 [default = 1e-09];
      Specified by:
      getRatioTestZeroThreshold in interface GlopParametersOrBuilder
      Returns:
      The ratioTestZeroThreshold.

    • hasHarrisToleranceRatio

      public boolean hasHarrisToleranceRatio()
       This impacts the ratio test and indicates by how much we allow a basic
 variable value that we move to go out of bounds. The value should be in
 [0.0, 1.0) and should be interpreted as a ratio of the
 primal_feasibility_tolerance. Setting this to 0.0 basically disables the
 Harris ratio test while setting this too close to 1.0 will make it
 difficult to keep the variable values inside their bounds modulo the
 primal_feasibility_tolerance.

 Note that the same comment applies to the dual simplex ratio test. There,
 we allow the reduced costs to be of an infeasible sign by as much as this
 ratio times the dual_feasibility_tolerance.
      optional double harris_tolerance_ratio = 13 [default = 0.5];
      Specified by:
      hasHarrisToleranceRatio in interface GlopParametersOrBuilder
      Returns:
      Whether the harrisToleranceRatio field is set.

    • getHarrisToleranceRatio

      public double getHarrisToleranceRatio()
       This impacts the ratio test and indicates by how much we allow a basic
 variable value that we move to go out of bounds. The value should be in
 [0.0, 1.0) and should be interpreted as a ratio of the
 primal_feasibility_tolerance. Setting this to 0.0 basically disables the
 Harris ratio test while setting this too close to 1.0 will make it
 difficult to keep the variable values inside their bounds modulo the
 primal_feasibility_tolerance.

 Note that the same comment applies to the dual simplex ratio test. There,
 we allow the reduced costs to be of an infeasible sign by as much as this
 ratio times the dual_feasibility_tolerance.
      optional double harris_tolerance_ratio = 13 [default = 0.5];
      Specified by:
      getHarrisToleranceRatio in interface GlopParametersOrBuilder
      Returns:
      The harrisToleranceRatio.

    • hasSmallPivotThreshold

      public boolean hasSmallPivotThreshold()
       When we choose the leaving variable, we want to avoid small pivot because
 they are the less precise and may cause numerical instabilities. For a
 pivot under this threshold times the infinity norm of the direction, we try
 various countermeasures in order to avoid using it.
      optional double small_pivot_threshold = 14 [default = 1e-06];
      Specified by:
      hasSmallPivotThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the smallPivotThreshold field is set.

    • getSmallPivotThreshold

      public double getSmallPivotThreshold()
       When we choose the leaving variable, we want to avoid small pivot because
 they are the less precise and may cause numerical instabilities. For a
 pivot under this threshold times the infinity norm of the direction, we try
 various countermeasures in order to avoid using it.
      optional double small_pivot_threshold = 14 [default = 1e-06];
      Specified by:
      getSmallPivotThreshold in interface GlopParametersOrBuilder
      Returns:
      The smallPivotThreshold.

    • hasMinimumAcceptablePivot

      public boolean hasMinimumAcceptablePivot()
       We never follow a basis change with a pivot under this threshold.
      optional double minimum_acceptable_pivot = 15 [default = 1e-06];
      Specified by:
      hasMinimumAcceptablePivot in interface GlopParametersOrBuilder
      Returns:
      Whether the minimumAcceptablePivot field is set.

    • getMinimumAcceptablePivot

      public double getMinimumAcceptablePivot()
       We never follow a basis change with a pivot under this threshold.
      optional double minimum_acceptable_pivot = 15 [default = 1e-06];
      Specified by:
      getMinimumAcceptablePivot in interface GlopParametersOrBuilder
      Returns:
      The minimumAcceptablePivot.

    • hasDropTolerance

      public boolean hasDropTolerance()
       In order to increase the sparsity of the manipulated vectors, floating
 point values with a magnitude smaller than this parameter are set to zero
 (only in some places). This parameter should be positive or zero.
      optional double drop_tolerance = 52 [default = 1e-14];
      Specified by:
      hasDropTolerance in interface GlopParametersOrBuilder
      Returns:
      Whether the dropTolerance field is set.

    • getDropTolerance

      public double getDropTolerance()
       In order to increase the sparsity of the manipulated vectors, floating
 point values with a magnitude smaller than this parameter are set to zero
 (only in some places). This parameter should be positive or zero.
      optional double drop_tolerance = 52 [default = 1e-14];
      Specified by:
      getDropTolerance in interface GlopParametersOrBuilder
      Returns:
      The dropTolerance.

    • hasUseScaling

      public boolean hasUseScaling()
       Whether or not we scale the matrix A so that the maximum coefficient on
 each line and each column is 1.0.
      optional bool use_scaling = 16 [default = true];
      Specified by:
      hasUseScaling in interface GlopParametersOrBuilder
      Returns:
      Whether the useScaling field is set.

    • getUseScaling

      public boolean getUseScaling()
       Whether or not we scale the matrix A so that the maximum coefficient on
 each line and each column is 1.0.
      optional bool use_scaling = 16 [default = true];
      Specified by:
      getUseScaling in interface GlopParametersOrBuilder
      Returns:
      The useScaling.

    • hasCostScaling

      public boolean hasCostScaling()
      optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
      Specified by:
      hasCostScaling in interface GlopParametersOrBuilder
      Returns:
      Whether the costScaling field is set.

    • getCostScaling

      public GlopParameters.CostScalingAlgorithm getCostScaling()
      optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
      Specified by:
      getCostScaling in interface GlopParametersOrBuilder
      Returns:
      The costScaling.

    • hasInitialBasis

      public boolean hasInitialBasis()
       What heuristic is used to try to replace the fixed slack columns in the
 initial basis of the primal simplex.
      optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
      Specified by:
      hasInitialBasis in interface GlopParametersOrBuilder
      Returns:
      Whether the initialBasis field is set.

    • getInitialBasis

      public GlopParameters.InitialBasisHeuristic getInitialBasis()
       What heuristic is used to try to replace the fixed slack columns in the
 initial basis of the primal simplex.
      optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
      Specified by:
      getInitialBasis in interface GlopParametersOrBuilder
      Returns:
      The initialBasis.

    • hasUseTransposedMatrix

      public boolean hasUseTransposedMatrix()
       Whether or not we keep a transposed version of the matrix A to speed-up the
 pricing at the cost of extra memory and the initial tranposition
 computation.
      optional bool use_transposed_matrix = 18 [default = true];
      Specified by:
      hasUseTransposedMatrix in interface GlopParametersOrBuilder
      Returns:
      Whether the useTransposedMatrix field is set.

    • getUseTransposedMatrix

      public boolean getUseTransposedMatrix()
       Whether or not we keep a transposed version of the matrix A to speed-up the
 pricing at the cost of extra memory and the initial tranposition
 computation.
      optional bool use_transposed_matrix = 18 [default = true];
      Specified by:
      getUseTransposedMatrix in interface GlopParametersOrBuilder
      Returns:
      The useTransposedMatrix.

    • hasBasisRefactorizationPeriod

      public boolean hasBasisRefactorizationPeriod()
       Number of iterations between two basis refactorizations. Note that various
 conditions in the algorithm may trigger a refactorization before this
 period is reached. Set this to 0 if you want to refactorize at each step.
      optional int32 basis_refactorization_period = 19 [default = 64];
      Specified by:
      hasBasisRefactorizationPeriod in interface GlopParametersOrBuilder
      Returns:
      Whether the basisRefactorizationPeriod field is set.

    • getBasisRefactorizationPeriod

      public int getBasisRefactorizationPeriod()
       Number of iterations between two basis refactorizations. Note that various
 conditions in the algorithm may trigger a refactorization before this
 period is reached. Set this to 0 if you want to refactorize at each step.
      optional int32 basis_refactorization_period = 19 [default = 64];
      Specified by:
      getBasisRefactorizationPeriod in interface GlopParametersOrBuilder
      Returns:
      The basisRefactorizationPeriod.

    • hasDynamicallyAdjustRefactorizationPeriod

      public boolean hasDynamicallyAdjustRefactorizationPeriod()
       If this is true, then basis_refactorization_period becomes a lower bound on
 the number of iterations between two refactorization (provided there is no
 numerical accuracy issues). Depending on the estimated time to refactorize
 vs the extra time spend in each solves because of the LU update, we try to
 balance the two times.
      optional bool dynamically_adjust_refactorization_period = 63 [default = true];
      Specified by:
      hasDynamicallyAdjustRefactorizationPeriod in interface GlopParametersOrBuilder
      Returns:
      Whether the dynamicallyAdjustRefactorizationPeriod field is set.

    • getDynamicallyAdjustRefactorizationPeriod

      public boolean getDynamicallyAdjustRefactorizationPeriod()
       If this is true, then basis_refactorization_period becomes a lower bound on
 the number of iterations between two refactorization (provided there is no
 numerical accuracy issues). Depending on the estimated time to refactorize
 vs the extra time spend in each solves because of the LU update, we try to
 balance the two times.
      optional bool dynamically_adjust_refactorization_period = 63 [default = true];
      Specified by:
      getDynamicallyAdjustRefactorizationPeriod in interface GlopParametersOrBuilder
      Returns:
      The dynamicallyAdjustRefactorizationPeriod.

    • hasSolveDualProblem

      public boolean hasSolveDualProblem()
       Whether or not we solve the dual of the given problem.
 With a value of auto, the algorithm decide which approach is probably the
 fastest depending on the problem dimensions (see dualizer_threshold).
      optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
      Specified by:
      hasSolveDualProblem in interface GlopParametersOrBuilder
      Returns:
      Whether the solveDualProblem field is set.

    • getSolveDualProblem

      public GlopParameters.SolverBehavior getSolveDualProblem()
       Whether or not we solve the dual of the given problem.
 With a value of auto, the algorithm decide which approach is probably the
 fastest depending on the problem dimensions (see dualizer_threshold).
      optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
      Specified by:
      getSolveDualProblem in interface GlopParametersOrBuilder
      Returns:
      The solveDualProblem.

    • hasDualizerThreshold

      public boolean hasDualizerThreshold()
       When solve_dual_problem is LET_SOLVER_DECIDE, take the dual if the number
 of constraints of the problem is more than this threshold times the number
 of variables.
      optional double dualizer_threshold = 21 [default = 1.5];
      Specified by:
      hasDualizerThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the dualizerThreshold field is set.

    • getDualizerThreshold

      public double getDualizerThreshold()
       When solve_dual_problem is LET_SOLVER_DECIDE, take the dual if the number
 of constraints of the problem is more than this threshold times the number
 of variables.
      optional double dualizer_threshold = 21 [default = 1.5];
      Specified by:
      getDualizerThreshold in interface GlopParametersOrBuilder
      Returns:
      The dualizerThreshold.

    • hasSolutionFeasibilityTolerance

      public boolean hasSolutionFeasibilityTolerance()
       When the problem status is OPTIMAL, we check the optimality using this
 relative tolerance and change the status to IMPRECISE if an issue is
 detected.

 The tolerance is "relative" in the sense that our thresholds are:
 - tolerance * max(1.0, abs(bound)) for crossing a given bound.
 - tolerance * max(1.0, abs(cost)) for an infeasible reduced cost.
 - tolerance for an infeasible dual value.
      optional double solution_feasibility_tolerance = 22 [default = 1e-06];
      Specified by:
      hasSolutionFeasibilityTolerance in interface GlopParametersOrBuilder
      Returns:
      Whether the solutionFeasibilityTolerance field is set.

    • getSolutionFeasibilityTolerance

      public double getSolutionFeasibilityTolerance()
       When the problem status is OPTIMAL, we check the optimality using this
 relative tolerance and change the status to IMPRECISE if an issue is
 detected.

 The tolerance is "relative" in the sense that our thresholds are:
 - tolerance * max(1.0, abs(bound)) for crossing a given bound.
 - tolerance * max(1.0, abs(cost)) for an infeasible reduced cost.
 - tolerance for an infeasible dual value.
      optional double solution_feasibility_tolerance = 22 [default = 1e-06];
      Specified by:
      getSolutionFeasibilityTolerance in interface GlopParametersOrBuilder
      Returns:
      The solutionFeasibilityTolerance.

    • hasProvideStrongOptimalGuarantee

      public boolean hasProvideStrongOptimalGuarantee()
       If true, then when the solver returns a solution with an OPTIMAL status,
 we can guarantee that:
 - The primal variable are in their bounds.
 - The dual variable are in their bounds.
 - If we modify each component of the right-hand side a bit and each
 component of the objective function a bit, then the pair (primal values,
 dual values) is an EXACT optimal solution of the perturbed problem.
 - The modifications above are smaller than the associated tolerances as
 defined in the comment for solution_feasibility_tolerance (*).

 (*): This is the only place where the guarantee is not tight since we
 compute the upper bounds with scalar product of the primal/dual
 solution and the initial problem coefficients with only double precision.

 Note that whether or not this option is true, we still check the
 primal/dual infeasibility and objective gap. However if it is false, we
 don't move the primal/dual values within their bounds and leave them
 untouched.
      optional bool provide_strong_optimal_guarantee = 24 [default = true];
      Specified by:
      hasProvideStrongOptimalGuarantee in interface GlopParametersOrBuilder
      Returns:
      Whether the provideStrongOptimalGuarantee field is set.

    • getProvideStrongOptimalGuarantee

      public boolean getProvideStrongOptimalGuarantee()
       If true, then when the solver returns a solution with an OPTIMAL status,
 we can guarantee that:
 - The primal variable are in their bounds.
 - The dual variable are in their bounds.
 - If we modify each component of the right-hand side a bit and each
 component of the objective function a bit, then the pair (primal values,
 dual values) is an EXACT optimal solution of the perturbed problem.
 - The modifications above are smaller than the associated tolerances as
 defined in the comment for solution_feasibility_tolerance (*).

 (*): This is the only place where the guarantee is not tight since we
 compute the upper bounds with scalar product of the primal/dual
 solution and the initial problem coefficients with only double precision.

 Note that whether or not this option is true, we still check the
 primal/dual infeasibility and objective gap. However if it is false, we
 don't move the primal/dual values within their bounds and leave them
 untouched.
      optional bool provide_strong_optimal_guarantee = 24 [default = true];
      Specified by:
      getProvideStrongOptimalGuarantee in interface GlopParametersOrBuilder
      Returns:
      The provideStrongOptimalGuarantee.

    • hasChangeStatusToImprecise

      public boolean hasChangeStatusToImprecise()
       If true, the internal API will change the return status to imprecise if the
 solution does not respect the internal tolerances.
      optional bool change_status_to_imprecise = 58 [default = true];
      Specified by:
      hasChangeStatusToImprecise in interface GlopParametersOrBuilder
      Returns:
      Whether the changeStatusToImprecise field is set.

    • getChangeStatusToImprecise

      public boolean getChangeStatusToImprecise()
       If true, the internal API will change the return status to imprecise if the
 solution does not respect the internal tolerances.
      optional bool change_status_to_imprecise = 58 [default = true];
      Specified by:
      getChangeStatusToImprecise in interface GlopParametersOrBuilder
      Returns:
      The changeStatusToImprecise.

    • hasMaxNumberOfReoptimizations

      public boolean hasMaxNumberOfReoptimizations()
       When the solution of phase II is imprecise, we re-run the phase II with the
 opposite algorithm from that imprecise solution (i.e., if primal or dual
 simplex was used, we use dual or primal simplex, respectively). We repeat
 such re-optimization until the solution is precise, or we hit this limit.
      optional double max_number_of_reoptimizations = 56 [default = 40];
      Specified by:
      hasMaxNumberOfReoptimizations in interface GlopParametersOrBuilder
      Returns:
      Whether the maxNumberOfReoptimizations field is set.

    • getMaxNumberOfReoptimizations

      public double getMaxNumberOfReoptimizations()
       When the solution of phase II is imprecise, we re-run the phase II with the
 opposite algorithm from that imprecise solution (i.e., if primal or dual
 simplex was used, we use dual or primal simplex, respectively). We repeat
 such re-optimization until the solution is precise, or we hit this limit.
      optional double max_number_of_reoptimizations = 56 [default = 40];
      Specified by:
      getMaxNumberOfReoptimizations in interface GlopParametersOrBuilder
      Returns:
      The maxNumberOfReoptimizations.

    • hasLuFactorizationPivotThreshold

      public boolean hasLuFactorizationPivotThreshold()
       Threshold for LU-factorization: for stability reasons, the magnitude of the
 chosen pivot at a given step is guaranteed to be greater than this
 threshold times the maximum magnitude of all the possible pivot choices in
 the same column. The value must be in [0,1].
      optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
      Specified by:
      hasLuFactorizationPivotThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the luFactorizationPivotThreshold field is set.

    • getLuFactorizationPivotThreshold

      public double getLuFactorizationPivotThreshold()
       Threshold for LU-factorization: for stability reasons, the magnitude of the
 chosen pivot at a given step is guaranteed to be greater than this
 threshold times the maximum magnitude of all the possible pivot choices in
 the same column. The value must be in [0,1].
      optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
      Specified by:
      getLuFactorizationPivotThreshold in interface GlopParametersOrBuilder
      Returns:
      The luFactorizationPivotThreshold.

    • hasMaxTimeInSeconds

      public boolean hasMaxTimeInSeconds()
       Maximum time allowed in seconds to solve a problem.
      optional double max_time_in_seconds = 26 [default = inf];
      Specified by:
      hasMaxTimeInSeconds in interface GlopParametersOrBuilder
      Returns:
      Whether the maxTimeInSeconds field is set.

    • getMaxTimeInSeconds

      public double getMaxTimeInSeconds()
       Maximum time allowed in seconds to solve a problem.
      optional double max_time_in_seconds = 26 [default = inf];
      Specified by:
      getMaxTimeInSeconds in interface GlopParametersOrBuilder
      Returns:
      The maxTimeInSeconds.

    • hasMaxDeterministicTime

      public boolean hasMaxDeterministicTime()
       Maximum deterministic time allowed to solve a problem. The deterministic
 time is more or less correlated to the running time, and its unit should
 be around the second (at least on a Xeon(R) CPU E5-1650 v2 @ 3.50GHz).

 TODO(user): Improve the correlation.
      optional double max_deterministic_time = 45 [default = inf];
      Specified by:
      hasMaxDeterministicTime in interface GlopParametersOrBuilder
      Returns:
      Whether the maxDeterministicTime field is set.

    • getMaxDeterministicTime

      public double getMaxDeterministicTime()
       Maximum deterministic time allowed to solve a problem. The deterministic
 time is more or less correlated to the running time, and its unit should
 be around the second (at least on a Xeon(R) CPU E5-1650 v2 @ 3.50GHz).

 TODO(user): Improve the correlation.
      optional double max_deterministic_time = 45 [default = inf];
      Specified by:
      getMaxDeterministicTime in interface GlopParametersOrBuilder
      Returns:
      The maxDeterministicTime.

    • hasMaxNumberOfIterations

      public boolean hasMaxNumberOfIterations()
       Maximum number of simplex iterations to solve a problem.
 A value of -1 means no limit.
      optional int64 max_number_of_iterations = 27 [default = -1];
      Specified by:
      hasMaxNumberOfIterations in interface GlopParametersOrBuilder
      Returns:
      Whether the maxNumberOfIterations field is set.

    • getMaxNumberOfIterations

      public long getMaxNumberOfIterations()
       Maximum number of simplex iterations to solve a problem.
 A value of -1 means no limit.
      optional int64 max_number_of_iterations = 27 [default = -1];
      Specified by:
      getMaxNumberOfIterations in interface GlopParametersOrBuilder
      Returns:
      The maxNumberOfIterations.

    • hasMarkowitzZlatevParameter

      public boolean hasMarkowitzZlatevParameter()
       How many columns do we look at in the Markowitz pivoting rule to find
 a good pivot. See markowitz.h.
      optional int32 markowitz_zlatev_parameter = 29 [default = 3];
      Specified by:
      hasMarkowitzZlatevParameter in interface GlopParametersOrBuilder
      Returns:
      Whether the markowitzZlatevParameter field is set.

    • getMarkowitzZlatevParameter

      public int getMarkowitzZlatevParameter()
       How many columns do we look at in the Markowitz pivoting rule to find
 a good pivot. See markowitz.h.
      optional int32 markowitz_zlatev_parameter = 29 [default = 3];
      Specified by:
      getMarkowitzZlatevParameter in interface GlopParametersOrBuilder
      Returns:
      The markowitzZlatevParameter.

    • hasMarkowitzSingularityThreshold

      public boolean hasMarkowitzSingularityThreshold()
       If a pivot magnitude is smaller than this during the Markowitz LU
 factorization, then the matrix is assumed to be singular. Note that
 this is an absolute threshold and is not relative to the other possible
 pivots on the same column (see lu_factorization_pivot_threshold).
      optional double markowitz_singularity_threshold = 30 [default = 1e-15];
      Specified by:
      hasMarkowitzSingularityThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the markowitzSingularityThreshold field is set.

    • getMarkowitzSingularityThreshold

      public double getMarkowitzSingularityThreshold()
       If a pivot magnitude is smaller than this during the Markowitz LU
 factorization, then the matrix is assumed to be singular. Note that
 this is an absolute threshold and is not relative to the other possible
 pivots on the same column (see lu_factorization_pivot_threshold).
      optional double markowitz_singularity_threshold = 30 [default = 1e-15];
      Specified by:
      getMarkowitzSingularityThreshold in interface GlopParametersOrBuilder
      Returns:
      The markowitzSingularityThreshold.

    • hasUseDualSimplex

      public boolean hasUseDualSimplex()
       Whether or not we use the dual simplex algorithm instead of the primal.
      optional bool use_dual_simplex = 31 [default = false];
      Specified by:
      hasUseDualSimplex in interface GlopParametersOrBuilder
      Returns:
      Whether the useDualSimplex field is set.

    • getUseDualSimplex

      public boolean getUseDualSimplex()
       Whether or not we use the dual simplex algorithm instead of the primal.
      optional bool use_dual_simplex = 31 [default = false];
      Specified by:
      getUseDualSimplex in interface GlopParametersOrBuilder
      Returns:
      The useDualSimplex.

    • hasAllowSimplexAlgorithmChange

      public boolean hasAllowSimplexAlgorithmChange()
       During incremental solve, let the solver decide if it use the primal or
 dual simplex algorithm depending on the current solution and on the new
 problem. Note that even if this is true, the value of use_dual_simplex
 still indicates the default algorithm that the solver will use.
      optional bool allow_simplex_algorithm_change = 32 [default = false];
      Specified by:
      hasAllowSimplexAlgorithmChange in interface GlopParametersOrBuilder
      Returns:
      Whether the allowSimplexAlgorithmChange field is set.

    • getAllowSimplexAlgorithmChange

      public boolean getAllowSimplexAlgorithmChange()
       During incremental solve, let the solver decide if it use the primal or
 dual simplex algorithm depending on the current solution and on the new
 problem. Note that even if this is true, the value of use_dual_simplex
 still indicates the default algorithm that the solver will use.
      optional bool allow_simplex_algorithm_change = 32 [default = false];
      Specified by:
      getAllowSimplexAlgorithmChange in interface GlopParametersOrBuilder
      Returns:
      The allowSimplexAlgorithmChange.

    • hasDevexWeightsResetPeriod

      public boolean hasDevexWeightsResetPeriod()
       Devex weights will be reset to 1.0 after that number of updates.
      optional int32 devex_weights_reset_period = 33 [default = 150];
      Specified by:
      hasDevexWeightsResetPeriod in interface GlopParametersOrBuilder
      Returns:
      Whether the devexWeightsResetPeriod field is set.

    • getDevexWeightsResetPeriod

      public int getDevexWeightsResetPeriod()
       Devex weights will be reset to 1.0 after that number of updates.
      optional int32 devex_weights_reset_period = 33 [default = 150];
      Specified by:
      getDevexWeightsResetPeriod in interface GlopParametersOrBuilder
      Returns:
      The devexWeightsResetPeriod.

    • hasUsePreprocessing

      public boolean hasUsePreprocessing()
       Whether or not we use advanced preprocessing techniques.
      optional bool use_preprocessing = 34 [default = true];
      Specified by:
      hasUsePreprocessing in interface GlopParametersOrBuilder
      Returns:
      Whether the usePreprocessing field is set.

    • getUsePreprocessing

      public boolean getUsePreprocessing()
       Whether or not we use advanced preprocessing techniques.
      optional bool use_preprocessing = 34 [default = true];
      Specified by:
      getUsePreprocessing in interface GlopParametersOrBuilder
      Returns:
      The usePreprocessing.

    • hasUseMiddleProductFormUpdate

      public boolean hasUseMiddleProductFormUpdate()
       Whether or not to use the middle product form update rather than the
 standard eta LU update. The middle form product update should be a lot more
 efficient (close to the Forrest-Tomlin update, a bit slower but easier to
 implement). See for more details:
 Qi Huangfu, J. A. Julian Hall, "Novel update techniques for the revised
 simplex method", 28 january 2013, Technical Report ERGO-13-0001
 http://www.maths.ed.ac.uk/hall/HuHa12/ERGO-13-001.pdf
      optional bool use_middle_product_form_update = 35 [default = true];
      Specified by:
      hasUseMiddleProductFormUpdate in interface GlopParametersOrBuilder
      Returns:
      Whether the useMiddleProductFormUpdate field is set.

    • getUseMiddleProductFormUpdate

      public boolean getUseMiddleProductFormUpdate()
       Whether or not to use the middle product form update rather than the
 standard eta LU update. The middle form product update should be a lot more
 efficient (close to the Forrest-Tomlin update, a bit slower but easier to
 implement). See for more details:
 Qi Huangfu, J. A. Julian Hall, "Novel update techniques for the revised
 simplex method", 28 january 2013, Technical Report ERGO-13-0001
 http://www.maths.ed.ac.uk/hall/HuHa12/ERGO-13-001.pdf
      optional bool use_middle_product_form_update = 35 [default = true];
      Specified by:
      getUseMiddleProductFormUpdate in interface GlopParametersOrBuilder
      Returns:
      The useMiddleProductFormUpdate.

    • hasInitializeDevexWithColumnNorms

      public boolean hasInitializeDevexWithColumnNorms()
       Whether we initialize devex weights to 1.0 or to the norms of the matrix
 columns.
      optional bool initialize_devex_with_column_norms = 36 [default = true];
      Specified by:
      hasInitializeDevexWithColumnNorms in interface GlopParametersOrBuilder
      Returns:
      Whether the initializeDevexWithColumnNorms field is set.

    • getInitializeDevexWithColumnNorms

      public boolean getInitializeDevexWithColumnNorms()
       Whether we initialize devex weights to 1.0 or to the norms of the matrix
 columns.
      optional bool initialize_devex_with_column_norms = 36 [default = true];
      Specified by:
      getInitializeDevexWithColumnNorms in interface GlopParametersOrBuilder
      Returns:
      The initializeDevexWithColumnNorms.

    • hasExploitSingletonColumnInInitialBasis

      public boolean hasExploitSingletonColumnInInitialBasis()
       Whether or not we exploit the singleton columns already present in the
 problem when we create the initial basis.
      optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
      Specified by:
      hasExploitSingletonColumnInInitialBasis in interface GlopParametersOrBuilder
      Returns:
      Whether the exploitSingletonColumnInInitialBasis field is set.

    • getExploitSingletonColumnInInitialBasis

      public boolean getExploitSingletonColumnInInitialBasis()
       Whether or not we exploit the singleton columns already present in the
 problem when we create the initial basis.
      optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
      Specified by:
      getExploitSingletonColumnInInitialBasis in interface GlopParametersOrBuilder
      Returns:
      The exploitSingletonColumnInInitialBasis.

    • hasDualSmallPivotThreshold

      public boolean hasDualSmallPivotThreshold()
       Like small_pivot_threshold but for the dual simplex. This is needed because
 the dual algorithm does not interpret this value in the same way.
 TODO(user): Clean this up and use the same small pivot detection.
      optional double dual_small_pivot_threshold = 38 [default = 0.0001];
      Specified by:
      hasDualSmallPivotThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the dualSmallPivotThreshold field is set.

    • getDualSmallPivotThreshold

      public double getDualSmallPivotThreshold()
       Like small_pivot_threshold but for the dual simplex. This is needed because
 the dual algorithm does not interpret this value in the same way.
 TODO(user): Clean this up and use the same small pivot detection.
      optional double dual_small_pivot_threshold = 38 [default = 0.0001];
      Specified by:
      getDualSmallPivotThreshold in interface GlopParametersOrBuilder
      Returns:
      The dualSmallPivotThreshold.

    • hasPreprocessorZeroTolerance

      public boolean hasPreprocessorZeroTolerance()
       A floating point tolerance used by the preprocessors. This is used for
 things like detecting if two columns/rows are proportional or if an
 interval is empty.

 Note that the preprocessors also use solution_feasibility_tolerance() to
 detect if a problem is infeasible.
      optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
      Specified by:
      hasPreprocessorZeroTolerance in interface GlopParametersOrBuilder
      Returns:
      Whether the preprocessorZeroTolerance field is set.

    • getPreprocessorZeroTolerance

      public double getPreprocessorZeroTolerance()
       A floating point tolerance used by the preprocessors. This is used for
 things like detecting if two columns/rows are proportional or if an
 interval is empty.

 Note that the preprocessors also use solution_feasibility_tolerance() to
 detect if a problem is infeasible.
      optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
      Specified by:
      getPreprocessorZeroTolerance in interface GlopParametersOrBuilder
      Returns:
      The preprocessorZeroTolerance.

    • hasObjectiveLowerLimit

      public boolean hasObjectiveLowerLimit()
       The solver will stop as soon as it has proven that the objective is smaller
 than objective_lower_limit or greater than objective_upper_limit. Depending
 on the simplex algorithm (primal or dual) and the optimization direction,
 note that only one bound will be used at the time.

 Important: The solver does not add any tolerances to these values, and as
 soon as the objective (as computed by the solver, so with some imprecision)
 crosses one of these bounds (strictly), the search will stop. It is up to
 the client to add any tolerance if needed.
      optional double objective_lower_limit = 40 [default = -inf];
      Specified by:
      hasObjectiveLowerLimit in interface GlopParametersOrBuilder
      Returns:
      Whether the objectiveLowerLimit field is set.

    • getObjectiveLowerLimit

      public double getObjectiveLowerLimit()
       The solver will stop as soon as it has proven that the objective is smaller
 than objective_lower_limit or greater than objective_upper_limit. Depending
 on the simplex algorithm (primal or dual) and the optimization direction,
 note that only one bound will be used at the time.

 Important: The solver does not add any tolerances to these values, and as
 soon as the objective (as computed by the solver, so with some imprecision)
 crosses one of these bounds (strictly), the search will stop. It is up to
 the client to add any tolerance if needed.
      optional double objective_lower_limit = 40 [default = -inf];
      Specified by:
      getObjectiveLowerLimit in interface GlopParametersOrBuilder
      Returns:
      The objectiveLowerLimit.

    • hasObjectiveUpperLimit

      public boolean hasObjectiveUpperLimit()
      optional double objective_upper_limit = 41 [default = inf];
      Specified by:
      hasObjectiveUpperLimit in interface GlopParametersOrBuilder
      Returns:
      Whether the objectiveUpperLimit field is set.

    • getObjectiveUpperLimit

      public double getObjectiveUpperLimit()
      optional double objective_upper_limit = 41 [default = inf];
      Specified by:
      getObjectiveUpperLimit in interface GlopParametersOrBuilder
      Returns:
      The objectiveUpperLimit.

    • hasDegenerateMinistepFactor

      public boolean hasDegenerateMinistepFactor()
       During a degenerate iteration, the more conservative approach is to do a
 step of length zero (while shifting the bound of the leaving variable).
 That is, the variable values are unchanged for the primal simplex or the
 reduced cost are unchanged for the dual simplex. However, instead of doing
 a step of length zero, it seems to be better on degenerate problems to do a
 small positive step. This is what is recommended in the EXPAND procedure
 described in:
 P. E. Gill, W. Murray, M. A. Saunders, and M. H. Wright. "A practical anti-
 cycling procedure for linearly constrained optimization".
 Mathematical Programming, 45:437\u2013474, 1989.

 Here, during a degenerate iteration we do a small positive step of this
 factor times the primal (resp. dual) tolerance. In the primal simplex, this
 may effectively push variable values (very slightly) further out of their
 bounds (resp. reduced costs for the dual simplex).

 Setting this to zero reverts to the more conservative approach of a zero
 step during degenerate iterations.
      optional double degenerate_ministep_factor = 42 [default = 0.01];
      Specified by:
      hasDegenerateMinistepFactor in interface GlopParametersOrBuilder
      Returns:
      Whether the degenerateMinistepFactor field is set.

    • getDegenerateMinistepFactor

      public double getDegenerateMinistepFactor()
       During a degenerate iteration, the more conservative approach is to do a
 step of length zero (while shifting the bound of the leaving variable).
 That is, the variable values are unchanged for the primal simplex or the
 reduced cost are unchanged for the dual simplex. However, instead of doing
 a step of length zero, it seems to be better on degenerate problems to do a
 small positive step. This is what is recommended in the EXPAND procedure
 described in:
 P. E. Gill, W. Murray, M. A. Saunders, and M. H. Wright. "A practical anti-
 cycling procedure for linearly constrained optimization".
 Mathematical Programming, 45:437\u2013474, 1989.

 Here, during a degenerate iteration we do a small positive step of this
 factor times the primal (resp. dual) tolerance. In the primal simplex, this
 may effectively push variable values (very slightly) further out of their
 bounds (resp. reduced costs for the dual simplex).

 Setting this to zero reverts to the more conservative approach of a zero
 step during degenerate iterations.
      optional double degenerate_ministep_factor = 42 [default = 0.01];
      Specified by:
      getDegenerateMinistepFactor in interface GlopParametersOrBuilder
      Returns:
      The degenerateMinistepFactor.

    • hasRandomSeed

      public boolean hasRandomSeed()
       At the beginning of each solve, the random number generator used in some
 part of the solver is reinitialized to this seed. If you change the random
 seed, the solver may make different choices during the solving process.
 Note that this may lead to a different solution, for example a different
 optimal basis.

 For some problems, the running time may vary a lot depending on small
 change in the solving algorithm. Running the solver with different seeds
 enables to have more robust benchmarks when evaluating new features.

 Also note that the solver is fully deterministic: two runs of the same
 binary, on the same machine, on the exact same data and with the same
 parameters will go through the exact same iterations. If they hit a time
 limit, they might of course yield different results because one will have
 advanced farther than the other.
      optional int32 random_seed = 43 [default = 1];
      Specified by:
      hasRandomSeed in interface GlopParametersOrBuilder
      Returns:
      Whether the randomSeed field is set.

    • getRandomSeed

      public int getRandomSeed()
       At the beginning of each solve, the random number generator used in some
 part of the solver is reinitialized to this seed. If you change the random
 seed, the solver may make different choices during the solving process.
 Note that this may lead to a different solution, for example a different
 optimal basis.

 For some problems, the running time may vary a lot depending on small
 change in the solving algorithm. Running the solver with different seeds
 enables to have more robust benchmarks when evaluating new features.

 Also note that the solver is fully deterministic: two runs of the same
 binary, on the same machine, on the exact same data and with the same
 parameters will go through the exact same iterations. If they hit a time
 limit, they might of course yield different results because one will have
 advanced farther than the other.
      optional int32 random_seed = 43 [default = 1];
      Specified by:
      getRandomSeed in interface GlopParametersOrBuilder
      Returns:
      The randomSeed.

    • hasUseAbslRandom

      public boolean hasUseAbslRandom()
       Whether to use absl::BitGen instead of MTRandom.
      optional bool use_absl_random = 72 [default = false];
      Specified by:
      hasUseAbslRandom in interface GlopParametersOrBuilder
      Returns:
      Whether the useAbslRandom field is set.

    • getUseAbslRandom

      public boolean getUseAbslRandom()
       Whether to use absl::BitGen instead of MTRandom.
      optional bool use_absl_random = 72 [default = false];
      Specified by:
      getUseAbslRandom in interface GlopParametersOrBuilder
      Returns:
      The useAbslRandom.

    • hasNumOmpThreads

      public boolean hasNumOmpThreads()
       Number of threads in the OMP parallel sections. If left to 1, the code will
 not create any OMP threads and will remain single-threaded.
      optional int32 num_omp_threads = 44 [default = 1];
      Specified by:
      hasNumOmpThreads in interface GlopParametersOrBuilder
      Returns:
      Whether the numOmpThreads field is set.

    • getNumOmpThreads

      public int getNumOmpThreads()
       Number of threads in the OMP parallel sections. If left to 1, the code will
 not create any OMP threads and will remain single-threaded.
      optional int32 num_omp_threads = 44 [default = 1];
      Specified by:
      getNumOmpThreads in interface GlopParametersOrBuilder
      Returns:
      The numOmpThreads.

    • hasPerturbCostsInDualSimplex

      public boolean hasPerturbCostsInDualSimplex()
       When this is true, then the costs are randomly perturbed before the dual
 simplex is even started. This has been shown to improve the dual simplex
 performance. For a good reference, see Huangfu Q (2013) "High performance
 simplex solver", Ph.D, dissertation, University of Edinburgh.
      optional bool perturb_costs_in_dual_simplex = 53 [default = false];
      Specified by:
      hasPerturbCostsInDualSimplex in interface GlopParametersOrBuilder
      Returns:
      Whether the perturbCostsInDualSimplex field is set.

    • getPerturbCostsInDualSimplex

      public boolean getPerturbCostsInDualSimplex()
       When this is true, then the costs are randomly perturbed before the dual
 simplex is even started. This has been shown to improve the dual simplex
 performance. For a good reference, see Huangfu Q (2013) "High performance
 simplex solver", Ph.D, dissertation, University of Edinburgh.
      optional bool perturb_costs_in_dual_simplex = 53 [default = false];
      Specified by:
      getPerturbCostsInDualSimplex in interface GlopParametersOrBuilder
      Returns:
      The perturbCostsInDualSimplex.

    • hasUseDedicatedDualFeasibilityAlgorithm

      public boolean hasUseDedicatedDualFeasibilityAlgorithm()
       We have two possible dual phase I algorithms. Both work on an LP that
 minimize the sum of dual infeasiblities. One use dedicated code (when this
 param is true), the other one use exactly the same code as the dual phase
 II but on an auxiliary problem where the variable bounds of the original
 problem are changed.

 TODO(user): For now we have both, but ideally the non-dedicated version
 will win since it is a lot less code to maintain.
      optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
      Specified by:
      hasUseDedicatedDualFeasibilityAlgorithm in interface GlopParametersOrBuilder
      Returns:
      Whether the useDedicatedDualFeasibilityAlgorithm field is set.

    • getUseDedicatedDualFeasibilityAlgorithm

      public boolean getUseDedicatedDualFeasibilityAlgorithm()
       We have two possible dual phase I algorithms. Both work on an LP that
 minimize the sum of dual infeasiblities. One use dedicated code (when this
 param is true), the other one use exactly the same code as the dual phase
 II but on an auxiliary problem where the variable bounds of the original
 problem are changed.

 TODO(user): For now we have both, but ideally the non-dedicated version
 will win since it is a lot less code to maintain.
      optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
      Specified by:
      getUseDedicatedDualFeasibilityAlgorithm in interface GlopParametersOrBuilder
      Returns:
      The useDedicatedDualFeasibilityAlgorithm.

    • hasRelativeCostPerturbation

      public boolean hasRelativeCostPerturbation()
       The magnitude of the cost perturbation is given by
 RandomIn(1.0, 2.0) * (
 relative_cost_perturbation * cost
 + relative_max_cost_perturbation * max_cost);
      optional double relative_cost_perturbation = 54 [default = 1e-05];
      Specified by:
      hasRelativeCostPerturbation in interface GlopParametersOrBuilder
      Returns:
      Whether the relativeCostPerturbation field is set.

    • getRelativeCostPerturbation

      public double getRelativeCostPerturbation()
       The magnitude of the cost perturbation is given by
 RandomIn(1.0, 2.0) * (
 relative_cost_perturbation * cost
 + relative_max_cost_perturbation * max_cost);
      optional double relative_cost_perturbation = 54 [default = 1e-05];
      Specified by:
      getRelativeCostPerturbation in interface GlopParametersOrBuilder
      Returns:
      The relativeCostPerturbation.

    • hasRelativeMaxCostPerturbation

      public boolean hasRelativeMaxCostPerturbation()
      optional double relative_max_cost_perturbation = 55 [default = 1e-07];
      Specified by:
      hasRelativeMaxCostPerturbation in interface GlopParametersOrBuilder
      Returns:
      Whether the relativeMaxCostPerturbation field is set.

    • getRelativeMaxCostPerturbation

      public double getRelativeMaxCostPerturbation()
      optional double relative_max_cost_perturbation = 55 [default = 1e-07];
      Specified by:
      getRelativeMaxCostPerturbation in interface GlopParametersOrBuilder
      Returns:
      The relativeMaxCostPerturbation.

    • hasInitialConditionNumberThreshold

      public boolean hasInitialConditionNumberThreshold()
       If our upper bound on the condition number of the initial basis (from our
 heurisitic or a warm start) is above this threshold, we revert to an all
 slack basis.
      optional double initial_condition_number_threshold = 59 [default = 1e+50];
      Specified by:
      hasInitialConditionNumberThreshold in interface GlopParametersOrBuilder
      Returns:
      Whether the initialConditionNumberThreshold field is set.

    • getInitialConditionNumberThreshold

      public double getInitialConditionNumberThreshold()
       If our upper bound on the condition number of the initial basis (from our
 heurisitic or a warm start) is above this threshold, we revert to an all
 slack basis.
      optional double initial_condition_number_threshold = 59 [default = 1e+50];
      Specified by:
      getInitialConditionNumberThreshold in interface GlopParametersOrBuilder
      Returns:
      The initialConditionNumberThreshold.

    • hasLogSearchProgress

      public boolean hasLogSearchProgress()
       If true, logs the progress of a solve to LOG(INFO). Note that the same
 messages can also be turned on by displaying logs at level 1 for the
 relevant files.
      optional bool log_search_progress = 61 [default = false];
      Specified by:
      hasLogSearchProgress in interface GlopParametersOrBuilder
      Returns:
      Whether the logSearchProgress field is set.

    • getLogSearchProgress

      public boolean getLogSearchProgress()
       If true, logs the progress of a solve to LOG(INFO). Note that the same
 messages can also be turned on by displaying logs at level 1 for the
 relevant files.
      optional bool log_search_progress = 61 [default = false];
      Specified by:
      getLogSearchProgress in interface GlopParametersOrBuilder
      Returns:
      The logSearchProgress.

    • hasLogToStdout

      public boolean hasLogToStdout()
       If true, logs will be displayed to stdout instead of using Google log info.
      optional bool log_to_stdout = 66 [default = true];
      Specified by:
      hasLogToStdout in interface GlopParametersOrBuilder
      Returns:
      Whether the logToStdout field is set.

    • getLogToStdout

      public boolean getLogToStdout()
       If true, logs will be displayed to stdout instead of using Google log info.
      optional bool log_to_stdout = 66 [default = true];
      Specified by:
      getLogToStdout in interface GlopParametersOrBuilder
      Returns:
      The logToStdout.

    • hasCrossoverBoundSnappingDistance

      public boolean hasCrossoverBoundSnappingDistance()
       If the starting basis contains FREE variable with bounds, we will move
 any such variable to their closer bounds if the distance is smaller than
 this parameter.

 The starting statuses can contains FREE variables with bounds, if a user
 set it like this externally. Also, any variable with an initial BASIC
 status that was not kept in the initial basis is marked as FREE before this
 step is applied.

 Note that by default a FREE variable is assumed to be zero unless a
 starting value was specified via SetStartingVariableValuesForNextSolve().

 Note that, at the end of the solve, some of these FREE variable with bounds
 and an interior point value might still be left in the final solution.
 Enable push_to_vertex to clean these up.
      optional double crossover_bound_snapping_distance = 64 [default = inf];
      Specified by:
      hasCrossoverBoundSnappingDistance in interface GlopParametersOrBuilder
      Returns:
      Whether the crossoverBoundSnappingDistance field is set.

    • getCrossoverBoundSnappingDistance

      public double getCrossoverBoundSnappingDistance()
       If the starting basis contains FREE variable with bounds, we will move
 any such variable to their closer bounds if the distance is smaller than
 this parameter.

 The starting statuses can contains FREE variables with bounds, if a user
 set it like this externally. Also, any variable with an initial BASIC
 status that was not kept in the initial basis is marked as FREE before this
 step is applied.

 Note that by default a FREE variable is assumed to be zero unless a
 starting value was specified via SetStartingVariableValuesForNextSolve().

 Note that, at the end of the solve, some of these FREE variable with bounds
 and an interior point value might still be left in the final solution.
 Enable push_to_vertex to clean these up.
      optional double crossover_bound_snapping_distance = 64 [default = inf];
      Specified by:
      getCrossoverBoundSnappingDistance in interface GlopParametersOrBuilder
      Returns:
      The crossoverBoundSnappingDistance.

    • hasPushToVertex

      public boolean hasPushToVertex()
       If the optimization phases finishes with super-basic variables (i.e.,
 variables that either 1) have bounds but are FREE in the basis, or 2) have
 no bounds and are FREE in the basis at a nonzero value), then run a "push"
 phase to push these variables to bounds, obtaining a vertex solution. Note
 this situation can happen only if a starting value was specified via
 SetStartingVariableValuesForNextSolve().
      optional bool push_to_vertex = 65 [default = true];
      Specified by:
      hasPushToVertex in interface GlopParametersOrBuilder
      Returns:
      Whether the pushToVertex field is set.

    • getPushToVertex

      public boolean getPushToVertex()
       If the optimization phases finishes with super-basic variables (i.e.,
 variables that either 1) have bounds but are FREE in the basis, or 2) have
 no bounds and are FREE in the basis at a nonzero value), then run a "push"
 phase to push these variables to bounds, obtaining a vertex solution. Note
 this situation can happen only if a starting value was specified via
 SetStartingVariableValuesForNextSolve().
      optional bool push_to_vertex = 65 [default = true];
      Specified by:
      getPushToVertex in interface GlopParametersOrBuilder
      Returns:
      The pushToVertex.

    • hasUseImpliedFreePreprocessor

      public boolean hasUseImpliedFreePreprocessor()
       If presolve runs, include the pass that detects implied free variables.
      optional bool use_implied_free_preprocessor = 67 [default = true];
      Specified by:
      hasUseImpliedFreePreprocessor in interface GlopParametersOrBuilder
      Returns:
      Whether the useImpliedFreePreprocessor field is set.

    • getUseImpliedFreePreprocessor

      public boolean getUseImpliedFreePreprocessor()
       If presolve runs, include the pass that detects implied free variables.
      optional bool use_implied_free_preprocessor = 67 [default = true];
      Specified by:
      getUseImpliedFreePreprocessor in interface GlopParametersOrBuilder
      Returns:
      The useImpliedFreePreprocessor.

    • hasMaxValidMagnitude

      public boolean hasMaxValidMagnitude()
       Any finite values in the input LP must be below this threshold, otherwise
 the model will be reported invalid. This is needed to avoid floating point
 overflow when evaluating bounds * coeff for instance. In practice, users
 shouldn't use super large values in an LP. With the default threshold, even
 evaluating large constraint with variables at their bound shouldn't cause
 any overflow.
      optional double max_valid_magnitude = 70 [default = 1e+30];
      Specified by:
      hasMaxValidMagnitude in interface GlopParametersOrBuilder
      Returns:
      Whether the maxValidMagnitude field is set.

    • getMaxValidMagnitude

      public double getMaxValidMagnitude()
       Any finite values in the input LP must be below this threshold, otherwise
 the model will be reported invalid. This is needed to avoid floating point
 overflow when evaluating bounds * coeff for instance. In practice, users
 shouldn't use super large values in an LP. With the default threshold, even
 evaluating large constraint with variables at their bound shouldn't cause
 any overflow.
      optional double max_valid_magnitude = 70 [default = 1e+30];
      Specified by:
      getMaxValidMagnitude in interface GlopParametersOrBuilder
      Returns:
      The maxValidMagnitude.

    • hasDropMagnitude

      public boolean hasDropMagnitude()
       Value in the input LP lower than this will be ignored. This is similar to
 drop_tolerance but more aggressive as this is used before scaling. This is
 mainly here to avoid underflow and have simpler invariant in the code, like
 a * b == 0 iff a or b is zero and things like this.
      optional double drop_magnitude = 71 [default = 1e-30];
      Specified by:
      hasDropMagnitude in interface GlopParametersOrBuilder
      Returns:
      Whether the dropMagnitude field is set.

    • getDropMagnitude

      public double getDropMagnitude()
       Value in the input LP lower than this will be ignored. This is similar to
 drop_tolerance but more aggressive as this is used before scaling. This is
 mainly here to avoid underflow and have simpler invariant in the code, like
 a * b == 0 iff a or b is zero and things like this.
      optional double drop_magnitude = 71 [default = 1e-30];
      Specified by:
      getDropMagnitude in interface GlopParametersOrBuilder
      Returns:
      The dropMagnitude.

    • hasDualPricePrioritizeNorm

      public boolean hasDualPricePrioritizeNorm()
       On some problem like stp3d or pds-100 this makes a huge difference in
 speed and number of iterations of the dual simplex.
      optional bool dual_price_prioritize_norm = 69 [default = false];
      Specified by:
      hasDualPricePrioritizeNorm in interface GlopParametersOrBuilder
      Returns:
      Whether the dualPricePrioritizeNorm field is set.

    • getDualPricePrioritizeNorm

      public boolean getDualPricePrioritizeNorm()
       On some problem like stp3d or pds-100 this makes a huge difference in
 speed and number of iterations of the dual simplex.
      optional bool dual_price_prioritize_norm = 69 [default = false];
      Specified by:
      getDualPricePrioritizeNorm in interface GlopParametersOrBuilder
      Returns:
      The dualPricePrioritizeNorm.

    • isInitialized

      public final boolean isInitialized()
      Specified by:
      isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
      Overrides:
      isInitialized in class com.google.protobuf.GeneratedMessage

    • writeTo

      public void writeTo(com.google.protobuf.CodedOutputStream output) throws IOException
      Specified by:
      writeTo in interface com.google.protobuf.MessageLite
      Overrides:
      writeTo in class com.google.protobuf.GeneratedMessage
      Throws:
      IOException

    • getSerializedSize

      public int getSerializedSize()
      Specified by:
      getSerializedSize in interface com.google.protobuf.MessageLite
      Overrides:
      getSerializedSize in class com.google.protobuf.GeneratedMessage

    • equals

      public boolean equals(Object obj)
      Specified by:
      equals in interface com.google.protobuf.Message
      Overrides:
      equals in class com.google.protobuf.AbstractMessage

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface com.google.protobuf.Message
      Overrides:
      hashCode in class com.google.protobuf.AbstractMessage

    • parseFrom

      public static GlopParameters parseFrom(ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException
      Throws:
      com.google.protobuf.InvalidProtocolBufferException

    • parseFrom

      public static GlopParameters parseFrom(ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException
      Throws:
      com.google.protobuf.InvalidProtocolBufferException

    • parseFrom

      public static GlopParameters parseFrom(com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException
      Throws:
      com.google.protobuf.InvalidProtocolBufferException

    • parseFrom

      public static GlopParameters parseFrom(com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException
      Throws:
      com.google.protobuf.InvalidProtocolBufferException

    • parseFrom

      public static GlopParameters parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException
      Throws:
      com.google.protobuf.InvalidProtocolBufferException

    • parseFrom

      public static GlopParameters parseFrom(byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException
      Throws:
      com.google.protobuf.InvalidProtocolBufferException

    • parseFrom

      public static GlopParameters parseFrom(InputStream input) throws IOException
      Throws:
      IOException

    • parseFrom

      public static GlopParameters parseFrom(InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws IOException
      Throws:
      IOException

    • parseDelimitedFrom

      public static GlopParameters parseDelimitedFrom(InputStream input) throws IOException
      Throws:
      IOException

    • parseDelimitedFrom

      public static GlopParameters parseDelimitedFrom(InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws IOException
      Throws:
      IOException

    • parseFrom

      public static GlopParameters parseFrom(com.google.protobuf.CodedInputStream input) throws IOException
      Throws:
      IOException

    • parseFrom

      public static GlopParameters parseFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws IOException
      Throws:
      IOException

    • newBuilderForType

      public GlopParameters.Builder newBuilderForType()
      Specified by:
      newBuilderForType in interface com.google.protobuf.Message
      Specified by:
      newBuilderForType in interface com.google.protobuf.MessageLite

    • newBuilder

      public static GlopParameters.Builder newBuilder()

    • newBuilder

      public static GlopParameters.Builder newBuilder(GlopParameters prototype)

    • toBuilder

      public GlopParameters.Builder toBuilder()
      Specified by:
      toBuilder in interface com.google.protobuf.Message
      Specified by:
      toBuilder in interface com.google.protobuf.MessageLite

    • newBuilderForType

      protected GlopParameters.Builder newBuilderForType(com.google.protobuf.AbstractMessage.BuilderParent parent)
      Overrides:
      newBuilderForType in class com.google.protobuf.AbstractMessage

    • getDefaultInstance

      public static GlopParameters getDefaultInstance()

    • parser

      public static com.google.protobuf.Parser<GlopParameters> parser()

    • getParserForType

      public com.google.protobuf.Parser<GlopParameters> getParserForType()
      Specified by:
      getParserForType in interface com.google.protobuf.Message
      Specified by:
      getParserForType in interface com.google.protobuf.MessageLite
      Overrides:
      getParserForType in class com.google.protobuf.GeneratedMessage

    • getDefaultInstanceForType

      public GlopParameters getDefaultInstanceForType()
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder