Compares newValue and oldValue to see if they are the same.
If this is the case, this change is redundant, since it doesn't represent a true change.
This can happen on compounded changes.

@return true if redundant, else if otherwise.
975092
public boolean isRedundant() {
    if (isListChange()) {
      return Objects.equals(oldList.get(),newList.get());
    }
    return oldValue.get().equals(newValue.get());
  }
105323
private boolean isRedundantTransform(CrystalTransform tt) {

		Iterator<CrystalTransform> it = visitedCrystalTransforms.iterator();
		while (it.hasNext()) {
			CrystalTransform v = it.next();

			if (tt.isEquivalent(v)) {

				logger.debug("Skipping redundant transformation: "+tt+", equivalent to "+v);

				// there's only 1 possible equivalent partner for each visited matrix
				// (since the equivalent is its inverse matrix and the inverse matrix is unique)
				// thus once the partner has been seen, we don't need to check it ever again
				it.remove();

				return true;
			}
		}

		return false;
	}
1206642
private boolean valueEquals(V leftValue, V rightValue) {
        if (leftValue == rightValue) {
            return true;
        }
        if (leftValue == null || rightValue == null) {
            return false;
        }
        return leftValue.equals(rightValue);
    }
801404
public boolean isEquivalentTo(Semver version) {
        // Get versions without build
        Semver sem1 = this.getBuild() == null ? this : new Semver(this.getValue().replace("+" + this.getBuild(), ""));
        Semver sem2 = version.getBuild() == null ? version : new Semver(version.getValue().replace("+" + version.getBuild(), ""));
        // Compare those new versions
        return sem1.isEqualTo(sem2);
    }
997219
public boolean isResetValues() {
        Boolean result = (Boolean) eval(RESET_VALUES, resetValues);
        return ((result != null) ? result : false);
    }
981058
private boolean updateMinMaxValues() {

        double min_x_value_new;
        double max_x_value_new;
        double max_y_value_new;

        if (this.measures == null) {
            // no values received yet -> reset axes
            min_x_value_new = 0;
            max_x_value_new = 1;
            max_y_value_new = 1;
        } else {
            min_x_value_new = getMinXValue();
            max_x_value_new = getMaxXValue();
            max_y_value_new = getMaxSelectedValue();
        }

        // resizing needed?
        if (min_x_value_new != this.min_x_value
                || max_x_value_new != this.max_x_value
                || max_y_value_new != this.max_y_value) {
            this.min_x_value = min_x_value_new;
            this.max_x_value = max_x_value_new;
            this.max_y_value = max_y_value_new;
            updateMinXValue();
            updateMaxXValue();
            updateMaxYValue();
            updateLowerXValue();
            updateUpperXValue();
            updateUpperYValue();
            return true;
        }
        return false;
    }
1219357
protected boolean valuesEqual(MapEntryValue oldValue, MapEntryValue newValue) {
    return (oldValue == null && newValue == null)
        || (oldValue != null && newValue != null && valuesEqual(oldValue.value(), newValue.value()));
  }
158977
public boolean isForeignKeyChanged() {
        return CollectionUtils.exists(differences.values(), new Predicate() {
            @Override
            public boolean evaluate(Object object) {
                return ((ModelDiffEntry) object).isForeignKey();
            }
        });
    }
1036592
public boolean sameAs(Object obj){
		if(obj==null){
			return false;
		}
		if(obj instanceof String || obj instanceof IdVersionString){
			if(this.toString().equals(obj.toString())){
				return true;
			}
		}
		return false;
	}
1050357
public boolean sameAs(BlockType other) {
        if (!this.isValid) {
            return !other.isValid && (this.isTop == other.isTop);
        } else {
            if (!other.isValid) {
                return false;
            } else {
                // Both facts are valid
                if (this.depth != other.depth) {
                    return false;
                }

                // Compare bits
                for (int i = 0; i < this.depth; ++i) {
                    if (this.get(i) != other.get(i)) {
                        return false;
                    }
                }

                return true;
            }
        }
    }
234279
@Override
  public boolean isModified()
  {
    long now = CurrentTime.currentTime();
    long lastCheckTime = _lastCheckTime.get();
    
    if (now <= lastCheckTime + _checkInterval) {
      return _isModified;
    }

    if (! _lastCheckTime.compareAndSet(lastCheckTime, now)) {
      return _isModified;
    }

    if (isModifiedImpl()) {
      _isModified = true;
      //_lastCheckTime.set(0);
    }
    else {
      _isModified = false;
    }

    return _isModified;
  }
1312553
protected boolean isPlusMinusOneValue(QuantityValue quantityValue) {
		BigDecimal valueSucc = quantityValue.getNumericValue().add(
				BigDecimal.ONE);
		BigDecimal valuePrec = quantityValue.getNumericValue().subtract(
				BigDecimal.ONE);
		return (quantityValue.getLowerBound().equals(valuePrec)
				&& quantityValue.getUpperBound().equals(valueSucc) && "1"
					.equals(quantityValue.getUnit()));
	}
1122416
public boolean checkDuplicate(T obj)
    {
        int top = _top.get();

        for (int i = top - 1; i >= 0; i--) {
            if (_freeStack.get(i) == obj)
                return true;
        }

        return false;
    }
162577
protected boolean sameValue(Object newValue, Object currentValue) {
        if (newValue == NOT_FOUND) {
            return true;
        }
        if (currentValue == NOT_FOUND) {
            currentValue = Undefined.instance;
        }
        // Special rules for numbers: NaN is considered the same value,
        // while zeroes with different signs are considered different.
        if (currentValue instanceof Number && newValue instanceof Number) {
            double d1 = ((Number)currentValue).doubleValue();
            double d2 = ((Number)newValue).doubleValue();
            if (Double.isNaN(d1) && Double.isNaN(d2)) {
                return true;
            }
            if (d1 == 0.0 && Double.doubleToLongBits(d1) != Double.doubleToLongBits(d2)) {
                return false;
            }
        }
        return ScriptRuntime.shallowEq(currentValue, newValue);
    }
816178
boolean valuesAreTheSameAsDefault()
    {
        if (getDefaultValues() == null || getDefaultValues().size() == 0)
            return false;
        if (getValues() == null || getValues().size() == 0)
            return false;
        if (getDefaultValues().size() != getValues().size())
            return false;
        for (int v = 0; v < getDefaultValues().size(); v++)
            if (!getDefaultValues().get(v).equals(getValues().get(v)))
                return false;
        return true;
    }
843909
def changed(self):
        
        if self.explicit:
            return self.value != self.previous_value

        if isinstance(self.column, BaseContainerColumn):
            default_value = self.column.get_default()
            if self.column._val_is_null(default_value):
                return not self.column._val_is_null(self.value) and self.value != self.previous_value
            elif self.previous_value is None:
                return self.value != default_value

            return self.value != self.previous_value

        return False
816217
@ObjectiveCName("changeWithValue:")
    public boolean change(@Nullable T value) {
        if (this.value != null && value != null && value.equals(this.value)) {
            return false;
        }

        // No need in sync. We are not expected complex sync of value models
        this.value = value;

        notify(value);

        return true;
    }