Merge the result of an instance.

@param minmax Minmax value
436669
protected synchronized void merge(DoubleMinMax minmax) {
    this.minmax.put(minmax.getMin());
    this.minmax.put(minmax.getMax());
  }
530079
public void combine(@NonNull EnhancedDoubleStatistics other) {
      count += other.count;
      sum += other.sum;
      sumOfSq += other.sumOfSq;
      min = Math.min(min, other.min);
      max = Math.max(max, other.max);
   }
943461
public IVersionRange merge(IVersionRange... ranges) {
    if (ranges.length < 2) {
      return ranges[0];
    }

    // Check the type of the first range
    if (!(ranges[0] instanceof VersionRange)) {
      if (!(ranges[0] instanceof OrRange)) {
        throw new UnsupportedOperationException("Incorrect type for ranges[0]");
      }
      if (((OrRange) ranges[0]).size() != 2) {
        throw new UnsupportedOperationException("Incorrect size for ranges[0]");
      }
    }
    else {
      if (!((VersionRange) ranges[0]).isUnbounded()) {
        throw new UnsupportedOperationException("ranges[0] should be unbounded (> or >=)");
      }
    }

    int lastIndex = ranges.length - 1;

    // Check the type of the last range
    if (!(ranges[lastIndex] instanceof VersionRange)) {
      if (!(ranges[lastIndex] instanceof OrRange)) {
        throw new UnsupportedOperationException("Incorrect type for ranges[last]");
      }
      if (((OrRange) ranges[lastIndex]).size() != 2) {
        throw new UnsupportedOperationException("Incorrect size for ranges[last]");
      }
    }
    else {
      if (((VersionRange) ranges[lastIndex]).isUnbounded()) {
        throw new UnsupportedOperationException("ranges[0] should be bounded (< or <=)");
      }
    }

    // Check the rest of the types
    for (int i = 1; i < lastIndex; i++) {
      if (!(ranges[i] instanceof OrRange)) {
        throw new UnsupportedOperationException("Incorrect type for ranges[" + i + "]");
      }

      if (((OrRange) ranges[i]).size() != 2) {
        throw new UnsupportedOperationException("Incorrect size for ranges[" + i + "]");
      }
    }

    List<IVersionRange> results = new LinkedList<IVersionRange>();
    IVersionRange last = null;
    for (int i = 0; i < ranges.length; i++) {
      IVersionRange range = ranges[i];
      if (last == null) {
        if (range instanceof VersionRange) {
          last = range;
        }
        else {
          OrRange orange = (OrRange) range;
          results.add(orange.first());
          last = orange.last();
        }
      }
      else {
        if (range instanceof VersionRange) {
          AndRange arange = new AndRange(last, range);
          results.add(arange);
          last = null;
        }
        else {
          OrRange orange = (OrRange) range;
          AndRange arange = new AndRange(last, orange.first());
          results.add(arange);
          last = orange.last();
        }
      }
    }

    if (last != null) {
      results.add(last);
    }

    return new OrRange(results);
  }
855396
public void setMax(int max)
    {
        this.max = max;
        if (this.max < Alterable.MIN)
        {
            this.max = Alterable.MIN;
        }
        set(cur);
    }
277621
public void setDimension(double min, double max) {
        this.minx = min;
        this.maxx = max;
        this.miny = min;
        this.maxy = max;
        this.minz = min;
        this.maxz = max;
    }
1289775
public void mergeWith(ReturnPathType fact) {
        if (fact.isTop()) {
            // other fact is top: no change to this one
            return;
        } else if (this.isTop()) {
            // this fact is top: copy other fact
            this.copyFrom(fact);
        } else {
            // neither fact is top: as long as one of the two
            // facts represents a (possible) normal return, then the result
            // is a possible normal return
            if (fact.type == CAN_RETURN_NORMALLY) {
                this.type = CAN_RETURN_NORMALLY;
            }
        }
    }
1106167
public static void merge(final Readable input,
                           final Message.Builder builder)
                           throws IOException {
    merge(input, ExtensionRegistry.getEmptyRegistry(), builder);
  }
291947
@Override
	public void setX(double min, double max) {
		if (min <= max) {
			this.minxProperty.set(min);
			this.maxxProperty.set(max);
		} else {
			this.minxProperty.set(max);
			this.maxxProperty.set(min);
		}
	}
769934
@Override
	public void setY(double min, double max) {
		if (min <= max) {
			this.minyProperty.set(min);
			this.maxyProperty.set(max);
		} else {
			this.minyProperty.set(max);
			this.maxyProperty.set(min);
		}
	}
418669
@Override
    public void merge(ROCMultiClass other) {
        if (this.underlying == null) {
            this.underlying = other.underlying;
            return;
        } else if (other.underlying == null) {
            return;
        }

        //Both have data
        if (underlying.length != other.underlying.length) {
            throw new UnsupportedOperationException("Cannot merge ROCBinary: this expects " + underlying.length
                            + "outputs, other expects " + other.underlying.length + " outputs");
        }
        for (int i = 0; i < underlying.length; i++) {
            this.underlying[i].merge(other.underlying[i]);
        }
    }
1100121
void merge(final long key, final double[] values) {
    setNotEmpty();
    if (key < theta_) {
      final int index = findOrInsertKey(key);
      if (index < 0) {
        incrementCount();
        setValues(~index, values);
      } else {
        updateValues(index, values);
      }
      rebuildIfNeeded();
    }
  }
1281831
def _merge_default_values(self):
        """"""
        values = self._get_default_values()
        for key, value in values.items():
            if not self.data.get(key):
                self.data[key] = value
1063475
public void setDamages(int min, int max)
    {
        this.min = UtilMath.clamp(min, 0, Integer.MAX_VALUE);
        this.max = UtilMath.clamp(max, this.min, Integer.MAX_VALUE);
    }
446979
@Override
	public void merge(MinMaxHolder another){
		BigInteger anotherMin = toBigInteger(another.getMin());
		if (anotherMin != null){
			evaluate(anotherMin);
		}
		BigInteger anotherMax = toBigInteger(another.getMax());
		if (anotherMax != null){
			evaluate(anotherMax);
		}
	}
859320
public void mergeResults(LrJobResults resultFiles)
    {
        for(JobLrScenarioResult scenarioResult : resultFiles.getLrScenarioResults().values())
        {
            this._resultFiles.addScenario(scenarioResult);
        }
    }
295174
public void setMax(java.lang.Object _max) {
		getStateHelper().put(PropertyKeys.max, _max);
	}
136627
public boolean merge(AbstractTransition another) {
        if (!isCompatible(another)) {
            return false;
        }
        if (another.mId != null) {
            if (mId == null) {
                mId = another.mId;
            } else {
                StringBuilder sb = new StringBuilder(mId.length() + another.mId.length());
                sb.append(mId);
                sb.append("_MERGED_");
                sb.append(another.mId);
                mId = sb.toString();
            }
        }
        mUpdateStateAfterUpdateProgress |= another.mUpdateStateAfterUpdateProgress;
        mSetupList.addAll(another.mSetupList);
        Collections.sort(mSetupList, new Comparator<S>() {
            @Override
            public int compare(S lhs, S rhs) {
                if (lhs instanceof AbstractTransitionBuilder && rhs instanceof AbstractTransitionBuilder) {
                    AbstractTransitionBuilder left = (AbstractTransitionBuilder) lhs;
                    AbstractTransitionBuilder right = (AbstractTransitionBuilder) rhs;
                    float startLeft = left.mReverse ? left.mEnd : left.mStart;
                    float startRight = right.mReverse ? right.mEnd : right.mStart;
                    return (int) ((startRight - startLeft) * 1000);
                }
                return 0;
            }
        });

        return true;
    }