Sets the error tolerance used for projection maintenance strategies such
as {@link KernelPoint.BudgetStrategy#PROJECTION}
@param errorTolerance the error tolerance in [0, 1]
968777
public void setErrorTolerance(double errorTolerance)
    {
        if(Double.isNaN(errorTolerance) || errorTolerance < 0 || errorTolerance > 1)
            throw new IllegalArgumentException("Error tolerance must be in [0, 1], not " + errorTolerance);
        this.errorTolerance = errorTolerance;
        for(KernelPoint kp : points)
            kp.setErrorTolerance(errorTolerance);
    }
170779
public void setValidationErrors(java.util.Collection<ValidationError> validationErrors) {
        if (validationErrors == null) {
            this.validationErrors = null;
            return;
        }

        this.validationErrors = new com.amazonaws.internal.SdkInternalList<ValidationError>(validationErrors);
    }
273108
public void setErrorMessage(String msg) {
        if (msg != null && msg.trim().length() > 0) {
            errorMessage = msg;
        }
    }
183826
@Override
    public final void setReliability(Reliability value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setReliability", value);
        if (value != null) {
            /* Call the superclass's method to get the int value of the Reliability instance and set it into the field */
            super.setReliability(value);
        }
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "setReliability", "NullPointerException");
            throw new NullPointerException();
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setReliability");
    }
1051624
public final void setErrorMessage(@NonNull final CharSequence errorMessage) {
        Condition.INSTANCE.ensureNotNull(errorMessage, "The error message may not be null");
        Condition.INSTANCE.ensureNotEmpty(errorMessage, "The error message may not be empty");
        this.errorMessage = errorMessage;
    }
497409
public void setErrors(com.google.api.ads.admanager.axis.v201811.ApiError[] errors) {
        this.errors = errors;
    }
636971
public void setErrorClass(java.lang.String errorClass) {
        getStateHelper().put(PropertyKeys.errorClass, errorClass);
    }
123812
public IterableOfProtosFluentAssertion<M> usingFloatToleranceForFieldDescriptors(
      float tolerance, Iterable<FieldDescriptor> fieldDescriptors) {
    return usingConfig(config.usingFloatToleranceForFieldDescriptors(tolerance, fieldDescriptors));
  }
756297
static void checkTolerance(float tolerance) {
    checkArgument(!Float.isNaN(tolerance), "tolerance cannot be NaN");
    checkArgument(tolerance >= 0.0f, "tolerance (%s) cannot be negative", tolerance);
    checkArgument(
        floatToIntBits(tolerance) != NEG_ZERO_BITS, "tolerance (%s) cannot be negative", tolerance);
    checkArgument(tolerance != Float.POSITIVE_INFINITY, "tolerance cannot be POSITIVE_INFINITY");
  }
914026
public void setErrorTime(com.google.api.ads.admanager.axis.v201805.DateTime errorTime) {
        this.errorTime = errorTime;
    }
416913
public void setStandardErrorValue(float v) {
    if (Measure_Type.featOkTst && ((Measure_Type)jcasType).casFeat_standardErrorValue == null)
      jcasType.jcas.throwFeatMissing("standardErrorValue", "ch.epfl.bbp.uima.types.Measure");
    jcasType.ll_cas.ll_setFloatValue(addr, ((Measure_Type)jcasType).casFeatCode_standardErrorValue, v);}
180911
public static void updateBinaryErrorMap(final ErrorMap map) {
        if (map == null) {
            return;
        }

        if (BINARY_ERROR_MAP == null || map.compareTo(BINARY_ERROR_MAP) > 0) {
            BINARY_ERROR_MAP = map;
        }
    }
1014593
protected void setErrorTags(Span span, Throwable error) {
        if (error != null) {
            String message = error.getMessage();
            if (message == null) {
                message = error.getClass().getSimpleName();
            }
            span.setTag(TAG_ERROR, message);
        }
    }
1169841
public void setValidationErrors(java.util.Collection<ValidationError> validationErrors) {
        if (validationErrors == null) {
            this.validationErrors = null;
            return;
        }

        this.validationErrors = new java.util.ArrayList<ValidationError>(validationErrors);
    }
826164
public MapWithProtoValuesFluentAssertion<M> usingDoubleToleranceForFieldDescriptorsForValues(
      double tolerance, FieldDescriptor firstFieldDescriptor, FieldDescriptor... rest) {
    return usingConfig(
        config.usingDoubleToleranceForFieldDescriptors(
            tolerance, asList(firstFieldDescriptor, rest)));
  }
1177011
public void setFailures(java.util.Collection<String> failures) {
        if (failures == null) {
            this.failures = null;
            return;
        }

        this.failures = new java.util.ArrayList<String>(failures);
    }
177316
public void setErrors(java.util.Collection<TableError> errors) {
        if (errors == null) {
            this.errors = null;
            return;
        }

        this.errors = new java.util.ArrayList<TableError>(errors);
    }