Combines {@code tint} with the current tint via {@link Tint#combine}.
@return the tint prior to combination.
182279
public int combineTint (int tint) {
    int otint = this.tint;
    if (tint != Tint.NOOP_TINT) this.tint = Tint.combine(tint, otint);
    return otint;
  }
627975
static PorterDuffColorFilter updateTintFilter(Drawable drawable, PorterDuffColorFilter tintFilter, ColorStateList tint,
                                                PorterDuff.Mode tintMode) {
    if (tint == null || tintMode == null) {
      return null;
    }

    final int color = tint.getColorForState(drawable.getState(), Color.TRANSPARENT);

    if (tintFilter == null || !LOLLIPOP_PLUS) { // TODO worth caching them?
      return new PorterDuffColorFilter(color, tintMode);
    }

    tryInvoke(tintFilter, "setColor", INT_ARG, color);
    tryInvoke(tintFilter, "setMode", MODE_ARG, tintMode);
    return tintFilter;
  }
318257
public JMListMap<K, V> merge(JMListMap<K, V> jmListMap) {
        jmListMap.forEach(this::addAll);
        return this;
    }
1050737
@SuppressWarnings("rawtypes")
	public static CompoundPainter getCompoundPainter(final Color color,
		final GlossPainter.GlossPosition position, final double angle)
	{
		final MattePainter mp = new MattePainter(color);
		final GlossPainter gp = new GlossPainter(color, position);
		final PinstripePainter pp = new PinstripePainter(color, angle);
		final CompoundPainter compoundPainter = new CompoundPainter(mp, pp, gp);
		return compoundPainter;

	}
512456
public static Style cyan() {
        final Style style = new Style();
        style.color = PaletteUtils.getSolidColor(PaletteUtils.MATERIAL_CYAN);
        return style;
    }
38931
public Optional<E> getPrevious() {
        return Optional.of(currentIndex).filter(getGreater(0))
                .map(i -> linkedList.get(--currentIndex));
    }
1081587
public static IConjunct simplify( IConjunct conjunct)
    {
    return
      conjunct.getDisjunctCount() == 1
      ? conjunct.getDisjuncts().next()
      : conjunct;
    }
918621
@Override
    public int[] vertexColor() {
        int[] result = colors;
        if (result == null) {
            synchronized (this) {
                result = colors;
                if (result == null) {
                    colors = result = buildVertexColor();
                }
            }
        }
        return result;
    }
803031
public CombineOutput combine(final List<ShareInfo> usetheseshares)
    {
        CombineOutput ret = null;

        sanityCheckPublicInfos(publicInfo, usetheseshares);

        if (true)
        {
            println(" SOLVING USING THESE SHARES, mod=" + publicInfo.getPrimeModulus());
            for (ShareInfo si : usetheseshares)
            {
                println("   " + si.share);
            }
            println("end SOLVING USING THESE SHARES");
        }
        if (publicInfo.getK() > usetheseshares.size())
        {
            throw new SecretShareException("Must have " + publicInfo.getK() +
                                           " shares to solve.  Only provided " +
                                           usetheseshares.size());
        }

        checkForDuplicatesOrThrow(usetheseshares);


        final int size = publicInfo.getK();
        BigInteger[] xarray = new BigInteger[size];
        BigInteger[] fofxarray = new BigInteger[size];
        for (int i = 0, n = size; i < n; i++)
        {
            xarray[i] = usetheseshares.get(i).getXasBigInteger();
            fofxarray[i] = usetheseshares.get(i).getShare();
        }
        EasyLinearEquation ele =
            EasyLinearEquation.createForPolynomial(xarray, fofxarray);
        if (publicInfo.getPrimeModulus() != null)
        {
            ele = ele.createWithPrimeModulus(publicInfo.getPrimeModulus());
        }

        BigInteger solveSecret = null;

        if (false)
        {
            EasyLinearEquation.EasySolve solve = ele.solve();

            solveSecret = solve.getAnswer(1);
        }
        else
        {
            BigInteger[][] matrix = ele.getMatrix();
            NumberMatrix.print("SS.java", matrix, out);
            println("CVT matrix.height=" + matrix.length + " width=" + matrix[0].length);
            BigRationalMatrix brm = BigRationalMatrix.create(matrix);
            NumberMatrix.print("SS.java brm", brm.getArray(), out);

            NumberSimplex<BigRational> simplex = new NumberSimplex<BigRational>(brm, 0);
            simplex.initForSolve(out);
            simplex.solve(out);

            BigRational answer = simplex.getAnswer(0);
            if (publicInfo.getPrimeModulus() != null)
            {
                solveSecret = answer.computeBigIntegerMod(publicInfo.getPrimeModulus());
            }
            else
            {
                solveSecret = answer.bigIntegerValue();
            }
        }

        if (publicInfo.getPrimeModulus() != null)
        {
            solveSecret = solveSecret.mod(publicInfo.getPrimeModulus());
        }
        ret = new CombineOutput(solveSecret);


        return ret;
    }
435662
public final T build() {
        T dialog = buildDialog();
        if(!extraWindowHints.isEmpty()) {
            Set<Window.Hint> combinedHints = new HashSet<Window.Hint>(dialog.getHints());
            combinedHints.addAll(extraWindowHints);
            dialog.setHints(combinedHints);
        }
        return dialog;
    }
1323904
public static Bitmap processTintTransformationMap(Bitmap transformationMap, int tintColor) {
		// tint color
		int[] t = new int[] {
				Color.red(tintColor),
				Color.green(tintColor),
				Color.blue(tintColor) };
		
		int width = transformationMap.getWidth();
		int height = transformationMap.getHeight();
		int[] pixels = new int[width * height];
		transformationMap.getPixels(pixels, 0, width, 0, 0, width, height);
		
		float[] transformation = new float[2];
		
		for (int i=0; i<pixels.length; i++) {
			int color = pixels[i];
			int alpha = Color.alpha(color);
			transformation[0] = Color.red(color) / 255f;
			transformation[1] = Color.green(color) / 255f;
			pixels[i] = applyTransformation(t, alpha, transformation);
		}
		return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888);
	}
416117
public static BindFuture combineFutures(BindFuture future1, BindFuture future2) {
        if (future1 == null || future1.isBound()) {
            return future2;
        }
        else if (future2 == null || future2.isBound()) {
            return future1;
        }
        else {
            return new CompositeBindFuture(Arrays.asList(future1, future2));
        }
    }
265457
public Variant merge(Variant current, Variant load) {
        return merge(current, Collections.singleton(load));
    }
351835
public HSBColor getComplementaryColor() {
        double[] rgb = HSBColor.getRGB(hue, saturation, brightness);
        double[] hsb = HSBColor.getHSB(1.0 - rgb[0], 1.0 - rgb[1], 1.0 - rgb[2]);
        return new HSBColor(hsb[0], hsb[1], hsb[2]);
    }
398417
public TypeMetadata combineAll(TypeMetadata other) {
        Assert.checkNonNull(other);

        TypeMetadata out = new TypeMetadata();
        Set<Entry.Kind> keys = new HashSet<>(contents.keySet());
        keys.addAll(other.contents.keySet());

        for(Entry.Kind key : keys) {
            if (contents.containsKey(key)) {
                if (other.contents.containsKey(key)) {
                    out.add(key, contents.get(key).combine(other.contents.get(key)));
                } else {
                    out.add(key, contents.get(key));
                }
            } else if (other.contents.containsKey(key)) {
                out.add(key, other.contents.get(key));
            }
        }
        return out;
    }
625080
private PorterDuffColorFilter createTintFilter(ColorStateList tint, PorterDuff.Mode tintMode) {
        if (tint == null || tintMode == null) {
            return null;
        }
        final int color = tint.getColorForState(getState(), Color.TRANSPARENT);
        return new PorterDuffColorFilter(color, tintMode);
    }
964696
public void prepare (int tint, AffineTransform xf) {
    prepare(tint, xf.m00, xf.m01, xf.m10, xf.m11, xf.tx, xf.ty);
  }