Static factory method for wrapping a value of type <code>B</code> in a {@link These}.

@param b   the value
@param <A> the first possible type
@param <B> the second possible type
@return the wrapped value as a <code>{@link These}&lt;A,B&gt;</code>
484086
public static <A, B> These<A, B> b(B b) {
        return new _B<>(b);
    }
540080
public IMatrix add(IMatrix b) {
        IMatrix result = new IMatrix(rows, columns);
        add(b, result);
        return result;
    }
716247
function (b) {
            b = b.val;
            var a = this.val,
                a0 = a[0],
                a1 = a[1],
                a3 = a[3],
                a4 = a[4],
                b0 = b[0],
                b1 = b[1],
                b3 = b[3],
                b4 = b[4],
                b6 = b[6],
                b7 = b[7];

            a[0] = a0 * b0 + a3 * b1;
            a[1] = a1 * b0 + a4 * b1;
            a[3] = a0 * b3 + a3 * b4;
            a[4] = a1 * b3 + a4 * b4;
            a[6] += a0 * b6 + a3 * b7;
            a[7] += a1 * b6 + a4 * b7;

            return this;
        }
35525
public IVector mul(double b) {
        IVector result = new IVector(size);
        mul(b, result);
        return result;
    }
210078
public static <T1 extends Serializable, T2 extends Serializable> Pair<T1, T2> next(T1 a, T2 b) {
    return new Pair<>(a, b);
  }
79259
public Vector4f fma(Vector4fc a, Vector4fc b) {
        return fma(a, b, thisOrNew());
    }
715981
public static <A, B> Pair<A, B> pair(
    final A left,
    final B right)
  {
    return new Pair<A, B>(left, right);
  }
917481
public Vector sub(Vector b) {
        if ((b == null) || (size != b.size)) return null;

        int i;
        Vector result = new Vector(size);
        for (i = 0; i < size; i++)
            result.vector[i] = vector[i] - b.vector[i];
        return result;
    }
713502
public static Vector4f fromIntRGBA(int r, int g, int b, int a) {
        return new Vector4f((r & 0xff) / 255f, (g & 0xff) / 255f, (b & 0xff) / 255f, (a & 0xff) / 255f);
    }
1214887
def b=(value)
      if typecode < RGB_
        decompose( 2 )[] = value
      elsif typecode == OBJECT
        self[] = Hornetseye::lazy do
          r * RGB.new( 1, 0, 0 ) + g * RGB.new( 0, 1, 0 ) + value * RGB.new( 0, 0, 1 )
        end
      else
        raise "Cannot assign blue channel to elements of type #{typecode.inspect}"
      end
    end
487266
public MessageAttributeValue withBinaryListValues(java.util.Collection<java.nio.ByteBuffer> binaryListValues) {
        setBinaryListValues(binaryListValues);
        return this;
    }
56492
private Object wrap(final Object value) {

		if (value instanceof Map) {

			return new MapResultWrapper(db, (Map)value);
		}

		if (value instanceof Collection) {

			return wrap((Collection)value);
		}

		return wrapper.apply(value);
	}
105525
public static String toHex(byte b) {
      StringBuilder sb = new StringBuilder();
      appendByteAsHex(sb, b);
      return sb.toString();
   }
931564
public static String byteArrayToHexString(byte[] b) {
       StringBuilder resultSb = new StringBuilder();
       for (byte aB : b) {
           resultSb.append(byteToHexString(aB));
       }
       return resultSb.toString();
   }
635471
public static TypeOfAddress valueOf(byte b) {
        // bits 0-3 are the ton (shift over 0, then only the first 4 bits)
        int ton = (b & 0x0F);
        // bits 4-7 are the npi (shift over 4, then only the first 3 bits)
        int npi = ((b >> 4) & 0x07);
        // create our type of address now
        return new TypeOfAddress(Ton.fromInt(ton), Npi.fromInt(npi));
    }
668502
public Tags merge(Tags other) {
    // Dereference "other" first as a null pointer check so we cannot risk returning null later.
    if (other.isEmpty()) {
      return this;
    }
    if (this.isEmpty()) {
      return other;
    }
    SortedMap<String, SortedSet<Object>> merged = new TreeMap<String, SortedSet<Object>>();
    for (Map.Entry<String, SortedSet<Object>> e : map.entrySet()) {
      SortedSet<Object> otherValues = other.map.get(e.getKey());
      if (otherValues == null || e.getValue().containsAll(otherValues)) {
        // Our values are a superset of the values in the other map, so just use them.
        merged.put(e.getKey(), e.getValue());
      } else if (otherValues.containsAll(e.getValue())) {
        // The other map's values are a superset of ours, so just use them.
        merged.put(e.getKey(), otherValues);
      } else {
        // Values exist in both maps and neither is a superset, so we really must merge.
        SortedSet<Object> mergedValues = new TreeSet<Object>(e.getValue());
        mergedValues.addAll(otherValues);
        merged.put(e.getKey(), Collections.unmodifiableSortedSet(mergedValues));
      }
    }
    for (Map.Entry<String, SortedSet<Object>> e : other.map.entrySet()) {
      // Finally add those values that were only in the other map.
      if (!map.containsKey(e.getKey())) {
        merged.put(e.getKey(), e.getValue());
      }
    }
    return new Tags(Collections.unmodifiableSortedMap(merged));
  }
1167315
public static Buffer wrap(final int value) {
        final int size = value < 0 ? stringSize(-value) + 1 : stringSize(value);
        final byte[] bytes = new byte[size];
        getBytes(value, size, bytes);
        return new ByteBuffer(bytes);
    }