Applies the UNIT rule to 'g' (see top comment).
482458
def _unit(g):
    """"""
    nt_unit_rule = get_any_nt_unit_rule(g)
    while nt_unit_rule:
        g = _remove_unit_rule(g, nt_unit_rule)
        nt_unit_rule = get_any_nt_unit_rule(g)
    return g
438052
def units(self, val):
        """"""
        if isinstance(val, units.Unit):
            self._unit = val
        else:
            self._unit = units(val)
293593
private void  g(Attributes attributes) throws SVGParseException
   {
      debug("<g>");

      if (currentElement == null)
         throw new SVGParseException("Invalid document. Root element must be <svg>");
      SVG.Group  obj = new SVG.Group();
      obj.document = svgDocument;
      obj.parent = currentElement;
      parseAttributesCore(obj, attributes);
      parseAttributesStyle(obj, attributes);
      parseAttributesTransform(obj, attributes);
      parseAttributesConditional(obj, attributes);
      currentElement.addChild(obj);
      currentElement = obj;
   }
97993
def apply_mana_drain(self):
        """"""
        self.r = self.g = self.b = self.y = 0
1151471
def _calc_g(w, aod700):
    """"""

    g = -0.0147*np.log(w) - 0.3079*aod700**2 + 0.2846*aod700 + 0.3798

    return g
1013421
public static void unitize2(double[] x) {
        double n = norm(x);

        for (int i = 0; i < x.length; i++) {
            x[i] /= n;
        }
    }
1294957
def toggle(self):
        
        r, g, b = self.value
        self.value = (1 - r, 1 - g, 1 - b)
485875
def set_bfield(self, B_G):
        
        if not (B_G > 0):
            raise ValueError('must have B_G > 0; got %r' % (B_G,))

        self.in_vals[IN_VAL_B] = B_G
        return self
374609
function(r, g,b) {
		return this.setRGB([this.rgb[0] + r, this.rgb[1] + g, this.rgb[2] + b]);
	}
98077
def _ge_from_lt(self, other):
    """"""
    op_result = self.__lt__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result
267709
private void set(Unit unit, Rational rational, Unit base, boolean replace) {
    Map<Unit, UnitFactor> map = factors.get(unit);
    if (map == null) {
      map = new EnumMap<>(Unit.class);
      factors.put(unit, map);
    }
    if (replace || !map.containsKey(base)) {
      map.put(base,  new UnitFactor(rational, base));
    }
  }
363199
def obfn_g(self, Y):
        
        """

        return self.obfn_g0(self.obfn_g0var()) + \
            self.obfn_g1(self.obfn_g1var())
461778
private int applyFog( int rgb , float fraction ) {
		// avoid floating point math
		int adjustment = (int)(1000*fraction);

		int r = (rgb >> 16)&0xFF;
		int g = (rgb >> 8)&0xFF;
		int b = rgb & 0xFF;

		r = (r * adjustment + ((backgroundColor>>16)&0xFF)*(1000-adjustment)) / 1000;
		g = (g * adjustment + ((backgroundColor>>8)&0xFF)*(1000-adjustment)) / 1000;
		b = (b * adjustment + (backgroundColor&0xFF)*(1000-adjustment)) / 1000;

		return (r << 16) | (g << 8) | b;
	}
1279954
private static void putConvertion( HashMap<String, Double> group, String unit, double factor ) {
        UNIT_CONVERSIONS.put(unit, group );
        group.put( unit, factor );
    }
23973
public void enter(Permutation g) {
        int deg = size;
        int i = test(g);
        if (i == deg) {
            return;
        } else {
            permutations[i][g.get(base.get(i))] = new Permutation(g);
        }

        for (int j = 0; j <= i; j++) {
            for (int a = 0; a < deg; a++) {
                Permutation h = permutations[j][a];
                if (h != null) {
                    Permutation f = g.multiply(h);
                    enter(f);
                }
            }
        }
    }
411042
def L(g,i):
    """"""
    g1 = g&(2**i)
    if i:
        n = Lwidth(i)
        Ln = L(g,i-1)
        if g1:
            return Ln<<(2*n)           | Ln<<n | Ln
        else:
            return int('1'*n,2)<<(2*n) | Ln<<n | Ln
    else:
        if g1:
            return int('000',2)
        else:
            return int('100',2)
343163
def _g(self, x, tau):
        
        return tau ** 2 * (tau ** 2 + 1) ** -2 * (
                (tau ** 2 + 1 + 2 * (x ** 2 - 1)) * self.F(x) + tau * np.pi + (tau ** 2 - 1) * np.log(tau) +
                np.sqrt(tau ** 2 + x ** 2) * (-np.pi + self.L(x, tau) * (tau ** 2 - 1) * tau ** -1))