Divides the line into two at requested `ratio` between 0 and 1.
170618
function(ratio) {

        var dividerPoint = this.pointAt(ratio);

        // return array with two new lines
        return [
            new Line(this.start, dividerPoint),
            new Line(dividerPoint, this.end)
        ];
    }
191323
def split(self, t):
        """"""
        pt = self.point(t)
        return Line(self.start, pt), Line(pt, self.end)
1354032
def split(line, lines):
    
    out = empty((len(lines) + 1, 4))

    p1 = line[:2]
    for n, l2 in enumerate(lines):
        p2 = intersection(line, l2)
        out[n][:2] = p1
        out[n][2:] = p2
        p1 = p2
    out[n + 1][:2] = p2
    out[n + 1][2:] = line[2:]
    return out
838061
public PackedDecimal divide(PackedDecimal operand) {
        if (this.isBruch() || operand.isBruch()) {
            return divide(operand.toBruch());
        } else {
            return divide(operand.toBigDecimal());
        }
    }
189793
static int divide(Slice decimal, int divisor, Slice result)
    {
        if (divisor == 0) {
            throwDivisionByZeroException();
        }
        checkArgument(divisor > 0);

        long remainder = getLong(decimal, 1);
        long high = remainder / divisor;
        remainder %= divisor;

        remainder = (getInt(decimal, 1) & LONG_MASK) + (remainder << 32);
        int z1 = (int) (remainder / divisor);
        remainder %= divisor;

        remainder = (getInt(decimal, 0) & LONG_MASK) + (remainder << 32);
        int z0 = (int) (remainder / divisor);

        pack(result, z0, z1, high, isNegative(decimal));
        return (int) (remainder % divisor);
    }
755636
static void divide(Slice dividend, int dividendScaleFactor, Slice divisor, int divisorScaleFactor, Slice quotient, Slice remainder)
    {
        divide(getRawLong(dividend, 0), getRawLong(dividend, 1), dividendScaleFactor, getRawLong(divisor, 0), getRawLong(divisor, 1), divisorScaleFactor, quotient, remainder);
    }
211330
def split_input_output(self, text):
        """"""
        lines = _to_lines(text)
        i = 0
        for line in lines:
            if _starts_with_regex(line, self.input_prompt_regex):
                i += 1
            else:
                break
        return lines[:i], lines[i:]
1104896
function(ratio, opt) {

        if (ratio <= 0) return this.divideAtT(0);
        if (ratio >= 1) return this.divideAtT(1);

        var t = this.tAt(ratio, opt);

        return this.divideAtT(t);
    }
774074
def _divide(self, x1, x2, out):
        """"""
        self.tspace._divide(x1.tensor, x2.tensor, out.tensor)
1204061
@Transformer
    public static String[] divide(Object o, String sep) {
        return str(o).split(sep);
    }
1095347
def divide(self, other, out=None):
        
        return self.space.divide(self, other, out=out)
826704
def split_by_value( total, nodes, headdivisor=2.0 ):
    """"""
    head_sum,tail_sum = 0,0
    divider = 0
    for node in nodes[::-1]:
        if head_sum < total/headdivisor:
            head_sum += node[0]
            divider -= 1
        else:
            break
    return (head_sum,nodes[divider:]),(total-head_sum,nodes[:divider])
136579
function (line, dist) {
        var sum = 0;

        if (dist <= 0) return line[0];

        for (var i = 0; i < line.length - 1; i++) {
            var p0 = line[i];
            var p1 = line[i + 1];
            var d = this.distance(p0, p1);
            sum += d;
            if (sum > dist) return interpolate(p0, p1, (dist - (sum - d)) / d);
        }

        return line[line.length - 1];
    }
830056
function divide(bit) {
  var bitString = ((zeros + zeros) + (Number(bit).toString(2))).slice(-64);

  return [
    parseInt(bitString.slice(0, 32), 2), // hi
    parseInt(bitString.slice(-32), 2) // lo
  ];
}
597803
def div(a, b):
  
  def divide(a, b):
    """Division"""
    return a / b
  return op_with_scalar_cast(a, b, divide)
904096
function(ratio, opt) {

            if (ratio <= 0) return this.start.clone();
            if (ratio >= 1) return this.end.clone();

            var t = this.tAt(ratio, opt);

            return this.pointAtT(t);
        }
118638
def _prf_divide(numerator, denominator):
    
    result = numerator / denominator
    mask = denominator == 0.0
    if not mask.any():
        return result

    # remove nan
    result[mask] = 0.0
    return result