Divide an image, constant or array.

 @param other [Image, Real, Array<Real>] Thing to divide self by
 @return [Image] result of division
485001
def / other
      other.is_a?(Vips::Image) ?
          divide(other) : linear(Image::smap(other) {|x| 1.0 / x}, 0)
    end
1114466
def dock(self, other):
		'''
			
		'''
		if other.multiplicand != self.multiplicand:
			raise Exception("Can't subtract " + repr(other) + " from " + repr(self))
		return mult(self.multiplicand, self.multiplier - other.multiplier)
952905
def symmetric_difference(other)
      if other.is_a?(RelativeComplement)
        # A ⊖ ~B = (A ∖ ¬B) | (¬B ∖ A)
        #        = (A ∩ B)  | (¬B ∩ ¬A)
        #        = (B ∖ ¬A) | (¬A ∖ B)
        #        = ~A ⊖ B
        intersection(other.complement).
          union(other.intersection(complement))
      else
        # A ⊖ B = (A ∖ B) | (B ∖ A)
        #       = (A ∪ B) - (A ∩ B)
        other = Cantor.build(other)

        if other.empty?
          self
        else
          union(other).difference(intersection(other))
        end
      end
    end
1299290
def paste(self, other):
        
        r, g, b, alpha = other.pil_image.split()
        pil_image = self.pil_image.copy()
        pil_image.paste(other.pil_image, mask=alpha)
        return kurt.Image(pil_image)
921757
def coerce(other)
      return [other.to_unit, self] if other.respond_to? :to_unit
      case other
      when Unit
        [other, self]
      else
        [RubyUnits::Unit.new(other), self]
      end
    end
275542
@SafeVarargs
  public static <T> RubyArray<T> p(T first, T... others) {
    RubyArray<T> ra = new RubyArray<>();
    out.print("[");
    ra.add(p(first, false));
    Arrays.asList(others).forEach(item -> {
      out.print(", ");
      ra.add(p(item, false));
    });
    out.print("]");
    out.println();
    return ra;
  }
858716
def divide(x1, x2, output_shape=None, name=None):
  
  output_shape = convert_to_shape(output_shape)
  if not isinstance(x2, Tensor):
    return ScalarMultiplyOperation(x1, 1.0 / x2).outputs[0]
  with tf.name_scope(name, default_name="divide"):
    x1, x2 = binary_arguments_to_tensors(x1, x2)
    return multiply(x1, reciprocal(x2), output_shape=output_shape)
503942
public void set(Tensor other) {
        checkEqualSize(this, other);
        this.dims = IntArrays.copyOf(other.dims);
        DoubleArrays.copy(other.values, this.values);
    }
41257
public static void divide(double[] array1, double[] array2) {
        assert (array1.length == array2.length);
        for (int i=0; i<array1.length; i++) {
            array1[i] /= array2[i];
        }
    }
727960
def %(other)
      if Duration === other || Scalar === other
        Duration.build(value % other.value)
      elsif Numeric === other
        Duration.build(value % other)
      else
        raise_type_error(other)
      end
    end
479521
def difference(self, other):
        
        diff = (tuple(set(self.plates) - set(other.plates)), tuple(set(other.plates) - set(self.plates)))
        counts = map(len, diff)
        # is_sub_plate = counts == [1, 1] and diff[1][0].is_sub_plate(diff[0][0])
        is_sub_plate = counts == [1, 1] and diff[0][0].is_sub_plate(diff[1][0])  # MK fixed
        if len(other.plates) == 1 and counts == [1, 0] and diff[0][0].parent == other.plates[0].parent:
            is_sub_plate = True
        return diff, counts, is_sub_plate
1346117
def value_left(self, other):
    
    return other.value if isinstance(other, self.__class__) else other
480619
public AABBd union(AABBd other, AABBd dest) {
        dest.minX = this.minX < other.minX ? this.minX : other.minX;
        dest.minY = this.minY < other.minY ? this.minY : other.minY;
        dest.minZ = this.minZ < other.minZ ? this.minZ : other.minZ;
        dest.maxX = this.maxX > other.maxX ? this.maxX : other.maxX;
        dest.maxY = this.maxY > other.maxY ? this.maxY : other.maxY;
        dest.maxZ = this.maxZ > other.maxZ ? this.maxZ : other.maxZ;
        return dest;
    }
876026
def split_image(self, split_len):
        
        result = copy.copy(self)
        result.data = self.data[:split_len]
        self.data = self.data[split_len:]
        self.addr += split_len
        self.file_offs = None
        result.file_offs = None
        return result
1246600
def *(other)
      if other.is_a?(InternalComplex) or other.is_a?(Complex)
        InternalComplex.new @real * other.real - @imag * other.imag,
                    @real * other.imag + @imag * other.real
      elsif InternalComplex.generic? other
        InternalComplex.new @real * other, @imag * other
      else
        x, y = other.coerce self
        x * y
      end
    end
843585
def common(self, other):
		'''
			
		'''
		if self.multiplicand == other.multiplicand:
			return mult(self.multiplicand, self.multiplier.common(other.multiplier))

		# Multiplicands disagree, no common part at all.
		return mult(nothing, zero)
1080633
public function lt($other)
    {
        if (!($other instanceof self)) {
            $other = new BigInt($other);
        }
        return ($this->compare($other) < 0);
    }