Crowdly

Add to Chrome

Course 88790

Looking for Course 88790 test answers and solutions? Browse our comprehensive collection of verified answers for Course 88790 at emas3.ui.ac.id.

Get instant access to accurate answers and detailed explanations for your course questions. Our community-driven platform helps students succeed!

Information:

IEEE 754 double precision represents numbers as where mantissa has 52 bits. When dividing two numbers, the quotient's relative error is approximately the sum of the operands' relative errors.

Why does dividing by a large number limit error amplification better than dividing by a small number?

Small divisors trigger mantissa overflow during division, requiring error-inducing renormalization steps.

100%

IEEE 754 allocates extended guard bits specifically for large-divisor arithmetic operations only.

Large divisors reduce Newton-Raphson iterations needed in the hardware division unit implementation.

Large numbers have more significant mantissa bits, giving inherently higher division precision.

Division by large values shifts results into the more precise subnormal floating-point range.

Large divisors produce quotients , preventing error amplification in subsequent operations.

View this question

Information:

Chemical mass balance problems can involve species with concentrations differing by orders of magnitude (e.g., trace elements vs. bulk species), creating systems with highly disparate coefficient magnitudes.

A chemical reactor model has concentrations ranging from

M (trace catalyst) to M (bulk solvent). The mass balance system has coefficients spanning 7 orders of magnitude. Why is partial pivoting critical?

Pivoting ensures exact mass conservation throughout the numerical elimination procedure.

Small concentration divisors without pivoting create huge multipliers that amplify round-off errors.

Pivoting accelerates convergence by prioritizing equations with the largest rate constants.

The wide concentration range causes overflow unless pivoting redistributes coefficient values.

Without pivoting, thermodynamic constraints are violated producing negative concentration values.

Chemical equilibrium requires species processed in decreasing concentration order for accuracy.

View this question

Information:

The number of additions in forward elimination for Gaussian elimination is approximately for an matrix.

Using the exact formula

for additions, calculate the total for a matrix.

9 additions: total operations from the matrix size

5 additions: by combinatorial count

10 additions: from summing intermediate products

8 additions: : ; : ; total

100%

12 additions: from the series formula

6 additions: gives ; sum terminates at one term

View this question

Information:

Numerical experiments can reveal the impact of pivoting by comparing solutions from the same system solved with and without partial pivoting, measuring the deviation from the true solution.

Two implementations solve

: one with partial pivoting, one without. For a matrix with condition number and smallest diagonal element

, the results are:

With pivoting:

Without pivoting:

What explains this

rder-of-magnitude difference?

Small pivot divisors create large multipliers that amplify round-off errors cumulatively.

100%

Pivoting internally uses higher-precision arithmetic to preserve numerical accuracy.

Without pivoting, the solver converges to a completely different solution branch.

Without pivoting, the algorithm terminates early when it detects a near-singular matrix.

Pivoting adds iterative refinement steps after elimination to correct accumulated errors.

Pivoting reduces the condition number , directly improving solution accuracy.

View this question

Information:

Gaussian elimination transforms a system into upper triangular form through row operations. The elimination process proceeds column by column, eliminating entries below the diagonal.

Consider the following modified Python code for Gaussian elimination:

def gauss_elim_v2(A, b):
    n = len(A)
    for k in range(n-1):
        for i in range(k+1, n):
            factor = A[i][k] / A[k][k]
            for j in range(n):
                A[i][j] -= factor * A[k][j]
            b[i] -= factor * b[k]
    return A, b

What is the consequence of using

range(n) instead of range(k, n) in the innermost loop?

Previous elimination results are corrupted by modifying already-processed columns.

100%

Division by zero is triggered when accessing previously processed column entries.

Elements above the diagonal become non-zero, violating upper triangular form.

Redundant operations on already-zeroed entries occur but output remains correct overall.

The loop index exceeds the valid column range of the matrix, causing out-of-bounds memory errors.

Entries in the first columns fail to be eliminated during the inner loop.

View this question

Information:

LU decomposition handles negative entries the same as positive ones. The sign is preserved through the arithmetic: and can be negative, and their products must reconstruct the original (possibly negative) .

Perform LU decomposition (Doolittle) on:

What is

(row 2, column 1 of )?

View this question

Information:

The computational cost of Gaussian elimination is approximately flops (floating-point operations). LU decomposition has the same cost for factorization, but each subsequent solve (forward + backward substitution) costs only flops.

For a system with

and different right-hand sides, at what value of does LU decomposition become more efficient than repeated Gaussian elimination?

, because factorization reuse saves significant work.

100%

, because substitution cost must match the matrix dimension for crossover to occur.

, because LU is always more efficient due to better numerical stability properties.

, because the storage overhead of L and U requires multiple solves to amortize.

, because the breakeven point scales linearly with the matrix size parameter value.

, because the factorization cost only becomes negligible at very large values of .

View this question

Information:

An orthogonal matrix satisfies , implying . For the 2-norm, for any orthogonal matrix.

Compute

for the rotation matrix .

for any , because implies .

100%

for any , computed as the Frobenius norm .

because the 1-norm of rotation matrices depends on the angle of rotation.

only when ; otherwise it grows with the rotation angle magnitude.

because the diagonal dominance decreases as , increasing the condition number.

for any , because the matrix has 2 eigenvalues of magnitude 1, giving .

View this question

Information:

Computational fluid dynamics (CFD) simulations can generate linear systems with unknowns. Direct methods like LU require time and memory. Iterative methods like GMRES require time for iterations and memory.

A CFD simulation has

variables. The workstation has 128 GB RAM. Can LU decomposition be used?

No, because LU decomposition is numerically unstable for

Yes, LU works if we use block decomposition to fit data in cache

Yes, LU is practical here because iterative methods converge more slowly

No, because LU decomposition cannot handle CFD-type sparse systems at all

Yes, modern SSDs provide virtual memory sufficient for petabyte-scale matrices

No, dense storage needs TB and FLOPs are prohibitive

100%

View this question

Information:

During Gaussian elimination, large-magnitude values progressively become zeros below the diagonal. A heatmap visualization uses color intensity to show magnitude: dark (near zero) vs. bright (large magnitude).

The following heatmap shows the absolute values of matrix entries during elimination. Darker cells indicate values near zero; brighter (lighter) cells indicate larger magnitudes.

	C1	C2	C3	C4
R1	4	2	1	3
R2	0	3	2	4
R3	0	0	5	1
R4	0	2	3	2

Legend: dark ≈ 0 (eliminated), medium = partial, light = large (unprocessed)

Which best describes the elimination status?

Backward substitution is in progress starting from the lower-right quadrant area.

Column 2 is fully processed; column 3 is currently being processed at row 4 now.

Columns 1-2 are fully processed with only two elimination steps left to finish.

The dark pattern indicates accumulated round-off errors in the first two column entries.

Columns 1-3 are fully processed; only the final diagonal element needs correction.

Column 1 is done; column 2 is partially done with row 4 pending.

100%

View this question

Want instant access to all verified answers on emas3.ui.ac.id?

Get Unlimited Answers To Exam Questions - Install Crowdly Extension Now!

Add to Chrome

Telegram Instagram TikTok Question Bank