Linearna algebra
Colin Fahey
1. Software
LinearAlgebra.zip
Linearna algebra source code (C#)
19910 bytes
MD5: 11d8c8035cac30ba543e5e0b72ee9767
2. Uvod
U ovom se članku opisuje vektore i matrice u (d)-dimenzionalan prostor.
3. (d)-dimenzionalan prostor: atribute
3.1 Array
"polje:" Zbirka varijabli takvih da se svaka varijabla ima jedinstveno ime, i da takva imena mogu biti dodijeljena jedna narudžba.
Integer vrijednosti može se koristiti kao imena za varijable u niz.
Na primjer, ako polje sadrži (d) varijable, onda je cijeli broj vrijednosti { 0, 1, 2, ..., (d-1) } mogu biti nazivi dodjeljuju na varijable u polje.
3.2 (d)-dimenzionalan vektor
"(d)-dimenzionalan vektor:" niz (d) varijabli.
"vektorska komponenta:" varijablu unutar vektor.
3.3 (d)-dimenzionalan vektorski prostor
"jedne dimenzije prostora:" potpuni skup vrijednosti koje mogu biti pohranjene od strane jedne varijable.
"(d)-dimenzionalan prostor:" potpuni skup kombinacije vrijednosti koje mogu biti pohranjene po jedan niz (d) varijabli.
Formalna definicija jedan "vektorski prostor:"
Neka (T) biti osnovna tipa (primjeri: pravi broj, cijeli broj, kompleksni broj, racionalan broj, itd.).
Bilo koje varijable je osnovni tip se zove jedan "skalarni."
A "(T)-type (d)-dimenzionalan vektorski prostor" je skup (S) od (d)-dimenzionalan vektori imaju dvije operacije, vektor Osim (+), i skalar multiplication (*), zadovoljavanju uvjeta u nastavku:
(1) Ako (v) i (w) su bilo koje dvije vektori u (S), zatim (v + w) je također vektor u (S);
(2) Ako (u), (v), i (w) su vektori u bilo koje tri (S), zatim (u + v) + w = u + (v + w);
[additive commutativity]
(3) Ako (v) i (w) su bilo koje dvije vektori u (S), zatim (v + w) = (w + v);
[additive associativity]
(4) Postoji jedna "nula vektor," (0), u (S), tako da za bilo koji vektor (v) u (S), (v + (0)) = v;
[additive identiteta]
(5) Ako je bilo koji skalarni (c) tipa (T), i (v) je bilo koji vektor u (S), zatim proizvod (c * v) je vektor u (S);
(6) Ako (a), (b), i (c) su bilo koje scalars tipa (T), i (v) i (w) su bilo koji vektori u (S), zatim (a + b) * v = a*v + b*v, i c*(v + w) = c*v + c*w;
[multiplikativne distributivity]
(7) Ako (a) i (b) su scalars bilo kojeg tipa (T), i (v) je bilo koji vektor u (S), zatim (a*b)*v = a*(b*v);
(8) Ako "1" je skalar tipa (T) takva da (1*1)=1, i (v) je bilo koji vektor u (S), zatim (1*v) = v;
(9) Za svaki vektor (v) u (S), vektor (-1)*v = -v zadovoljava v + (-v) = (0);
[additive inverse]
3.4 (d)-dimenzionalan vektor kod
Kod ispod pokazuje kako (d)-dimenzionalan vektor, s 64-bitnim komponentama pokretni zarez, može biti implementirana.
Niz je dovoljno da predstavljaju vektor.
Kod ispod ima niz sadržane u razredu, samo za praktičnost.
Kod ne namjerava biti učinkovita.
A structure (primjer: "struct", upišite vrijednost) predstavljaju vektore a fiksni broj dimenzija (primjeri: 3 ili 4) je vjerojatno da će biti puno efikasniji od općeg (d)-dimenzionalan vektor klasa je ovdje prikazano.
Iako je kod ispod definira vektor s pokretni zarez komponente, ovaj dokument također koristi vektore s cijeli broj komponenti.
Kod ispod lako mogu biti izmijenjene kako bi se proveo sa vektori cijeli broj komponenti.
using System;
using System.Collections.Generic;
using System.Text;
// Multidimensional vector with 64-bit floating-point components:
public class VectorF64
{
private double[] components;
public int Dimensions()
{
if (null == this.components)
{
return (0);
}
return (this.components.Length);
}
public VectorF64()
{
this.components = null;
}
public VectorF64( params double[] paramValues )
{
this.components = null;
if (null == paramValues)
{
return;
}
int dimensions = paramValues.Length;
this.components = new double[dimensions];
for (int i = 0; i < dimensions; i++)
{
this.components[i] = paramValues[i];
}
}
public VectorF64( VectorF64 other )
{
this.components = null;
if (null == other)
{
return;
}
if (null == other.components)
{
return;
}
int dimensions = other.Dimensions();
this.components = new double[dimensions];
for (int i = 0; i < dimensions; i++)
{
this.components[i] = other.components[i];
}
}
public double this[int index]
{
get
{
if (null == this.components)
{
return (0.0);
}
if
(
(index >= 0)
&& (index < this.components.Length)
)
{
return (this.components[index]);
}
return (0.0);
}
set
{
if (null == this.components)
{
return;
}
if
(
(index >= 0)
&& (index < this.components.Length)
)
{
this.components[index] = value;
}
}
}
public void Write( int precision )
{
if (null == this.components)
{
Log.Write( String.Empty + '(' + ' ' + ')' );
return;
}
int dimensions = this.Dimensions();
if (0 == dimensions)
{
Log.Write( String.Empty + '(' + ' ' + ')' );
return;
}
// Determine the largest component width in characters
// so that we can make all components an equal width.
int largestComponentWidth = 1;
for (int i = 0; i < dimensions; i++)
{
// { index [,minwidth] [:typeCode[precision]] }
// (minwidth<0) means left-justify
String text = String.Format( String.Empty + '{' + '0' + ':'
+ 'g' + precision + '}', this[i] );
if (text.Length > largestComponentWidth)
{
largestComponentWidth = text.Length;
}
}
Log.Write( '(' );
for (int i = 0; i < dimensions; i++)
{
Log.Write( ' ' );
String text =
String.Format( String.Empty + '{' + '0' + ','
+ largestComponentWidth + ':' + 'g' + precision + '}',
this[i] );
Log.Write( text );
if ((i + 1) < dimensions)
{
Log.Write( ',' );
}
else
{
Log.Write( ' ' );
}
}
Log.Write( ')' );
}
public void WriteLine( int precision )
{
this.Write( precision );
Log.WriteLine();
}
public void WriteLine()
{
const int defaultPrecision = 8;
this.Write( defaultPrecision );
Log.WriteLine();
}
// . . .
public static void Test()
{
// A 3-dimensional vector with 64-bit floating-point components:
VectorF64 v3 = new VectorF64( 0.0, 1.0, 2.0 );
v3.WriteLine(); // ( 0, 1, 2 )
// A 4-dimensional vector with 64-bit floating-point components:
VectorF64 v4 = new VectorF64( 0.0, 1.0, 2.0, 3.0 );
v4.WriteLine(); // ( 0, 1, 2, 3 )
// . . .
}
}
"(d) nula-dimenzionalan vektor:" vektor sa svim (d) komponente jednaka nuli.
public class VectorF64
{
// . . .
public static VectorF64 Zero( int dimensions )
{
VectorF64 zero = new VectorF64();
zero.components = new double[dimensions];
for (int i = 0; i < dimensions; i++)
{
zero[i] = 0.0;
}
return (zero);
}
// . . .
public static void Test()
{
// . . .
// An 8-dimensional vector with all 8 64-bit floating-point
// components set to zero:
VectorF64 z = VectorF64.Zero( 8 );
z.WriteLine(); // ( 0, 0, 0, 0, 0, 0, 0, 0 )
// . . .
}
}
3.5 (d)-dimenzionalan prostor: boda
"(d)-dimenzionalan prostor point:" niz (d) varijabli s određene vrijednosti "(koordinirati vrijednosti)."
"(d)-dimenzionalan prostor porijekla:" niz (d) varijabli sa svih vrijednosti jednaka nuli.
3.6 (d)-dimenzionalan vektori: non-relativna i relativna
A (d)-dimenzionalan vektor koji je "non-relativna" je (d)-dimenzionalan vektor koji izravno predstavlja status ili oblik.
A (d)-dimenzionalan vektor koji je "relativna" je (d)-dimenzionalan vektor koji predstavlja promjene na set komponenti.
Relativni vektor može predstavljati razliku između dva relativna ne-vektori.
S obzirom na relativnu vektor, koji određuju ne-relativni status ili konfiguracije koje koristite u odnosu vektor zahtijeva da se kombiniranjem relativna vektor s non-relativna vektor.
Non-vektori relativne i relativna vektori su i vektori.
Da li se određeni vektor je non-relativna ili relativna mora biti naveden kada je vektor je definiran.
Ako (d)-dimenzionalan vektor se tumačiti kao da su ne-relativna, onda (d)-dimenzionalan vektor može predstavljati točku u (d)-dimenzionalan prostor.
3.7 (d)-dimenzionalan vektor addition, subtraction, i skaliranje
Vector addition, subtraction, i skaliranje:
public class VectorF64
{
// . . .
public static VectorF64 operator +( VectorF64 a, VectorF64 b )
{
if ((null == a) ¦¦ (null == b))
{
return (new VectorF64()); // Vector not specified.
}
if ((null == a.components) ¦¦ (null == b.components))
{
return (new VectorF64()); // Vector is empty.
}
if (a.Dimensions() != b.Dimensions())
{
return (new VectorF64()); // Vectors not the same size.
}
int dimensions = a.Dimensions();
VectorF64 result = VectorF64.Zero( dimensions );
for (int i = 0; i < dimensions; i++)
{
result[i] = a[i] + b[i];
}
return (result);
}
public static VectorF64 operator -( VectorF64 a, VectorF64 b )
{
if ((null == a) ¦¦ (null == b))
{
return (new VectorF64()); // Vector not specified.
}
if ((null == a.components) ¦¦ (null == b.components))
{
return (new VectorF64()); // Vector is empty.
}
if (a.Dimensions() != b.Dimensions())
{
return (new VectorF64()); // Vectors not the same size.
}
int dimensions = a.Dimensions();
VectorF64 result = VectorF64.Zero( dimensions );
for (int i = 0; i < dimensions; i++)
{
result[i] = a[i] - b[i];
}
return (result);
}
public static VectorF64 operator -( VectorF64 a )
{
if (null == a)
{
return (new VectorF64()); // Vector not specified.
}
if (null == a.components)
{
return (new VectorF64()); // Vector is empty.
}
int dimensions = a.Dimensions();
VectorF64 result = VectorF64.Zero( dimensions );
for (int i = 0; i < dimensions; i++)
{
result[i] = (-( a[i] ));
}
return (result);
}
public static VectorF64 operator *( double scale, VectorF64 a )
{
if (null == a)
{
return (new VectorF64()); // Vector not specified.
}
if (null == a.components)
{
return (new VectorF64()); // Vector is empty.
}
int dimensions = a.Dimensions();
VectorF64 result = VectorF64.Zero( dimensions );
for (int i = 0; i < dimensions; i++)
{
result[i] = scale * a[i];
}
return (result);
}
public static VectorF64 operator *( VectorF64 a, double scale )
{
if (null == a)
{
return (new VectorF64()); // Vector not specified.
}
if (null == a.components)
{
return (new VectorF64()); // Vector is empty.
}
int dimensions = a.Dimensions();
VectorF64 result = VectorF64.Zero( dimensions );
for (int i = 0; i < dimensions; i++)
{
result[i] = scale * a[i];
}
return (result);
}
// . . .
public static void Test()
{
// . . .
// Examples of vector addition, subtraction, and scaling:
VectorF64 a = new VectorF64( 0.0, 1.0, 2.0, 3.0 );
a.WriteLine(); // ( 0, 1, 2, 3 )
VectorF64 b = new VectorF64( 3.0, 2.0, 1.0, 0.0 );
b.WriteLine(); // ( 3, 2, 1, 0 )
VectorF64 c = new VectorF64();
c.WriteLine(); // ( )
c = a + b;
c.WriteLine(); // ( 3, 3, 3, 3 )
c = a - b;
c.WriteLine(); // ( -3, -1, 1, 3 )
c = -b;
c.WriteLine(); // ( -3, -2, -1, 0 )
c = 3.0 * a;
c.WriteLine(); // ( 0, 3, 6, 9 )
// . . .
}
}
3.8 (d)-dimenzionalan temelju vektori
Formalne definicije na "temelju" jedan vektorski prostor:
Neka (T) biti osnovna tipa (primjeri: pravi broj, cijeli broj, kompleksni broj, racionalan broj, itd.).
Bilo koje varijable je osnovni tip se zove jedan "skalarni."
Neka (V) biti "(T)-type (d)-dimenzionalan vektorski prostor."
Ako je različit od nule vektori { u1, u2, ..., ud } u (V) su takve da je svaki vektor (v) u (V) se može zapisati kao "linearna kombinacija" od one vektore, v = c1*u1 + c2*u2 + ... + cd*ud, gdje { c1, c2, ..., cd } su scalars tipa (T), zatim (V) je "spojeni" by vektori { u1, u2, ..., ud }.
Bilo koji skup ne-nula vektori { u1, u2, ..., ud } da "span" vektorski prostor (V) se zove "temelju" (V).
Jedan jednostavan "osnovu" jednog (d)-dimenzionalan vektorski prostor je skup (d) različita (d)-dimenzionalan vektore, svaki s jedne komponenta jednaka jedan i sve ostale komponente jednaka nuli.
Takva osnova vektori su "orthonormal," što znači da su međusobno-okomica "(ortogonalni)" i da je svaki vektor je jedinica duljine.
Svaki takav vektor je jedinični vektor paralelan jednoj od koordinatnih osi (d).
Izražavanje proizvoljnog vektor kao "linearna kombinacija" tih osnova je vektore direktne; svaku komponentu od proizvoljan vektor je pomnožen s odgovarajućim temelju vektor, i tih proizvoda zbroje da se formira na proizvoljnim vektor.
Kod ispod pokazuje kako se vektor može se izraziti kao "linearna kombinacija" temelju vektori.
Kod ispod proizvoljno definira jedan orthonormal set temelju vektori.
public class VectorF64
{
// . . .
public static VectorF64 BasisVector( int dimensions, int componentIndex )
{
if (dimensions < 0)
{
// Invalid number of dimensions specified.
return (new VectorF64());
}
VectorF64 basisVector = VectorF64.Zero( dimensions );
if ((componentIndex >= 0) && (componentIndex < dimensions))
{
basisVector[ componentIndex ] = 1.0;
}
return (basisVector);
}
// . . .
public static void Test()
{
// . . .
// The 4 basis vectors of 4-dimensional space,
// each with 4 64-bit floating-point components:
VectorF64 b0 = VectorF64.BasisVector( 4, 0 );
b0.WriteLine(); // ( 1, 0, 0, 0 )
VectorF64 b1 = VectorF64.BasisVector( 4, 1 );
b1.WriteLine(); // ( 0, 1, 0, 0 )
VectorF64 b2 = VectorF64.BasisVector( 4, 2 );
b2.WriteLine(); // ( 0, 0, 1, 0 )
VectorF64 b3 = VectorF64.BasisVector( 4, 3 );
b3.WriteLine(); // ( 0, 0, 0, 1 )
// . . .
}
}
Bilo koji vektor u (d)-dimenzionalan prostor može se izraziti kao zbroj proizvode brojevi i vektori osnovu:
public class VectorF64
{
// . . .
public static void Test()
{
// . . .
// The following two vectors are equivalent:
// A 4-dimensional vector with 64-bit floating-point components:
VectorF64 va = new VectorF64( 0.1, 1.1, 2.2, 3.3 );
va.WriteLine(); // ( 0.1, 1.1, 2.2, 3.3 )
// A 4-dimensional vector formed by scaling the 4 independent
// basis vectors for 4-dimensional space:
VectorF64 vb =
0.1 * VectorF64.BasisVector( 4, 0 )
+ 1.1 * VectorF64.BasisVector( 4, 1 )
+ 2.2 * VectorF64.BasisVector( 4, 2 )
+ 3.3 * VectorF64.BasisVector( 4, 3 );
vb.WriteLine(); // ( 0.1, 1.1, 2.2, 3.3 )
// . . .
}
}
3.9 (d)-dimenzionalan prostor: udaljenost između točaka
Neka (P) biti (d)-dimenzionalan vektor koji predstavlja točku u (d)-dimenzionalan prostor.
Neka (Q) biti (d)-dimenzionalan vektor koji predstavlja točku u (d)-dimenzionalan prostor.
Neka (R) biti (d)-dimenzionalan vektor koji predstavlja promjenu u (d) koordinate kako bi dobili (P) iz točke do točke (Q); R = (Q - P).
U jednom-dimenzionalan prostor, P = ( p0 ), Q = ( q0 ), i R = (Q - P) = ( q0 - p0 ).
Udaljenost između dvije točke je: Abs( q0 - p0 ).
U dvodimenzionalni prostor, P = ( p0, p1 ), Q = ( q0, q1 ), i R = (Q - P) = ( q0-p0, q1-p1 ).
Tumačenje dva okomita raseljavanja kao okomita strane pravo-trokut, udaljenost između točaka odgovara na dužini od hypotenuse tog trokuta.
The Pythagorean formula, (a*a) + (b*b) = (c*c), gdje (a) i (b) su duljina od okomica strane pravo-trokut, i (c) je duljina od hypotenuse (izvrtati strani), može se koristiti da biste utvrdili je udaljenost između dvije točke: Sqrt( Sq(q0-p0) + Sq(q1-p1) ).
U trodimenzionalnom prostoru, P = ( p0, p1, p2 ), Q = ( q0, q1, q2 ), i R = (Q - P) = ( q0-p0, q1-p1, q2-p2 ).
Tumačenje displacement ( q0-p0, q1-p1, 0 ) kao okomita strane pravo-trokut, i koristeći Pythagorean formula, daje udaljenost između točke (P) i točka ( q0, q1, p2 ): d01 = Sqrt( Sq(q0-p0) + Sq(q1-p1) ).
The displacement ( q0-p0, q1-p1, 0 ) je okomita na displacement ( 0, 0, q2-p2 ), a drugi s desna trokut može biti formirana, a Pythagorean formula se može koristiti ponovno.
Ovako, udaljenost od točke do točke (P) je (Q) given by: Sqrt( Sq(d01) + Sq(q2-p2) ) = Sqrt( (Sq(q0-p0) + Sq(q1-p1)) + Sq(q2-p2) ) = Sqrt( Sq(q0-p0) + Sq(q1-p1) + Sq(q2-p2) ).
The method of produžuje na udaljenost od formula dvodimenzionalni prostor na trodimenzionalni prostor može se primijeniti više puta kako bi konačno utvrdili udaljenost formula za (d)-dimenzionalan prostor: Sqrt( (Sq(q0-p0) + Sq(q1-p1)) + Sq(q2-p2) + ... + Sq(qd-pd) ).
Kod ispod definira funkcija zove "dužina" koja računa na dužinu od (d)-dimenzionalan vektor.
Kad vektor predstavlja pomak između dvije točke u (d)-dimenzionalan prostor, u dužini od vektor predstavlja udaljenost između ta dva boda.
public class VectorF64
{
// . . .
public double Length()
{
if (null == this.components)
{
return (0.0); // Vector empty.
}
int dimensions = this.Dimensions();
double sumOfSquares = 0.0;
for (int i = 0; i < dimensions; i++)
{
sumOfSquares += (this[i] * this[i]);
}
double length = Math.Sqrt( sumOfSquares );
return (length);
}
public static double Length( VectorF64 a )
{
if (null == a)
{
return (0.0); // Vector not specified.
}
if (null == a.components)
{
return (0.0); // Vector is empty.
}
return (a.Length());
}
// . . .
public static void Test()
{
// . . .
// Example of vector length:
// A 6-dimensional vector representing a point (p):
VectorF64 p = new VectorF64( 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 );
p.WriteLine(); // ( 0, 1, 2, 3, 4, 5 )
// A 6-dimensional vector representing a point (q):
VectorF64 q = new VectorF64( -5.0, 4.0, -3.0, 2.0, -1.0, 0.0 );
q.WriteLine(); // ( -5, 4, -3, 2, -1, 0 )
// A 6-dimensional vector representing the displacement
// from point (p) to point (q):
VectorF64 r = q - p;
r.WriteLine(); // ( -5, 3, -5, -1, -5, -5 )
// The distance between point (p) and point (q)
// in 6-dimensional space:
double distance = r.Length();
Log.WriteLine( distance ); // 10.4880884817015
// . . .
}
}
3.10 (d)-dimenzionalan vektori: skalarni produkt
Je "skalarni produkt" dva pretvara (d)-dimenzionalan vektori na broj.
Kod ispod jednog računa skalarni produkt dva vektori:
public class VectorF64
{
// . . .
public static double Dot( VectorF64 a, VectorF64 b )
{
if ((null == a) ¦¦ (null == b))
{
return (0.0); // Vector not specified.
}
if ((null == a.components) ¦¦ (null == b.components))
{
return (0.0); // Vector is empty.
}
if (a.Dimensions() != b.Dimensions())
{
return (0.0); // Vectors not the same size.
}
int dimensions = a.Dimensions();
double dotProduct = 0.0;
for (int i = 0; i < dimensions; i++)
{
dotProduct += (a[i] * b[i]);
}
return (dotProduct);
}
// . . .
}
Za bilo koji vektor, (A), Length(A) = Sqrt(Dot(A,A)).
3.11 (d)-dimenzionalan vektori: definicija "parallel"
Vektori (A) i (B) su "paralelno" ako se sve sljedeće su istinite:
(1) A.Length() > 0;
(2) B.Length() > 0;
(3) Abs(Dot(A,B)) = A.Length()*B.Length().
Kod ispod određuje ako par vektori su paralelno (eventualno anti-uskladio).
Floating-point brojevi mogu akumulirati pogreške u djelomični dio s obzirom na ograničene preciznosti, i, dakle, računalo kod bi trebao uključivati ne-nula tolerances Kada uspoređujete s pomičnim-point brojevima.
Kod uključuje primjer tolerancije vrijednosti, ali je primjer tolerancije vrijednosti ne bi mogli biti prikladni za neke zadatke.
public class VectorF64
{
// . . .
public static bool Parallel( VectorF64 a, VectorF64 b )
{
// Smallest normalized float : 1.1754943e-38
// Smallest normalized double: 2.2250738585072020e-308
double nonZeroThreshold = 1.0e-38; // conservative for double
// double: (52+1)-bit mantissa; log10(2^53)=15.95 decimal digits
double fractionalDifferenceThreshold = 1.0e-14; // conservative
if ((null == a) ¦¦ (null == b))
{
return (false); // Vector is not specified.
}
if ((null == a.components) ¦¦ (null == b.components))
{
return (false); // Vector is empty.
}
if (a.Dimensions() != b.Dimensions())
{
return (false); // Vectors not the same size.
}
double lengthA = a.Length();
if (lengthA <= nonZeroThreshold)
{
return (false);
}
double lengthB = b.Length();
if (lengthB <= nonZeroThreshold)
{
return (false);
}
double oneImpliesParallel =
Math.Abs( VectorF64.Dot( a, b ) ) / (lengthA * lengthB);
double absoluteDifferenceFromOne =
Math.Abs( oneImpliesParallel - 1.0 );
if (absoluteDifferenceFromOne <= fractionalDifferenceThreshold)
{
return (true);
}
return (false);
}
// . . .
public static void Test()
{
// . . .
// Example of testing for parallel vectors:
// A 6-dimensional vector:
VectorF64 vf = new VectorF64( 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 );
vf.WriteLine(); // ( 0, 1, 2, 3, 4, 5 )
// A 6-dimensional vector:
VectorF64 vg = new VectorF64( 0.0, -2.0, -4.0, -6.0, -8.0, -10.0 );
vg.WriteLine(); // ( 0, -2, -4, -6, -8, -10 )
// Determine if the specified vectors are parallel
// (or "anti-aligned"):
bool parallel = VectorF64.Parallel( vf, vg );
Log.WriteLine( parallel ); // True
// Add a non-negligible displacement to a component of a vector:
vf[0] += 1.0e-5;
vf.WriteLine(); // ( 1E-05, 1, 2, 3, 4, 5 )
// Determine if the specified vectors are parallel
// (or "anti-aligned"):
parallel = VectorF64.Parallel( vf, vg );
Log.WriteLine( parallel ); // False
// . . .
}
}
3.12 (d)-dimenzionalan vektori: definicija "okomica"
Vektori (A) i (B) su "okomica" ako sve sljedeće su istinite:
(1) A.Length() > 0;
(2) B.Length() > 0;
(3) Abs(Dot(A,B)) = 0.
Kod ispod određuje ako par su vektori okomit. Floating-point brojevi mogu akumulirati pogreške u djelomični dio s obzirom na ograničene preciznosti, i, dakle, računalo kod bi trebao uključivati ne-nula tolerances Kada uspoređujete s pomičnim-point brojevima.
Kod uključuje primjer tolerancije vrijednosti, ali je primjer tolerancije vrijednosti ne bi mogli biti prikladni za neke zadatke.
public class VectorF64
{
// . . .
public static bool Perpendicular( VectorF64 a, VectorF64 b )
{
// Smallest normalized float : 1.1754943e-38
// Smallest normalized double: 2.2250738585072020e-308
double nonZeroThreshold = 1.0e-38; // conservative for double
// double: (52+1)-bit mantissa; log10(2^53)=15.95 decimal digits
double fractionalDifferenceThreshold = 1.0e-14; // conservative
if ((null == a) ¦¦ (null == b))
{
return (false); // Vector is not specified.
}
if ((null == a.components) ¦¦ (null == b.components))
{
return (false); // Vector is empty.
}
if (a.Dimensions() != b.Dimensions())
{
return (false); // Vectors not the same size.
}
double lengthA = a.Length();
if (lengthA <= nonZeroThreshold)
{
return (false);
}
double lengthB = b.Length();
if (lengthB <= nonZeroThreshold)
{
return (false);
}
double zeroImpliesPerpendicular =
Math.Abs( VectorF64.Dot( a, b ) ) / (lengthA * lengthB);
double absoluteDifferenceFromZero =
Math.Abs( zeroImpliesPerpendicular );
if (absoluteDifferenceFromZero <= fractionalDifferenceThreshold)
{
return (true);
}
return (false);
}
// . . .
public static void Test()
{
// . . .
// Example of testing for perpendicular vectors:
// A 6-dimensional vector:
VectorF64 vf2 = new VectorF64( 0.0, 1.0, 2.0, 0.0, 4.0, 5.0 );
vf2.WriteLine(); // ( 0, 1, 2, 0, 4, 5 )
// A 6-dimensional vector:
VectorF64 vg2 = new VectorF64( 10.0, 0.0, 0.0, -5.0, 0.0, 0.0 );
vg2.WriteLine(); // ( 10, 0, 0, -5, 0, 0 )
// Determine if the specified vectors are perpendicular
bool perpendicular = VectorF64.Perpendicular( vf2, vg2 );
Log.WriteLine( perpendicular ); // True
// Add a non-negligible displacement to a component of a vector:
vf2[0] += 1.0e-13;
vf2.WriteLine(); // ( 1E-13, 1, 2, 0, 4, 5 )
// Determine if the specified vectors are perpendicular
perpendicular = VectorF64.Perpendicular( vf2, vg2 );
Log.WriteLine( perpendicular ); // False
// . . .
}
}
3.13 Matrice
"matrica:" A collection of varijabli takvih da se svaka varijabla ima jedinstvenu kombinaciju za "redom" ime i ime "stupca."
"unos:" varijablu unutar matrica.
Integer vrijednosti može se koristiti kao "red" i imena "stupca" imena za varijable u matrica.
Na primjer, ako je matrica (totalRows) retke i stupce (totalColumns), onda je cijeli broj vrijednosti { 0, 1, ..., (totalRows-1) } mogu biti nazivi dodjeljuju na redaka, i cijeli vrijednosti { 0, 1, ..., (totalColumns-1) } mogu biti dodijeljena imena stupaca.
Dakle, varijable u matrica može biti specificiran po izrijekom par integers, ( row, column ), ukazuju na kombinaciju redak i stupac indeksi odgovaraju specifičnim varijable.
Veličina jedna matrica je naveden kao "(totalRows) * (totalColumns)" (ili "(totalRows) by (totalColumns))."
Ovaj redoslijed je dimenzija ista kao i redoslijed dimenzije koristiti da biste naveli unose u matrica "(( row, column ))."
[Ovaj ugovor je pomalo nesretan, jer je za mnoge dvodimenzionalni koristi (primjeri: slike, grafikoni, etc) uobičajene konvencije je navesti dimenzije kao "width * height" i koordinate kao "( horizontal, vertical )" (ili "( x, y ))."
To je suprotno od reda dimenzija i koordinata koristi za opisivanje matrice i njihova unosa. ]
A matrica s (totalRows) jednaka (totalColumns) se zove "trg," na neki drugi način, matrica se zove "pravokutni."
A matrica može se smatrati sadrži skup "vektori redom," gdje su varijable u svaki red se tumačiti kao da pripadaju jednoj vektor.
A matrica također može smatrati sadrži niz "stupac vektori," gdje su varijable u svakom stupcu se tumačiti kao da pripadaju jednoj vektor.
Matrice može zastupati širok izbor matematičkih odnosa.
Značenje od matrica i operacije koje bi mogle biti prikladne za obradu entries od matrica, ovisi o kontekstu.
Međutim, postoje osnovna pravila matrica aritmetička koje su relevantne za mnogim kontekstima, i tih osnovnih pravila biti će definirani u kasniji dio.
Razvrstati i (totalColumns) vrijednosti su dovoljne da predstavljaju matrica.
U polje može imati (totalRows * totalColumns) varijabli, i ulazak u ( row, column ) možete odgovarati na varijabla u indeks ((totalColumns * row) + column).
Kod ispod definira matrica, s 64-bitnim plutajuće-točka unosa.
Razvrstati i (totalColumns) vrijednosti su dovoljne da predstavljaju matrica.
Kod ispod je razvrstati i (totalColumns) vrijednosti sadržane u razredu, samo za praktičnost.
The code ispod ne namjerava biti učinkovita.
A structure (primjer: "struct", upišite vrijednost) predstavljaju matrice određenih fiksnih dimenzija (primjeri: 2*2, 3*3, ili 4*4) je vjerojatno da će biti puno efikasniji od općeg (totalRows * totalColumns) klasa je ovdje prikazano.
Iako je kod ispod definira matrica s pomičnim-točka unosa, u ovom članku također omogućuje korištenje matrice s cijeli broj unosa.
Kod ispod mogu biti lako modificirana kako bi se proveo cijeli matrice s entries.