Invert the transform.

        After calling this method, calling the instance will do the inverse
        transform. Calling this twice return the instance to the original
        transform.
177044
def inv(self):
        

        self.x, self.y = self.y, self.x
        self._x_, self._y_ = self._y_, self._x_
        self.xfac, self.yfac = 1 / self.yfac, 1 / self.xfac
        self._xfac_, self._yfac_ = 1 / self._yfac_, 1 / self._xfac_
        self._u = 1 / self._u.conj()
1340502
public void inverse (double data[], int i0, int stride) {
    backtransform(data, i0, stride);

  /* normalize inverse fft with 1/n */
    double norm = normalization();
    for (int i = 0; i < n; i++) {
      data[i0+stride*i]   *= norm;
      data[i0+stride*i+1] *= norm; }}
711797
def inverse(self):
        
        result = G2Element()
        librelic.g2_neg_abi(byref(result), byref(self))
        return result
847501
@Override
    public Object transform( Object input ) {

        // Wrap the input in a map to fool the CompositeSpec to recurse itself.
        Map<String,Object> wrappedMap = new HashMap<>();
        wrappedMap.put(ROOT_KEY, input);
        rootSpec.applyToMap( wrappedMap );
        return input;
    }
382194
def inverse(self):
        
        inv_rotation = self.rotation.T
        inv_translation = np.dot(-self.rotation.T, self.translation)
        return RigidTransform(inv_rotation, inv_translation,
                              from_frame=self._to_frame,
                              to_frame=self._from_frame)
379966
def get_transform(self):
        
        return self.aux_transform + \
            self.ref_offset_transform + \
            self.dpi_transform + \
            self.offset_transform
166805
public final void inverse() {
		double norm;  

		norm = 1f/(this.w*this.w + this.x*this.x + this.y*this.y + this.z*this.z);
		this.w *=  norm;
		this.x *= -norm;
		this.y *= -norm;
		this.z *= -norm;
	}
678982
def inverse(self):
        
        return OperatorComp(self.right.inverse, self.left.inverse,
                            self.__tmp)
393543
def inverse(self):
        """"""
        sign = '-' if self.sign == '+' else '+'
        return DiscreteFourierTransform(
            domain=self.range, range=self.domain, axes=self.axes,
            halfcomplex=self.halfcomplex, sign=sign)
561839
function Invert()
    {
        $this->r = 0xff - $this->r;
        $this->g = 0xff - $this->g;
        $this->b = 0xff - $this->b;
    }
380349
@Override
	protected void doTransform(ITransformable.Scale transformable, float comp)
	{
		float fromX = reversed ? this.toX : this.fromX;
		float toX = reversed ? this.fromX : this.toX;
		float fromY = reversed ? this.toY : this.fromY;
		float toY = reversed ? this.fromY : this.toY;
		float fromZ = reversed ? this.toZ : this.fromZ;
		float toZ = reversed ? this.fromZ : this.toZ;

		transformable.scale(fromX + (toX - fromX) * comp, fromY + (toY - fromY) * comp, fromZ + (toZ - fromZ) * comp, offsetX, offsetY,
				offsetZ);
	}
927375
@Override
  public IVersionRange invert() {
    IVersionRange irange1 = range1.invert();
    IVersionRange irange2 = range2.invert();
    return new OrRange(irange1, irange2);
  }
1342904
@Override
	public ParallelTransformation reversed(boolean reversed)
	{
		if (!reversed)
			return this;

		for (Transformation<?, ?> transformation : listTransformations)
			transformation.reversed(true);

		return this;
	}
537450
public void transform(Tuple2D<?> tuple) {
		assert tuple != null : AssertMessages.notNullParameter();
		final double x = this.m00 * tuple.getX() + this.m01 * tuple.getY() + this.m02;
		final double y = this.m10 * tuple.getX() + this.m11 * tuple.getY() + this.m12;
		tuple.set(x, y);
	}
395700
def invert(a, b):
    
    if HAVE_GMP:
        s = int(gmpy2.invert(a, b))
        # according to documentation, gmpy2.invert might return 0 on
        # non-invertible element, although it seems to actually raise an
        # exception; for consistency, we always raise the exception
        if s == 0:
            raise ZeroDivisionError('invert() no inverse exists')
        return s
    else:
        r, s, _ = extended_euclidean_algorithm(a, b)
        if r != 1:
            raise ZeroDivisionError('invert() no inverse exists')
        return s % b
1284683
def _invert(self):
        
        result = defaultdict(dict)
        for test_context, src_context in six.iteritems(self.data):
            for src, lines in six.iteritems(src_context):
                result[src][test_context] = lines
        return result
764387
def _invertMapping(mapping):
    
    invertedMapping = ddict(set)
    for key, values in viewitems(mapping):
        for value in values:
            invertedMapping[value].add(key)
    return invertedMapping