4. Numerical and Statistical Computing

Introduction and Context

Data science depends on the ability to transform data into numerical representations, perform reliable calculations, quantify uncertainty, and draw defensible conclusions. Programming languages such as Python and R provide the syntax for these activities, while libraries such as NumPy, SciPy, pandas, base R, and related statistical packages provide efficient implementations of numerical and statistical methods.

Numerical computing concerns the representation and manipulation of numbers by computers. It includes vectorized arithmetic, matrices, numerical integration, optimization, simulation, and the solution of equations. Statistical computing uses these capabilities to summarize data, estimate unknown quantities, test hypotheses, model relationships, and assess uncertainty. The two areas are closely connected: a regression model may be statistically meaningful, but it also requires matrix multiplication, numerical optimization, and careful handling of floating-point values.

For postgraduate data science students, learning a function's name is not sufficient. A practitioner must understand what the function computes, what assumptions it makes, how efficiently it operates, how numerical error may affect the result, and whether the result is appropriate for the decision being made. This chapter therefore treats Python and R as computational environments and emphasizes interpretation as much as implementation.

Learning Objectives

After studying this chapter, students should be able to:

1. Explain the role of vectorization, arrays, matrices, and broadcasting in numerical computing.

2. Use NumPy, SciPy, base R, and related libraries for linear algebra, probability, simulation, optimization, and statistical analysis.

3. Distinguish exact arithmetic from floating-point approximation and identify sources of numerical error.

4. Select suitable descriptive and inferential statistical methods and interpret their assumptions.

5. Compare computational approaches using concepts such as time complexity, memory usage, stability, and reproducibility.

6. Apply simulation and optimization to practical data science problems.

7. Evaluate statistical output critically rather than treating software output as automatic evidence.

The Computational Foundation: Vectors, Arrays, and Matrices

A scalar is a single numerical value; a vector is an ordered collection of values; a matrix is a rectangular arrangement of values; and a higher-dimensional array extends the same idea to additional dimensions. In Python, NumPy's `ndarray` is the principal structure for homogeneous numerical data. In R, vectors, matrices, and arrays are native data structures.

```python

import numpy as np

x = np.array([2, 4, 6, 8])

y = 2 * x + 1

mean_x = np.mean(x)

```

```r

x <- c(2, 4, 6, 8)

y <- 2 * x + 1

mean_x <- mean(x)

```

The expression `2 * x + 1` applies operations element by element. This is vectorization. Instead of writing an explicit loop that visits every observation, the programmer expresses the operation on the whole object. Vectorized operations are usually shorter and often faster because numerical work is delegated to optimized compiled code.

Vectorization does not mean that a loop has disappeared conceptually. The operation still requires work proportional to the number of elements, normally written as O(n). The advantage is reduced interpreter overhead, clearer mathematical expression, and better use of optimized memory operations. Vectorization can, however, use substantial temporary memory. For very large data, chunking, streaming, sparse arrays, or carefully designed loops may be preferable.

Shape, Type, and Missing Values

An array's shape describes its dimensions. A matrix with 100 rows and 5 columns has shape `(100, 5)` in NumPy and dimensions `100 x 5` in R. Many programming errors arise from confusing a row vector, a column vector, and a one-dimensional array. In matrix calculations, the distinction affects whether multiplication is valid and what shape the result has.

Data type also matters. Integer, floating-point, Boolean, and complex values have different storage requirements and behavior. A numeric-looking column may accidentally be stored as text or as a categorical factor. In Python, pandas columns may have nullable or object types; in R, factors have category labels and integer codes. Before computation, inspect dimensions, types, ranges, and missingness.

Missing values require explicit treatment. NumPy commonly represents missing numerical values as `NaN`, while R uses `NA`. Many functions need an instruction such as `np.nanmean(x)` or `mean(x, na.rm = TRUE)`. Removing missing observations is not automatically correct: the mechanism producing missingness may be informative, and complete-case analysis can introduce bias.

Broadcasting and Recycling

NumPy broadcasting permits compatible arrays of different shapes to participate in an operation. For example, a matrix can be standardized by subtracting a row of column means, provided the dimensions align according to broadcasting rules. Broadcasting is powerful but can conceal an unintended dimension mismatch. R uses a related, but not identical, recycling rule: a shorter vector may be repeated across a longer vector. If the lengths are not compatible, R may issue a warning while still producing a result. This behavior should be checked rather than ignored.

Numerical Precision and Computational Complexity

Computers usually represent real numbers using finite-precision floating-point formats. A decimal value such as 0.1 generally has no exact binary representation. Consequently, calculations that appear mathematically exact may produce small errors.

```python

0.1 + 0.2 == 0.3

```

This expression may evaluate to `False` because the stored approximations differ slightly. Comparisons involving computed floating-point values should use a tolerance, such as `np.isclose`, rather than exact equality. R provides functions such as `all.equal` for approximate comparison.

Three forms of error are especially important. Round-off error results from representing numbers with limited precision. Truncation error occurs when an infinite mathematical process is approximated by a finite one, as in numerical integration. Propagation and accumulation error arise when earlier errors influence later calculations. An algorithm can be mathematically valid but numerically unstable if small input errors produce disproportionately large output errors.

Conditioning describes how sensitive a problem is to changes in its input. Stability describes how an algorithm behaves in the presence of numerical error. These are different: an ill-conditioned problem is inherently sensitive, while an unstable algorithm unnecessarily magnifies error. In linear algebra, solving a system using a matrix inverse explicitly is often less desirable than using a solver because inversion may be slower and less stable.

Computational complexity describes how time or memory grows with input size. Common orders include O(1), O(log n), O(n), O(n log n), and O(n²). Computing a mean is O(n); multiplying two dense n by n matrices is approximately O(n³) using the standard algorithm. Complexity is not the only consideration. Constant factors, memory locality, parallelism, data sparsity, and the cost of transferring data between systems may materially affect performance.

Reproducibility requires more than saving source code. Record package versions, input-data versions, random seeds, preprocessing decisions, and numerical tolerances. A fixed random seed improves repeatability but does not guarantee identical results across different libraries, hardware, or parallel execution settings.

Linear Algebra for Data Science

Linear algebra provides the language of many data science methods. A system of equations can be written as Ax = b, where A is a coefficient matrix, x is an unknown vector, and b is a known vector. The least-squares estimate in linear regression minimizes the squared distance between observed and predicted responses. Eigenvalues and eigenvectors underlie principal component analysis, while singular value decomposition supports dimensionality reduction and low-rank approximation.

NumPy and SciPy provide several approaches:

```python

A = np.array([[3., 1.], [1., 2.]])

b = np.array([9., 8.])

x = np.linalg.solve(A, b)

values, vectors = np.linalg.eig(A)

U, s, Vt = np.linalg.svd(A, full_matrices=False)

```

In R, comparable operations use `solve`, `eigen`, and `svd`:

```r

A <- matrix(c(3, 1, 1, 2), nrow = 2, byrow = TRUE)

b <- c(9, 8)

x <- solve(A, b)

eigen(A)

svd(A)

```

Matrix multiplication is not the same as element-wise multiplication. In NumPy, `A @ B` performs matrix multiplication, whereas `A B` performs element-wise multiplication when shapes permit. In R, `%%` performs matrix multiplication and `*` is element-wise. Confusing these operators can generate plausible but incorrect output.

The transpose changes rows into columns. The norm measures vector magnitude. The determinant can indicate singularity but is not generally the preferred diagnostic for solving systems. A matrix is singular when it lacks a unique inverse; it is ill-conditioned when small perturbations can cause substantial changes in the solution. Singular value decomposition is often useful for diagnosing rank deficiency and constructing stable approximations.

For large datasets, sparse matrices are important because most entries may be zero. SciPy's sparse matrix structures and R packages such as `Matrix` can reduce memory and computational cost. Sparse representations should be selected based on the pattern of non-zero values; converting a truly large sparse matrix to a dense matrix may exhaust memory.

Probability, Random Variables, and Simulation

Probability provides a formal framework for uncertainty. A random variable maps outcomes to numerical values. A probability mass function describes a discrete variable, while a probability density function describes a continuous variable. The cumulative distribution function gives the probability that a random variable is less than or equal to a specified value. Expected value and variance describe central tendency and dispersion at the distribution level.

Python's SciPy includes distribution objects, while base R provides functions using a naming convention: `d` for density or probability mass, `p` for cumulative probability, `q` for quantiles, and `r` for random generation. For a normal distribution:

```python

from scipy import stats

p = stats.norm.cdf(1.96)

q = stats.norm.ppf(0.975)

sample = stats.norm.rvs(loc=10, scale=2, size=1000, random_state=42)

```

```r

p <- pnorm(1.96)

q <- qnorm(0.975)

sample <- rnorm(1000, mean = 10, sd = 2)

```

Simulation approximates a theoretical or operational process by generating many random outcomes. Monte Carlo estimation uses the law of large numbers: under suitable conditions, the average of simulated outcomes approaches the expected value as the number of simulations increases. Simulation error decreases gradually, commonly at a rate proportional to the inverse square root of the number of replications. Therefore, increasing simulations by a factor of 100 reduces ordinary Monte Carlo error by roughly a factor of 10, not 100.

A simulation study should define the data-generating process, parameters, random-number generator, number of replications, performance measure, and uncertainty summary. Simulation is not a substitute for evidence when the assumed model is unrealistic. It is a tool for understanding consequences under specified assumptions.

Bootstrap methods repeatedly resample observed data, usually with replacement, to approximate the sampling distribution of a statistic. They can estimate standard errors and confidence intervals when analytical formulas are difficult. Bootstrap validity depends on whether the observed sample reasonably represents the population and whether the resampling scheme respects dependence, clustering, or time order.

Descriptive Statistics and Exploratory Analysis

Descriptive statistics organize observed data before formal modeling. Measures of location include the mean, median, trimmed mean, and mode. The mean is sensitive to extreme observations; the median is more robust for skewed distributions. Measures of dispersion include the range, variance, standard deviation, interquartile range, and median absolute deviation.

The sample variance is commonly calculated using a denominator of n − 1 rather than n because this provides an unbiased estimator of population variance under standard independent-sampling assumptions. The distinction should be made explicit when comparing software or reporting results. Quantiles, frequency tables, cross-tabulations, and visualizations complement numerical summaries.

A useful exploratory workflow examines:

• distributions and skewness;
• outliers and influential observations;
• relationships between variables;
• missing-data patterns;
• grouping and stratification;
• measurement scales and units.

Correlation measures association, not causation. Pearson correlation describes linear association and can be strongly affected by outliers. Spearman correlation uses ranks and is useful for monotonic relationships. A near-zero correlation does not rule out a nonlinear relationship, and a high correlation does not establish that changing one variable causes changes in another.

Statistical Inference: Estimation, Testing, and Modeling

Inferential statistics uses a sample to learn about a broader population. A parameter is a population quantity, while a statistic is calculated from sample data. An estimator is a rule for producing an estimate. Important properties include bias, variance, consistency, efficiency, and robustness.

A confidence interval is a procedure that, under repeated sampling and its assumptions, captures the fixed population parameter at a stated long-run rate. It is not correctly interpreted as the probability that a fixed parameter lies in one already-computed interval. Wider intervals generally result from greater variability, smaller samples, or higher confidence levels.

Hypothesis testing begins with a null hypothesis and an alternative hypothesis. A test statistic summarizes evidence relative to the null model. The p-value is the probability, assuming the null hypothesis and model are appropriate, of observing a result at least as extreme as the one obtained. It is not the probability that the null hypothesis is true, nor is it a measure of practical importance.

A small p-value may indicate incompatibility with the null model, but it does not establish causality or substantive significance. Report effect sizes and confidence intervals alongside p-values. When many hypotheses are tested, false-positive risk increases; procedures such as false discovery rate control or family-wise error adjustments may be appropriate.

Linear regression models a conditional mean, often written as y = Xβ + ε. Typical assumptions include an appropriate functional form, independent errors where applicable, constant error variance, and adequate treatment of influential observations. Normality of errors is particularly relevant for small-sample inference, but it is not required for calculating fitted values. Regression diagnostics should examine residuals, leverage, heteroscedasticity, dependence, and multicollinearity.

In Python, `scipy.stats` provides many classical tests, while `statsmodels` provides regression models and detailed inferential output. In R, base functions such as `t.test`, `wilcox.test`, `lm`, and `aov` support common analyses. The choice between parametric and non-parametric methods should reflect the estimand, measurement scale, design, and assumptions rather than a mechanical normality test alone.

Optimization and Numerical Search

Optimization selects parameter values that minimize a loss function or maximize an objective. It is central to regression, classification, experimental design, resource allocation, and machine learning. An optimization problem may be unconstrained or constrained, convex or non-convex, smooth or non-smooth.

SciPy's `optimize` module includes scalar minimization, multivariate minimization, root finding, least-squares methods, and constrained optimization. R users may employ `optim`, `nlm`, `optimx`, or specialized packages. A typical workflow defines the objective, selects an initial point, specifies constraints and tolerances, runs the algorithm, and evaluates convergence and sensitivity.

A reported optimum is not automatically trustworthy. Algorithms can stop because the gradient is small, because successive values change little, or because an iteration limit is reached. These conditions have different meanings. For non-convex objectives, multiple starting values may be needed. Scaling variables can improve conditioning. Constraints should reflect the problem's substantive meaning, not merely force a numerically convenient answer.

For a convex problem, a local optimum is also a global optimum under appropriate conditions. For non-convex problems, a local optimum may depend heavily on initialization. Stochastic optimization introduces additional randomness and requires monitoring of convergence, learning rates, and validation performance.

A Practical Workflow for Reliable Numerical and Statistical Computing

A disciplined workflow links mathematical formulation, implementation, validation, and interpretation.

First, define the question and estimand. Decide whether the objective is prediction, causal comparison, description, estimation, or optimization. Second, inspect and validate the data, including units, types, missingness, duplicates, and sampling design. Third, express the method mathematically before translating it into code. Fourth, implement a small, transparent reference version against which optimized code can be checked.

Next, test boundary cases and known results. Compare vectorized calculations with a simple loop on a small dataset. Check dimensions and conservation properties. For simulations, verify that simulated summaries approximate theoretical values. For optimization, evaluate the objective independently at the reported solution and at nearby points. Finally, document assumptions, seeds, software versions, tolerances, and decisions.

Unit tests should assess both values and properties. For example, a covariance matrix should be symmetric within numerical tolerance, probabilities should lie between zero and one, and a standardized variable should have approximately zero mean and unit variance. Tests should not merely confirm that code runs.

Illustrative Case Study: Optimizing a Hospital Appointment Schedule

Background

Consider an illustrative case involving a hospital outpatient department that schedules appointments for three categories of patients: routine, urgent, and specialist referrals. The department has limited daily capacity and wants to reduce expected waiting time without exceeding staff or room constraints.

Situation and Problem

Historical records contain appointment durations, arrival delays, cancellation indicators, and patient categories. The data are incomplete and show strong differences between categories. A naive average duration would understate the capacity required for specialist referrals. Management asks for a computational model that can compare scheduling policies.

Analysis

The data science team first examines distributions by category using groupwise means, medians, quantiles, and histograms. Because durations are right-skewed, the median and upper quantiles are reported alongside means. Missing durations are investigated rather than silently removed. Records from a period with a major system outage are excluded only after documenting the exclusion and evaluating its effect.

A bootstrap procedure estimates uncertainty in the median duration for each category. The team then constructs a simulation: for each simulated day, patient arrivals and appointment durations are sampled from category-specific empirical distributions. A fixed random seed is used for development, while multiple independent seeds are used for sensitivity analysis.

The scheduling objective combines expected waiting time with penalties for overtime and unused capacity. SciPy optimization is used to search over feasible allocations of appointment slots. In R, an equivalent model can be implemented with `optim` or a constrained optimization package. The objective is evaluated on many simulated days rather than on one average day, because variability is operationally important.

Approach and Solution

The team compares three policies: allocation based on overall mean duration, allocation based on category-specific quantiles, and an optimized policy with explicit overtime penalties. The simulation reports average waiting time, the 90th percentile of waiting time, overtime probability, and cancellation probability. Multiple starting allocations are supplied to the optimizer, and the final solution is checked against neighboring feasible allocations.

Outcome

The quantile-based and optimized policies produce different trade-offs. The optimized policy reduces expected waiting time but permits slightly more unused capacity than the mean-based policy. More importantly, it performs better under high-variability scenarios because it accounts for uncertainty rather than planning only around average demand. The result is presented as a conditional recommendation, not as a guaranteed operational improvement, because it depends on the estimated arrival and duration distributions.

Learning Points

The case illustrates several principles. Descriptive statistics should respect skewness and subgroups. Simulation can expose risks hidden by averages. Optimization requires a clearly defined objective and constraints. Uncertainty analysis is essential when decisions affect people and resources. Finally, computational output must be translated into operational measures that managers understand.

Challenges, Risks, and Common Mistakes

A common mistake is treating software output as a fact without checking the data-generating assumptions. A function can produce a valid numerical result for an invalid question. Other frequent errors include using the wrong matrix operator, silently recycling or broadcasting incompatible arrays, dropping missing values without assessing bias, confusing standard deviation with standard error, interpreting a p-value as an effect size, and reporting excessive decimal places.

Data leakage is a major risk in predictive workflows: information unavailable at decision time may accidentally enter model fitting or preprocessing. Repeated testing and selective reporting can create apparently persuasive but irreproducible findings. Overfitting can occur in both statistical models and simulation-based optimization when a policy is tuned to one historical sample.

Numerical failures include overflow, underflow, cancellation, ill-conditioned systems, and convergence to a poor local optimum. Scaling, stable algorithms, log transformations where appropriate, regularization, and diagnostic checks can reduce these risks. Numerical warnings should be investigated rather than suppressed.

Ethical, Governance, and Professional Considerations

Statistical computing can influence access to healthcare, credit, employment, education, and public services. A technically accurate computation may still produce unfair outcomes if the data reflect unequal measurement, historical discrimination, or unequal access. Analysts should document data provenance, inclusion criteria, missing-data decisions, transformations, and model limitations.

Privacy protection is essential when simulations or analyses use individual-level records. Aggregation, de-identification, access controls, and secure computational environments may be required, but de-identification does not eliminate all re-identification risk. Reproducible analysis should balance transparency with confidentiality.

Professional reporting should distinguish exploratory findings from confirmatory claims, disclose uncertainty, avoid misleading visual scales, and make assumptions visible. Where decisions are automated or semi-automated, human oversight, appeal mechanisms, monitoring, and periodic validation are important.

Current Developments and Best Practices

Modern numerical computing increasingly uses parallel processors, distributed systems, automatic differentiation, just-in-time compilation, and accelerator hardware. Libraries such as JAX, PyTorch, and TensorFlow extend numerical programming toward differentiable and hardware-accelerated computation, while established NumPy, SciPy, and R ecosystems remain essential for scientific and statistical work. Probabilistic programming supports explicit uncertainty modeling, and reproducible workflow tools connect code, environments, data, and reports.

These developments do not remove the need for fundamentals. A GPU cannot correct a poorly specified objective, and an advanced Bayesian model cannot compensate for biased data. Good practice includes:

• formulate the statistical question before selecting a function;
• inspect types, shapes, units, missingness, and sampling design;
• prefer stable solvers and appropriate representations;
• use tolerances for floating-point comparisons;
• validate simulations against known theory or empirical benchmarks;
• report effect sizes, uncertainty, and assumptions;
• test sensitivity to plausible alternative specifications;
• preserve reproducible environments and computational logs;
• separate exploratory analysis from final confirmatory analysis.

Chapter Summary

Numerical and statistical computing forms the computational core of data science. NumPy, SciPy, base R, and related libraries support vectorized operations, matrix algebra, probability calculations, simulation, optimization, descriptive statistics, and inference. Effective use requires understanding arrays, shapes, types, missing values, broadcasting, and matrix operators. Floating-point representation introduces approximation, while conditioning, stability, and computational complexity determine whether results are reliable and scalable.

Statistical analysis requires more than selecting a test or reading a p-value. Descriptive measures must reflect distributional shape and data quality; inferential procedures depend on design and assumptions; simulation and bootstrap methods quantify uncertainty under specified conditions; and optimization must be evaluated for convergence, constraints, and sensitivity. Professional practice combines numerical validation, statistical reasoning, reproducibility, ethical governance, and clear communication of limitations.

Key Terms

Floating-point arithmetic: Approximate representation of real numbers using finite computer precision.

Vectorization: Applying an operation to an entire array or vector without explicit element-by-element interpreter loops.

Broadcasting: Rules that allow compatible arrays of different shapes to participate in an operation.

Computational complexity: The growth of time or memory requirements as input size increases.

Conditioning: Sensitivity of a mathematical problem's output to perturbations in its input.

Numerical stability: The extent to which an algorithm limits the amplification of computational error.

Matrix multiplication: An algebraic operation combining rows of one matrix with columns of another.

Singular value decomposition: Factorization of a matrix into orthogonal matrices and singular values.

Sparse matrix: A matrix in which most entries are zero and stored efficiently using a specialized representation.

Random variable: A numerical mapping from outcomes of a random process.

Monte Carlo simulation: Approximation of quantities by repeated random sampling.

Bootstrap: Resampling procedure used to approximate a statistic's sampling distribution.

Estimator: A rule that uses sample data to estimate a population parameter.

Confidence interval: An interval produced by a procedure designed to capture a parameter at a stated long-run rate.

P-value: Probability, under a null model, of observing a result at least as extreme as the observed result.

Effect size: A quantitative measure of the magnitude of an observed or estimated relationship.

Optimization: Systematic search for parameter values that minimize or maximize an objective.

Ill-conditioning: A situation in which small input changes can cause large changes in the solution.

Reproducibility: Ability to obtain consistent analytical results using documented data, code, environments, and procedures.

Review Questions

Short Answer Questions

1. What is vectorization, and why can it improve numerical performance?

2. Distinguish round-off error from truncation error.

3. What is the difference between matrix multiplication and element-wise multiplication in Python and R?

4. Why is a p-value not a measure of practical importance?

5. What information should be recorded to make a simulation reproducible?

Long Answer Questions

1. Explain how floating-point representation, conditioning, and numerical stability affect the reliability of a data science computation.

2. Describe a complete workflow for conducting a bootstrap or Monte Carlo simulation, including assumptions and validation.

3. Discuss the role of linear algebra in regression, dimensionality reduction, and large-scale data analysis.

4. Compare descriptive statistics, confidence intervals, and hypothesis tests as tools for statistical reasoning.

5. Explain how an optimization result should be evaluated before it is used to support an organizational decision.

Analytical / Application Questions

1. A NumPy calculation produces a matrix with an unexpected shape after subtracting a vector. Diagnose how broadcasting may have caused the problem and propose checks.

2. An analyst reports a statistically significant difference with a very small effect size after testing 200 hypotheses. What additional analyses and reporting decisions are required?

3. Design a simulation study to compare two hospital scheduling policies when appointment durations are skewed, missing for some records, and different across patient categories.

22. Multiple Choice Questions with Answers

Question 1

Which operation performs matrix multiplication in NumPy?

A. A * B

B. A + B

C. A @ B

D. A / B

Correct Answer: C. A @ B

Question 2

Why should floating-point results generally be compared using a tolerance?

A. Floating-point numbers cannot be stored at all

B. Many decimal values are represented only approximately

C. Tolerance comparisons always increase precision

D. Integer calculations are inherently random

Correct Answer: B. Many decimal values are represented only approximately

Question 3

What does a Monte Carlo estimate rely primarily upon?

A. The law of large numbers

B. Exact symbolic integration

C. Elimination of all model assumptions

D. A guarantee that every simulated value is observed in reality

Correct Answer: A. The law of large numbers

Question 4

Which statement correctly interprets a p-value?

A. It is the probability that the null hypothesis is true

B. It is the probability that the research hypothesis is false

C. It measures the practical size of an effect

D. It is the probability, under the null model, of results at least as extreme as observed

Correct Answer: D. It is the probability, under the null model, of results at least as extreme as observed

Question 5

A shorter vector is silently repeated during an R calculation. Which feature is most directly involved?

A. Garbage collection

B. Vector recycling

C. Singular value decomposition

D. Bootstrap resampling

Correct Answer: B. Vector recycling

Question 6

Why might solving Ax = b be preferred to explicitly computing A's inverse?

A. Solvers can be more efficient and numerically stable

B. An inverse always changes the statistical model

C. Solvers require no numerical calculations

D. An inverse can only be used for rectangular matrices

Correct Answer: A. Solvers can be more efficient and numerically stable

Question 7

What does a bootstrap procedure primarily approximate?

A. The exact population distribution without assumptions

B. The sampling distribution of a statistic

C. The optimizer's convergence rate

D. The computer's floating-point format

Correct Answer: B. The sampling distribution of a statistic

Question 8

In a non-convex optimization problem, why are multiple starting values useful?

A. They guarantee a global optimum

B. They remove all constraints

C. They help reveal sensitivity to local optima

D. They convert the problem into a linear one

Correct Answer: C. They help reveal sensitivity to local optima

Question 9

Which practice is most appropriate when reporting a regression result?

A. Report only the smallest p-value

B. Ignore influential observations

C. Report effect sizes, uncertainty, and relevant diagnostics

D. Assume software output proves causality

Correct Answer: C. Report effect sizes, uncertainty, and relevant diagnostics

Question 10

Why can a sparse matrix representation be valuable?

A. It stores and processes many zero entries more efficiently

B. It makes every matrix positive definite

C. It eliminates the need to check dimensions

D. It guarantees exact floating-point arithmetic

Correct Answer: A. It stores and processes many zero entries more efficiently