← NumPy: arrays and numerical computing Progress & review ↗

Typorithm · medium

Safe ufunc division with out and where

pythonnumpynumerical-computingindependent-practice

Saved on this device

Full lesson · 4 learning steps Open any exercise for focused practice

Step 1 of 4 · intro card

Safe ufunc division with out and where

Concept and contract

Avoid invalid arithmetic by controlling where the ufunc executes and initializing every output position.

A universal function applies a numerical operation over array elements with broadcasting support. Its where argument controls which positions the operation computes. Its out argument supplies a destination buffer. These features allow a division contract that produces one finite output per input position, including an explicit fallback for zero denominators.

This is different from selecting already-computed results with np.where. Python evaluates arguments before calling a function, so top / bottom is evaluated even when a later where expression intends to discard its invalid elements. Preventing an invalid operation requires controlling the numerical operation itself, not merely its displayed result.

Mechanism and worked example

The worked function validates aligned one-dimensional finite arrays.

The worked function validates aligned one-dimensional finite arrays. It creates an output initialized to zero and calls np.divide with out=result and where=bottom != 0. Positions with nonzero denominators are computed, while zero-denominator positions retain their initialized fallback. The lab treats unexpected RuntimeWarnings as failures, so a quiet-looking output cannot conceal invalid arithmetic performed along the way.

This contract is deliberately elementwise and shape-preserving. A zero numerator with a valid denominator produces a valid zero result. A zero denominator invokes the fallback even when the numerator is also zero. Keep those cases distinct when explaining the mask.

Complete worked example

python

import numpy as np

def inspect_example(numerators, denominators):
    top = np.asarray(numerators, dtype=np.float64)
    bottom = np.asarray(denominators, dtype=np.float64)
    if top.ndim != 1 or top.shape != bottom.shape:
        raise ValueError("expected aligned vectors")
    if not np.isfinite(top).all() or not np.isfinite(bottom).all():
        raise ValueError("expected finite values")
    result = np.zeros_like(top)
    np.divide(top, bottom, out=result, where=bottom != 0)
    return result

Reasoning: The worked function validates aligned one-dimensional finite arrays. It creates an output initialized to zero and calls np.divide with out=result and where=bottom != 0. Positions with nonzero denominators are computed, while zero-denominator positions retain their initialized fallback. The lab treats unexpected RuntimeWarnings as failures, so a quiet-looking output cannot conceal invalid arithmetic performed along the way. This contract is deliberately elementwise and shape-preserving. A zero numerator with a valid denominator produces a valid zero result. A zero denominator invokes the fallback even when the numerator is also zero. Keep those cases distinct when explaining the mask.

Open in local Python playground ↗

Focused decision: context is in the complete example

python

result = np.zeros_like(top)
np.divide(top, bottom, out=result, where=bottom != 0)

Focused decision: Type this short numerical decision after reading its complete context. The complete imports, array construction, validation, and result checks remain in the worked example. Typing records practice; only the downloadable computer lab executes Python.

Counterexamples and common mistakes

The controlled counterexample divides first inside np.where.

The controlled counterexample divides first inside np.where. It may return the desired fallback values but still performs division by zero and emits an invalid or divide warning. Another mistake is passing an uninitialized empty output with a partial where mask; untouched positions then have no promised value. Suppressing all warnings also does not establish a valid numerical contract.

Checking only denominator != 0 does not prevent every possible floating-point overflow. The input range in these small fixtures is bounded, and production ratios may need additional magnitude checks. State that limitation rather than presenting one mask as a complete numerical safety policy.

Controlled mistake: inspect the failing numerical contract

python

import numpy as np

def inspect_example(numerators, denominators):
    top = np.asarray(numerators, dtype=np.float64)
    bottom = np.asarray(denominators, dtype=np.float64)
    if top.ndim != 1 or top.shape != bottom.shape:
        raise ValueError("expected aligned vectors")
    if not np.isfinite(top).all() or not np.isfinite(bottom).all():
        raise ValueError("expected finite values")
    result = np.zeros_like(top)
    result = np.where(bottom != 0, top / bottom, 0.0)
    return result

Reasoning: The controlled counterexample divides first inside np.where. It may return the desired fallback values but still performs division by zero and emits an invalid or divide warning. Another mistake is passing an uninitialized empty output with a partial where mask; untouched positions then have no promised value. Suppressing all warnings also does not establish a valid numerical contract. Checking only denominator != 0 does not prevent every possible floating-point overflow. The input range in these small fixtures is bounded, and production ratios may need additional magnitude checks. State that limitation rather than presenting one mask as a complete numerical safety policy.

Open in local Python playground ↗

Independent practice

Change the zero-denominator fallback to -1 while preserving all valid ratios.

Change the zero-denominator fallback to -1 while preserving all valid ratios. The task should affect output initialization only. Do not replace legitimate zero numerators with -1, drop invalid rows, or change the length of the returned vector.

Work through top=[0, 6, 5] and bottom=[2, 3, 0]. The changed output should distinguish the valid ratio zero from the sentinel at the final position. Keeping one output for each input makes it possible to preserve observation alignment in a larger report.

Step 1: Use -1 as the zero-denominator fallback without changing valid zero ratios. Step 2: Retain the working imports, input validation and array shapes. Change the stated policy, run the supplied practice cases, then explain the newly accepted or rejected boundary.

Practice starter: solve before reading the solution

python

import numpy as np

def inspect_example(numerators, denominators):
    top = np.asarray(numerators, dtype=np.float64)
    bottom = np.asarray(denominators, dtype=np.float64)
    if top.ndim != 1 or top.shape != bottom.shape:
        raise ValueError("expected aligned vectors")
    if not np.isfinite(top).all() or not np.isfinite(bottom).all():
        raise ValueError("expected finite values")
    result = np.zeros_like(top)
    np.divide(top, bottom, out=result, where=bottom != 0)
    return result

# Independent task: Use -1 as the zero-denominator fallback without changing valid zero ratios.

Reasoning: Use -1 as the zero-denominator fallback without changing valid zero ratios.

Open in local Python playground ↗

Hint 1: The divide mask already has the correct meaning.
Hint 2: Initialize result with np.full_like(top, -1.0).

Solution, tests and trade-offs

The solution uses full_like with a floating-point -1 initializer and keeps the divide call unchanged.

The solution uses full_like with a floating-point -1 initializer and keeps the divide call unchanged. Tests include zero numerators, negative denominators, an entirely zero-denominator vector and empty aligned arrays. Exact dtype and shape checks prevent a Python list or a smaller filtered vector from passing just because some ratios are correct.

A sentinel is a public interface decision and may be ambiguous if -1 is also a valid ratio. A richer interface could return values plus a validity mask, or reject invalid denominators entirely. This small task teaches how to implement one stated policy without claiming that it is appropriate for every consumer.

Practice solution and acceptance checks

python

import numpy as np

def inspect_example(numerators, denominators):
    top = np.asarray(numerators, dtype=np.float64)
    bottom = np.asarray(denominators, dtype=np.float64)
    if top.ndim != 1 or top.shape != bottom.shape:
        raise ValueError("expected aligned vectors")
    if not np.isfinite(top).all() or not np.isfinite(bottom).all():
        raise ValueError("expected finite values")
    result = np.full_like(top, -1.0)
    np.divide(top, bottom, out=result, where=bottom != 0)
    return result

Reasoning: The solution uses full_like with a floating-point -1 initializer and keeps the divide call unchanged. Tests include zero numerators, negative denominators, an entirely zero-denominator vector and empty aligned arrays. Exact dtype and shape checks prevent a Python list or a smaller filtered vector from passing just because some ratios are correct. A sentinel is a public interface decision and may be ambiguous if -1 is also a valid ratio. A richer interface could return values plus a validity mask, or reject invalid denominators entirely. This small task teaches how to implement one stated policy without claiming that it is appropriate for every consumer.

Open in local Python playground ↗

Interview reasoning and next step

Explain why np.where(mask, a / b, fallback) does not prevent the division from happening.

Explain why np.where(mask, a / b, fallback) does not prevent the division from happening. Contrast that with the ufunc where parameter and describe why out must be initialized for masked-off positions. Show how a valid numerical zero differs from an invalid ratio marker.

Practice the three-line output initialization and divide call on the PC, then recall the changed fallback. In the app, reason about which positions are calculated. Next, sort numerical scores while keeping identifiers and tied observations in the intended order.

Optional stretch — after the core task works: Add one independently reasoned boundary case and explain its expected value before running it.

Computer practice: https://applydjinn.com/typorithm/numpy-lab-20261106.zip. Install pinned dependencies in an isolated Python environment. Run verify.py, then change the working exercise baseline and run --practice np-ufuncs. The real NumPy arrays, numerical contracts, random state checks and temporary numeric files use owned fixtures only. No production database, feed, account or paid service is used. This lab executes Python; the PC typing trainer and native reading progress do not execute it.

Avoid invalid arithmetic by controlling where the ufunc executes and initializing every output position.