Wolfram Language & System Documentation Center

OrthogonalMatrixQ

gives True if m is an explicitly orthogonal matrix, and False otherwise.

Details and Options

A p×q matrix m is orthogonal if p≥q and Transpose[m].m is the q×q identity matrix, or p≤q and m.Transpose[m] is the p×p identity matrix.
OrthogonalMatrixQ works for symbolic as well as numerical matrices.
The following options can be given:

Normalized	True	test if matrix columns are normalized
SameTest	Automatic	function to test equality of expressions
Tolerance	Automatic	tolerance for approximate numbers

For exact and symbolic matrices, the option SameTest->f indicates that two entries a_ij and b_ij are taken to be equal if f[a_ij,b_ij] gives True.
For approximate matrices, the option Tolerance->t can be used to indicate that the norm γ=m.m^T-I_n_∞ satisfying γ≤t is taken to be zero where I_n is the identity matrix.

Examples

open all close all

Basic Examples (2)

Test if a 2×2 numeric matrix is orthogonal:

Wolfram Language code:

OrthogonalMatrixQ[(1/Sqrt[2])(⁠|   |    |
| - | -- |
| 1 | -1 |
| 1 | 1  |⁠)]

Test if a 3×3 symbolic matrix is orthogonal:

Wolfram Language code:

m = (⁠|   |        |         |
| - | ------ | ------- |
| 1 | 0      | 0       |
| 0 | Cos[α] | -Sin[α] |
| 0 | Sin[α] | Cos[α]  |⁠);

Wolfram Language code: OrthogonalMatrixQ[m]

Verify the condition by hand:

Wolfram Language code: Transpose[m].m == IdentityMatrix[3]//Simplify

Scope (14)

Basic Uses (6)

Test if a real matrix is orthogonal:

Wolfram Language code: m = (1/Sqrt[5]){{1, 2}, {-2, 1}};

Wolfram Language code: OrthogonalMatrixQ[m]

A real orthogonal matrix is also unitary:

Wolfram Language code: UnitaryMatrixQ[m]

Test if a complex matrix is orthogonal:

Wolfram Language code: m = (1/Sqrt[3]){{2, -I}, {I, 2}};

Wolfram Language code: OrthogonalMatrixQ[m]

This matrix satisfies :

Wolfram Language code: m.m == IdentityMatrix[2]

A complex-valued orthogonal matrix is not unitary:

Wolfram Language code: UnitaryMatrixQ[m]

Test if an exact matrix is orthogonal:

Wolfram Language code:

m = (⁠|   |    |    |
| - | -- | -- |
| 4 | -5 | 2  |
| 3 | -3 | -3 |
| 5 | 5  | 5  |⁠);

Wolfram Language code: OrthogonalMatrixQ[m]

Make the matrix orthogonal:

Wolfram Language code: OrthogonalMatrixQ[Orthogonalize[m]]

Use OrthogonalMatrixQ with arbitrary-precision matrix:

Wolfram Language code: m = RandomReal[5, {3, 3}, WorkingPrecision -> 15]

A random matrix is typically not orthogonal:

Wolfram Language code: OrthogonalMatrixQ[m]

Use OrthogonalMatrixQ with a symbolic matrix:

Wolfram Language code: OrthogonalMatrixQ[{{a, b}, {c, d}} / Sqrt[a^2 + b^2]]

The matrix becomes orthogonal when and :

Wolfram Language code: Block[{c = b, d = -a}, OrthogonalMatrixQ[{{a, b}, {c, d}} / Sqrt[a^2 + b^2]]]

OrthogonalMatrixQ works efficiently with large numerical matrices:

Wolfram Language code: m = RandomReal[1, {1000, 1000}];

Wolfram Language code: AbsoluteTiming[OrthogonalMatrixQ[m]]

Wolfram Language code:

a = Orthogonalize[m];
AbsoluteTiming[OrthogonalMatrixQ[a]]

Special Matrices (4)

Use OrthogonalMatrixQ with sparse matrices:

Wolfram Language code: SparseArray[{Band[{1, 1}] -> -1}, {5, 5}]

Wolfram Language code: OrthogonalMatrixQ[%]

Use OrthogonalMatrixQ with structured matrices:

Wolfram Language code: SymmetrizedArray[{{1, 1} -> (1/Sqrt[2]), {1, 2} -> (1/Sqrt[2]), {2, 2} -> -(1/Sqrt[2])}, {2, 2}, Symmetric[All]]

Wolfram Language code: OrthogonalMatrixQ[%]

The identity matrix is orthogonal:

Wolfram Language code: OrthogonalMatrixQ[IdentityMatrix[3]]

HilbertMatrix is not orthogonal:

Wolfram Language code: OrthogonalMatrixQ[HilbertMatrix[5]]

Rectangular Semi-orthogonal Matrices (4)

Test if a rectangular matrix is semi-orthogonal:

Wolfram Language code:

m = (1/2)(⁠|    |   |   |    |
| -- | - | - | -- |
| 1  | 1 | 1 | -1 |
| -1 | 1 | 1 | 1  |⁠);

Wolfram Language code: OrthogonalMatrixQ[m]

As there are more columns than rows, this indicates that the rows are orthonormal:

Wolfram Language code: m.ConjugateTranspose[m]

The columns are not orthonormal:

Wolfram Language code: ConjugateTranspose[m].m

Test a matrix with more rows than columns:

Wolfram Language code:

m = (1/2)(⁠|    |    |
| -- | -- |
| 1  | -1 |
| 1  | 1  |
| 1  | 1  |
| -1 | 1  |⁠);

Wolfram Language code: OrthogonalMatrixQ[m]

The columns of the matrix are orthonormal:

Wolfram Language code: ConjugateTranspose[m].m

The rows are not orthonormal:

Wolfram Language code: m.ConjugateTranspose[m]

Generate a random orthogonal matrix:

Wolfram Language code: m = RandomVariate[CircularRealMatrixDistribution[4]];

Wolfram Language code: OrthogonalMatrixQ[m]

Any subset of its rows forms a rectangular semi-orthogonal matrix:

Wolfram Language code: OrthogonalMatrixQ[m[[RandomSample[Range[4], 2]]]]

As does any subset of its columns:

Wolfram Language code: OrthogonalMatrixQ[m[[All, RandomSample[Range[4], 2]]]]

Rectangular identity matrices are semi-orthogonal:

Wolfram Language code: OrthogonalMatrixQ[IdentityMatrix[{3, 4}]]

Options (4)

Normalized (2)

Symbolic orthogonal matrix columns are often not normalized to 1:

Wolfram Language code:

m = {{a, b}, {b, -a}};
OrthogonalMatrixQ[m]

Avoid testing if the columns are normalized:

Wolfram Language code: OrthogonalMatrixQ[m, Normalized -> False]

Multiply the second column of an orthogonal matrix by 2:

Wolfram Language code: m = MapAt[2#&, RotationMatrix[π / 4, {1, 0, 1}], {All, 2}]

OrthogonalMatrixQ with NormalizedFalse will still give True for m:

Wolfram Language code: OrthogonalMatrixQ[m, Normalized -> False]

However, it will not give true for Transpose[m]:

Wolfram Language code: OrthogonalMatrixQ[Transpose[m], Normalized -> False]

This is because is a diagonal matrix, but is not:

Wolfram Language code: MatrixForm /@ {m.m, m.m}//FullSimplify

SameTest (1)

This matrix is orthogonal for a positive real , but OrthogonalMatrixQ gives False:

Wolfram Language code: m = {{Log[x ^ 2], 1}, {-1, 2Log[x]}} / Sqrt[1 + 4Log[x] ^ 2];

Wolfram Language code: OrthogonalMatrixQ[m]

Use the option SameTest to get the correct answer:

Wolfram Language code: OrthogonalMatrixQ[m, SameTest -> (Simplify[#1 - #2, x > 0] == 0&)]

Tolerance (1)

Generate an orthogonal real-valued matrix with some random perturbation of order 10^-13:

Wolfram Language code:

SeedRandom[5];n = 3;
q = Orthogonalize[RandomVariate[NormalDistribution[], {n, n}]] + 10 ^ -13 * RandomReal[1, {n, n}];

Wolfram Language code: OrthogonalMatrixQ[q]

q.q^ is not exactly zero outside the main diagonal:

Wolfram Language code: q.q//MatrixForm

Adjust the option Tolerance for accepting the matrix as orthogonal:

Wolfram Language code: OrthogonalMatrixQ[q, Tolerance -> 10 ^ -12]

Tolerance is applied to the following value:

Wolfram Language code: Norm[q.q - IdentityMatrix[3], ∞]

Applications (10)

Sources of Orthogonal Matrices (5)

Any orthonormal basis for $TemplateBox[{}, Reals]^n$ forms an orthogonal matrix:

Wolfram Language code:

Subscript[e, 1] = {(1/Sqrt[2]), (1/Sqrt[2]), 0};Subscript[e, 2] = {(1/Sqrt[2]), -(1/Sqrt[2]), 0};Subscript[e, 3] = {0, 0, 1};

The basis is orthonormal:

Wolfram Language code: Table[Subscript[e, i].Subscript[e, j], {i, 3}, {j, 3}]

Putting the basis vectors in rows of a matrix forms an orthogonal matrix:

Wolfram Language code: OrthogonalMatrixQ[{Subscript[e, 1], Subscript[e, 2], Subscript[e, 3]}]

Putting them in columns also gives an orthogonal matrix:

Wolfram Language code: OrthogonalMatrixQ[{Subscript[e, 1], Subscript[e, 2], Subscript[e, 3]}]

Orthogonalize applied to real, linearly independent vectors generates an orthogonal matrix:

Wolfram Language code: m = Orthogonalize[RandomReal[1., {5, 5}]];

Wolfram Language code: OrthogonalMatrixQ[m]

The matrix does not need to be square, in which case the resulting matrix is semi-orthogonal:

Wolfram Language code: m = Orthogonalize[RandomReal[1., {5, 3}]];

Wolfram Language code: OrthogonalMatrixQ[m]

Wolfram Language code: m = Orthogonalize[RandomReal[1., {3, 5}]];

Wolfram Language code: OrthogonalMatrixQ[m]

But the starting matrix must have full rank:

Wolfram Language code:

m = (|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |);

Wolfram Language code: MatrixRank[m]

Wolfram Language code: OrthogonalMatrixQ[Orthogonalize[m]]

Any rotation matrix is orthogonal:

Wolfram Language code: OrthogonalMatrixQ[RotationMatrix[RandomReal[2 Pi]]]

Wolfram Language code:

w = RandomReal[1., {3}];
OrthogonalMatrixQ[RotationMatrix[RandomReal[2 Pi], w]]

Wolfram Language code:

u = RandomReal[1., {3}];
OrthogonalMatrixQ[RotationMatrix[RandomReal[2 Pi], {u, w}]]

Any permutation matrix is orthogonal:

Wolfram Language code: m = PermutationMatrix[{2, 4, 1, 3}, TargetStructure -> "Dense"]

Wolfram Language code: OrthogonalMatrixQ[m]

Matrices drawn from CircularRealMatrixDistribution are orthogonal:

Wolfram Language code: OrthogonalMatrixQ /@ RandomVariate[CircularRealMatrixDistribution[3], 10]

Uses of Orthogonal Matrices (5)

Orthogonal matrices preserve the standard inner product on $TemplateBox[{}, Reals]^n$ . In other words, if is orthogonal and and are vectors, then :

Wolfram Language code:

o = RotationMatrix[Pi / 3, RandomReal[1, 3]];
{u, v} = RandomReal[1, {2, 3}];
OrthogonalMatrixQ[o] && u.v == (o.u).(o.v)

This means the angles between the vectors are unchanged:

Wolfram Language code: VectorAngle[u, v] == VectorAngle[o.u, o.v]

Since the norm is derived from the inner product, norms are preserved as well:

Wolfram Language code: Norm[u] == Norm[o.u]

Wolfram Language code: Norm[v] == Norm[o.v]

Any orthogonal matrix represents a rotation and/or reflection. If the matrix has determinant , it is a pure rotation. If it the determinant is , the matrix includes a reflection. Consider the following matrix:

Wolfram Language code:

m = (⁠|                     |                      |
| ------------------- | -------------------- |
| -0.9980858626557927 | -0.06184343753901693 |
| 0.06184343753901693 | -0.9980858626557927  |⁠);

It is orthogonal and has determinant :

Wolfram Language code: OrthogonalMatrixQ[m] && Det[m] == 1

Thus, it is a pure rotation; the Cartesian unit vectors and maintain their relative positions:

Wolfram Language code:

o = {0, 0};i = UnitVector[1];j = UnitVector[2];
Graphics[{{Blue, {Arrow[{o, m.i}], Dotted, Arrow[{o, i}]}}, {Red, {Arrow[{o, m.j}], Dotted, Arrow[{o, j}]}}}]

The following matrix is orthogonal but has determinant :

Wolfram Language code:

m = (⁠|                     |                     |
| ------------------- | ------------------- |
| -0.6512037846116245 | -0.7589029127019458 |
| -0.7589029127019458 | 0.6512037846116244  |⁠);

Wolfram Language code: OrthogonalMatrixQ[m] && Det[m] == -1

Thus, it includes a reflection; the Cartesian unit vectors and reverse their relative positions:

Wolfram Language code: Graphics[{{Blue, {Arrow[{o, m.i}], Dotted, Arrow[{o, i}]}}, {Red, {Arrow[{o, m.j}], Dotted, Arrow[{o, j}]}}}]

Orthogonal matrices play an important role in many matrix decompositions:

Wolfram Language code:

m = RandomReal[{-1., 1.}, {50, 50}];
{q, r} = QRDecomposition[m];
OrthogonalMatrixQ[q]

Wolfram Language code:

{u, w, v} = SingularValueDecomposition[m];
{OrthogonalMatrixQ[u], OrthogonalMatrixQ[v]}

Wolfram Language code:

{s, t} = SchurDecomposition[m];
OrthogonalMatrixQ[s]

Wolfram Language code:

{p, h} = HessenbergDecomposition[m];
OrthogonalMatrixQ[p]

The matrix is always orthogonal for any nonzero real vector :

Wolfram Language code:

n = 5;
Subscript[ℋ, v_] := IdentityMatrix[n] - 2 vv / v.v;
v = RandomReal[1, n];
OrthogonalMatrixQ[Subscript[ℋ, v]]

is called a Householder reflection; as a reflection, its determinant is :

Wolfram Language code: Det[Subscript[ℋ, v]]

It represents a reflection through a plane perpendicular to , sending to :

Wolfram Language code: Subscript[ℋ, v].v == -v

Any vector perpendicular to is unchanged by :

Wolfram Language code:

perp = Block[{w = RandomReal[1, n]}, w - Projection[w, v]];
Subscript[ℋ, v].perp == perp

In matrix computations, is used to set to zero selected components of a given column vector :

Wolfram Language code: x = RandomReal[1, n];

Wolfram Language code:

v = x - x[[1]] / Abs[x[[1]]] Norm[x]UnitVector[n, 1];
Subscript[ℋ, v].{x}//Chop

Find the function satisfying the following differential equation:

Wolfram Language code: (ⅆx/ⅆt) = Overscript[v, ⇀]⨯x, Overscript[v, ⇀] = {2, -1, 1}, x(0) = {1, 0, -1};

Represent the cross-product with by means of multiplication by the antisymmetric matrix :

Wolfram Language code:

vvec = {2, -1, 1};
(v = -LeviCivitaTensor[3].vvec)//MatrixForm

Wolfram Language code: AntisymmetricMatrixQ[v]

Wolfram Language code: v.{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]} == vvec⨯{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}

Compute the exponential and use it to define a solution to the equation:

Wolfram Language code:

u[t_] := MatrixExp[v t]
x0 = {1, 0, -1};
x[t_] = u[t].x0

Verify that satisfies the differential equation and initial condition:

Wolfram Language code: x'[t] == v.x[t] && x[0] == x0//Simplify

The matrix is orthogonal for all values of :

Wolfram Language code: OrthogonalMatrixQ[u[t]]

Thus, the orbit of the solution is at a constant distance from the origin, in this case a circle:

Wolfram Language code:

Show[ParametricPlot3D[x[t], {t, 0., 5.}, PlotStyle -> Tube[0.02]], Graphics3D[{Opacity[.5], Sphere[{0, 0, 0}, Norm[x0]]}], PlotRange -> All]

Properties & Relations (14)

A matrix is orthogonal if m.Transpose[m]IdentityMatrix[n]:

Wolfram Language code: m = {{Cos[α], -Sin[α]}, {Sin[α], Cos[α]}};

Wolfram Language code: {OrthogonalMatrixQ[m], m.m//Simplify}

For an approximate matrix, the identity is approximately true:

Wolfram Language code: m = RandomVariate[CircularRealMatrixDistribution[3]];

Wolfram Language code: {OrthogonalMatrixQ[m], Norm[m.m - IdentityMatrix[3]]}

The inverse of an orthogonal matrix is its transpose:

Wolfram Language code: o = RandomVariate[CircularRealMatrixDistribution[3]];

Wolfram Language code: Inverse[o] == Transpose[o]

Thus, the inverse and transpose are orthogonal matrices as well:

Wolfram Language code: {OrthogonalMatrixQ[Inverse[o]], OrthogonalMatrixQ[Transpose[o]]}

A real orthogonal matrix preserves the standard inner product of vectors in $TemplateBox[{}, Reals]^n$ :

Wolfram Language code:

o = RandomVariate[CircularRealMatrixDistribution[4]];
{u, v} = RandomReal[1, {2, 4}];
OrthogonalMatrixQ[o] && u.v == (o.u).(o.v)

As a consequence, real orthogonal matrices preserve norms as well:

Wolfram Language code: Norm[u] == Norm[o.u]

Wolfram Language code: Norm[v] == Norm[o.v]

Any real-valued orthogonal matrix is unitary:

Wolfram Language code: m = Orthogonalize[RandomReal[1, {3, 3}]];

Wolfram Language code: {OrthogonalMatrixQ[m], UnitaryMatrixQ[m]}

But a complex unitary matrix is typically not orthogonal:

Wolfram Language code: m = Orthogonalize[RandomComplex[1 + I, {3, 3}]];

Wolfram Language code: {OrthogonalMatrixQ[m], UnitaryMatrixQ[m]}

Products of orthogonal matrices are orthogonal:

Wolfram Language code:

{m1, m2} = RandomVariate[CircularRealMatrixDistribution[3], 2];
{OrthogonalMatrixQ[m1], OrthogonalMatrixQ[m2]}

Wolfram Language code: OrthogonalMatrixQ[m1.m2]

A real-valued orthogonal matrix is normal:

Wolfram Language code: m = Orthogonalize[RandomReal[1, {3, 3}]];

Wolfram Language code: {OrthogonalMatrixQ[m], NormalMatrixQ[m]}

A complex-valued orthogonal matrix need not be normal:

Wolfram Language code:

c = (1/Sqrt[-1 - 2I])(|       |       |
| ----- | ----- |
| I - 1 | I     |
| I     | 1 - I |);

Wolfram Language code: {OrthogonalMatrixQ[c], NormalMatrixQ[c]}

Real-valued orthogonal matrices have eigenvalues that lie on the unit circle:

Wolfram Language code: m = RandomVariate[CircularRealMatrixDistribution[3]];

Wolfram Language code: OrthogonalMatrixQ[m]

Use Eigenvalues to find eigenvalues:

Wolfram Language code: Eigenvalues[m]

Verify they lie on the unit circle:

Wolfram Language code: Abs[%]

This does not apply to complex-valued orthogonal matrices:

Wolfram Language code:

c = (1/Sqrt[3]){{2, -I}, {I, 2}};
OrthogonalMatrixQ[c]

Wolfram Language code: Eigenvalues[c]

Real orthogonal matrices have a complete set of eigenvectors:

Wolfram Language code: m = RandomVariate[CircularRealMatrixDistribution[3]];

Wolfram Language code: OrthogonalMatrixQ[m]

As a consequence, they must be diagonalizable:

Wolfram Language code: DiagonalizableMatrixQ[m]

Use Eigenvectors to find eigenvectors:

Wolfram Language code: Eigenvectors[m]

A complex orthogonal matrix can fail to be diagonalizable:

Wolfram Language code:

c = (⁠|       |        |       |
| ----- | ------ | ----- |
| 1 + I | -1 + I | -1    |
| 1 - I | 1      | 1 + I |
| -1    | -1 - I | 1 - I |⁠);

Wolfram Language code: {OrthogonalMatrixQ[c], DiagonalizableMatrixQ[c]}

The singular values are all 1 for a real orthogonal matrix:

Wolfram Language code: m = Orthogonalize[RandomReal[1, {3, 3}]];

Wolfram Language code: OrthogonalMatrixQ[m]

Wolfram Language code: SingularValueList[m]

This need not be true for a complex orthogonal matrix:

Wolfram Language code:

c = (1/5Sqrt[3])(|        |        |
| ------ | ------ |
| 4 - 2I | 8 + I  |
| -8 - I | 4 - 2I |);

Wolfram Language code: OrthogonalMatrixQ[c]

Wolfram Language code: SingularValueList[c]

The determinant of an orthogonal matrix is 1 or :

Wolfram Language code: m = RandomVariate[CircularRealMatrixDistribution[3]];

Wolfram Language code: {OrthogonalMatrixQ[m], RealAbs[Det[m]]}

The 2-norm of a real orthogonal matrix is always 1:

Wolfram Language code: m = Orthogonalize[RandomReal[1, {3, 3}]];

Wolfram Language code: {OrthogonalMatrixQ[m], Norm[m]}

This need not be true for complex orthogonal matrices:

Wolfram Language code:

c = (1/5Sqrt[3])(⁠|          |         |
| -------- | ------- |
| 8 + I    | 4 - 2 I |
| -4 + 2 I | 8 + 1I  |⁠);

Wolfram Language code: {OrthogonalMatrixQ[c], Norm[c]}

Integer powers of orthogonal matrices are orthogonal:

Wolfram Language code: m = RandomVariate[CircularRealMatrixDistribution[3]];

Wolfram Language code: OrthogonalMatrixQ[m]

Wolfram Language code: UnitaryMatrixQ[MatrixPower[m, RandomInteger[{-10, 10}]]]

MatrixExp[m] for real antisymmetric m is both orthogonal and unitary:

Wolfram Language code:

m = Symmetrize[RandomReal[1, {5, 5}], Antisymmetric[{1, 2}]];
expm = MatrixExp[m];

Wolfram Language code: {OrthogonalMatrixQ[expm], UnitaryMatrixQ[expm]}

For complex antisymmetric m, the exponential is orthogonal but not, in general, unitary:

Wolfram Language code:

mc = Symmetrize[RandomComplex[1 + I, {5, 5}], Antisymmetric[{1, 2}]];
expmc = MatrixExp[mc];

Wolfram Language code: {OrthogonalMatrixQ[expmc], UnitaryMatrixQ[expmc]}

OrthogonalMatrix can be used to explicitly construct orthogonal matrices:

Wolfram Language code: OrthogonalMatrix[RandomVariate[CircularRealMatrixDistribution[3]]]

These satisfy OrthogonalMatrixQ:

Wolfram Language code: OrthogonalMatrixQ[%]

Possible Issues (1)

OrthogonalMatrixQ uses the definition $TemplateBox[{m}, Transpose].m=I_n$ for both real- and complex-valued matrices:

Wolfram Language code:

c = (1/Sqrt[-1 - 8 I])(⁠|          |          |
| -------- | -------- |
| I        | -2 + 2 I |
| -2 + 2 I | -I       |⁠);

Wolfram Language code: {OrthogonalMatrixQ[c] , c.c == IdentityMatrix[2]}

These complex matrices need not be normal or possess many properties of real orthogonal matrices:

Wolfram Language code: NormalMatrixQ[c]

UnitaryMatrixQ tests the more common definition $TemplateBox[{m}, ConjugateTranspose].m=I_n$ that ensures a complex matrix is normal:

Wolfram Language code: UnitaryMatrixQ[c]

Alternatively, test if the entries are real to restrict to real orthogonal matrices:

Wolfram Language code: orthogonalMatrixQ[m_] := OrthogonalMatrixQ[m] && Element[m, Reals]

Wolfram Language code: orthogonalMatrixQ[c]

Neat Examples (1)

Rotation matrices are orthogonal:

Wolfram Language code:

cow = ExampleData[{"Geometry3D", "Cow"}, "GraphicsComplex"];
p = {0, 0, -0.25161901116371155};

Wolfram Language code: Table[OrthogonalMatrixQ[RotationMatrix[k Pi / 4., {0, 0, 1}]], {k, -1, 1}]

Wolfram Language code:

Graphics3D[{EdgeForm[None], Opacity[0.5], Table[{Lighter[ColorData[97, k + 2]], GeometricTransformation[cow, {RotationMatrix[k Pi / 4., {0, 0, 1}], p}]}, {k, -1, 1}]}, Lighting -> "Neutral", ImageSize -> Large, Boxed -> False]

Top

More Learning

Tech Support

Data Science, Finance & Business

Engineering

Science & Technology

Technology for Education

Education Initiatives

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

OrthogonalMatrixQ

Details and Options

Examples

Basic Examples (2)

Scope (14)

Basic Uses (6)

Special Matrices (4)

Rectangular Semi-orthogonal Matrices (4)

Options (4)

Normalized (2)

SameTest (1)

Tolerance (1)

Applications (10)

Sources of Orthogonal Matrices (5)

Uses of Orthogonal Matrices (5)

Properties & Relations (14)

Possible Issues (1)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

OrthogonalMatrixQ

Details and Options

Examples

Basic Examples (2)

Scope (14)

Basic Uses (6)

Special Matrices (4)

Rectangular Semi-orthogonal Matrices (4)

Options (4)

Normalized (2)

SameTest (1)

Tolerance (1)

Applications (10)

Sources of Orthogonal Matrices (5)

Uses of Orthogonal Matrices (5)

Properties & Relations (14)

Possible Issues (1)

Neat Examples (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX