English  Español  Português  Français  Italiano  Deutsch  Nederlands  Svenska  Dansk  Suomi  Norsk  Русский  Polski  Română  Български  Hrvatski  Česky  中国  中國  日本語  한국어  Ελληνική  हिन्दी  العربية 

रैखिक बीजगणित

Colin Fahey

यह लेख का वर्णन और वैक्टर matrices में (d) - आयामी स्थान है .

"श्रेणी" : एक संग्रह है कि इस तरह के प्रत्येक के लिए विभिन्न चर ने एक अनूठा नाम है , और है कि इस तरह के एक आदेश के नाम आवंटित किया जा सकता है .

पूर्णांक मान के रूप में इस्तेमाल किया जा सकता है नाम के लिए एक सरणी में चर .

उदाहरण के लिए , यदि एक सरणी में (d) चर , तो पूर्णांक मान हो सकता है { 0, 1, 2, ..., (d-1) } के नाम आवंटित करने के लिए विभिन्न श्रेणी के हैं .

"(d) - आयामी सदिश" : एक सरणी के (d) चर .

"सदिश घटक" : एक चर के भीतर एक सदिश .

"एक आयामी स्थान" : पूरा सेट मूल्यों के द्वारा संग्रहित किया जा सकता है कि एक परिवर्तनशील है .

"(d) - आयामी स्थान" : पूरा सेट के मूल्यों के संयोजन के द्वारा संग्रहित किया जा सकता है कि एक तरह की (d) चर .

इस परिभाषा के एक औपचारिक "सदिश स्थान" :

नीचे दिए गए कोड से पता चलता है कि किस तरह एक (d) - आयामी सदिश के साथ 64 सूत्री बिट चल घटकों , कार्यान्वित किया जा सकता है .

एक श्रेणी का प्रतिनिधित्व करने के लिए एक सदिश पर्याप्त है .

नीचे दिए गए कोड में एक वर्ग की श्रेणी में एक , केवल सुविधा के लिए है .

इस कोड को कुशल उद्देश्य नहीं है .

एक संरचना ( उदाहरण : "struct" , एक मान प्रकार ) का प्रतिनिधित्व करने का एक निर्धारित संख्या में वैक्टर आयाम ( उदाहरण : 3 या 4 ) होने की संभावना है की तुलना में काफी अधिक कुशल (d) सामान्य वर्ग के आयामी सदिश कि यहाँ दिखाया गया है .

हालाँकि नीचे दिए गए कोड को परिभाषित सदिश के साथ चल बिन्दु एक घटक है , के उपयोग की भी इस दस्तावेज़ के साथ वैक्टर पूर्णांक घटक हैं .

आसानी से किया जा सकता है नीचे दिए गए कोड को लागू करने के लिए संशोधित वैक्टर पूर्णांक के साथ घटक हैं .

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) - आयामी शून्य सदिश" : एक सदिश के साथ (d) सभी घटकों को शून्य के बराबर है .

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 )


        // . . .
    }
}

"(d) - आयामी अंतरिक्ष बिंदु" : सरणी के (d) चर के साथ एक विशेष मूल्यों ( "समन्वय मान" ) .

"(d) आयामी के मूल स्थान" : एक सरणी के (d) चर के साथ सभी मूल्यों को शून्य के बराबर है .

एक सदिश (d) - आयामी है कि "गैर सापेक्ष" है (d) - आयामी सदिश का प्रतिनिधित्व करता है कि एक स्थिति या सीधे विन्यास .

एक (d) के "सापेक्ष" है कि सदिश आयामी है (d) - आयामी सदिश का प्रतिनिधित्व करता है कि बदलाव का एक सेट करने के घटक हैं .

सदिश का प्रतिनिधित्व कर सकते हैं एक रिश्तेदार के बीच फर्क दो गैर वैक्टर सापेक्ष है .

सदिश एक रिश्तेदार को देखते हैं , एक गैर रिश्तेदार को निर्धारित स्थिति या विन्यास संयोजन का उपयोग करने की आवश्यकता होती है कि रिश्तेदार सदिश है कि रिश्तेदार सदिश के साथ एक गैर सदिश सापेक्ष है .

गैर सापेक्ष वैक्टर वैक्टर रिश्तेदार हैं और दोनों वैक्टर .

क्या किसी विशेष सदिश गैर सापेक्ष है या सापेक्ष निर्दिष्ट किया जाना चाहिए जब सदिश परिभाषित किया है .

यदि एक से (d) आयामी सदिश के रूप में व्याख्या की जा रही है न रिश्तेदार , तो (d) - आयामी सदिश का प्रतिनिधित्व कर सकते हैं (d) में एक बिंदु का स्थान आयामी है .

सदिश राशि के अतिरिक्त , घटाव , और स्केलिंग :

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 )


        // . . .
    }
}

इस परिभाषा के "आधार" औपचारिक सदिश एक स्थान :

एक साधारण "आधार" (d) - आयामी सदिश एक स्थान है (d) अलग सेट (d) - आयामी वैक्टर , प्रत्येक के साथ एक घटक के बराबर है और एक अन्य सभी घटकों को शून्य के बराबर है .

इस तरह के आधार वैक्टर "orthonormal" हैं , जिसका अर्थ है कि वे परस्पर - सीधा ( "orthogonal" ) और सदिश है कि प्रत्येक इकाई लम्बाई है .

हर एक ऐसी इकाई है सदिश सदिश समानांतर (d) के लिए एक समन्वय axes .

एक सदिश के रूप में व्यक्त करते मनमानी "रैखिक संयोजन" के आधार वैक्टर है इन प्रत्यक्ष , प्रत्येक घटक की मनमानी है सदिश गुणा की इसी आधार सदिश , एक साथ जुड़ जाते हैं और इन उत्पादों के रूप में की मनमानी सदिश .

नीचे दिए गए कोड से पता चलता है कि किस तरह एक सदिश के रूप में व्यक्त किया जा सकता है "रैखिक" वैक्टर "संयोजन" के आधार है .

नीचे दिए गए कोड मनमाने ढंग से परिभाषित एक सेट orthonormal वैक्टर आधार है .

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 )


        // . . .
    }
}

सदिश में से कोई भी (d) आयामी स्थान के रूप में व्यक्त किया जा सकता है की राशि के उत्पादों के आधार संख्या और वैक्टर :

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 )


        // . . .
    }
}

आइए एक (d) - (P) आयामी सदिश का प्रतिनिधित्व करता है कि एक बिंदु में (d) - आयामी स्थान है .

आइए एक (d) - (Q) आयामी सदिश का प्रतिनिधित्व करता है कि एक बिंदु में (d) - आयामी स्थान है .

आइए एक (d) - (R) आयामी सदिश में परिवर्तन का प्रतिनिधित्व करता है कि (d) निर्देशांक पाने के लिए (P) से बात करने की बात (Q) ; R = (Q - P) .

अंतरिक्ष में एक आयामी , P = ( p0 ) , Q = ( q0 ) , और R = (Q - P) = ( q0 - p0 ) .

दोनों के बीच की दूरी कहते है : Abs( q0 - p0 ) .

अंतरिक्ष में दो आयामी , P = ( p0, p1 ) , Q = ( q0, q1 ) , और R = (Q - P) = ( q0-p0, q1-p1 ) .

व्याख्या के रूप में दो displacements सीधा सीधा पक्षों के अधिकार के त्रिकोण में , दूरी के बीच के अंक से मेल खाता है कि लंबाई के कर्ण के त्रिकोण है .

यह फार्मूला Pythagorean , (a*a) + (b*b) = (c*c) , जहां (a) हैं और (b) की लंबाई के पक्ष में सीधा के त्रिकोण का अधिकार है , और (c) है लंबाई के कर्ण ( तिरछा पक्ष ) , को निर्धारित करने के लिए प्रयोग किया जा सकता है कि दोनों के बीच की दूरी अंक : Sqrt( Sq(q0-p0) + Sq(q1-p1) ) .

अंतरिक्ष में तीन आयामी , P = ( p0, p1, p2 ) , Q = ( q0, q1, q2 ) , और R = (Q - P) = ( q0-p0, q1-p1, q2-p2 ) .

( q0-p0, q1-p1, 0 ) के रूप में व्याख्या के विस्थापन का सीधा पक्षों के त्रिकोण का अधिकार है , और फार्मूला का प्रयोग कर Pythagorean , देता है (P) बिन्दु के बीच की दूरी और बिंदु ( q0, q1, p2 ) : d01 = Sqrt( Sq(q0-p0) + Sq(q1-p1) ) .

इस विस्थापन ( q0-p0, q1-p1, 0 ) को विस्थापन ( 0, 0, q2-p2 ) सीधा है , और एक अन्य दाएँ त्रिकोण का गठन किया जा सकता है , और फार्मूला Pythagorean फिर से इस्तेमाल किया जा सकता है .

इस प्रकार , (P) दूरी से बात करने के लिए (Q) बिंदु के द्वारा दी जाती है : 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) ) .

इस विधि को विस्तार से फार्मूले की दूरी दो आयामी करने के लिए तीन आयामी जगह जगह पर लागू किया जा सकता है बार बार की दूरी तय करने के लिए अंततः फार्मूला के लिए अंतरिक्ष (d) - आयामी : Sqrt( (Sq(q0-p0) + Sq(q1-p1)) + Sq(q2-p2) + ...  + Sq(qd-pd) ) .

नीचे दिए गए कोड को परिभाषित एक समारोह का नाम है जो "लम्बाई" computes की लंबाई एक सदिश (d) - आयामी है .

जब एक सदिश का प्रतिनिधित्व करता है विस्थापन के बीच दो अंकों में (d) - आयामी अंतरिक्ष , सदिश लम्बाई का प्रतिनिधित्व करता है उन लोगों के बीच दूरी की दो बातें हैं .

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


        // . . .
    }
}

इस "उत्पाद को" धर्मान्तरित "डॉट" (d) के दो आयामी वैक्टर करने के लिए एक संख्या है .

इस कोड के नीचे एक computes डॉट उत्पाद के दो वैक्टर :

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);
    }




    // . . .
}

सदिश के लिए किसी भी , (A) , Length(A) = Sqrt(Dot(A,A)) .

वैक्टर (A) और (B) "समानांतर" हैं तो सभी निम्नांकित के सही हैं :

( 1 ) A.Length() > 0 ;

( 2 ) B.Length() > 0 ;

( 3 ) Abs(Dot(A,B)) = A.Length()*B.Length() .

नीचे दिए गए कोड निर्धारित करता है तो एक जोड़ी वैक्टर समानांतर हैं ( शायद विरोधी अनुरूप ) .

फ़्लोटिंग बिन्दु संख्या जमा कर सकते हैं त्रुटियों में आंशिक भाग के कारण परिशुद्धता के सीमित है , और इसलिए , कंप्यूटर कोड शामिल होनी चाहिए , जब गैर शून्य tolerances तुलना चल बिन्दु संख्या है .

उदाहरण के मूल्यों सहिष्णुता कोड शामिल हैं , लेकिन सहिष्णुता का उदाहरण मान नहीं किया जा सकता है कुछ कार्यों के लिए उपयुक्त है .

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


        // . . .
    }
}

वैक्टर (A) और (B) "सीधा" कर रहे हैं तो सब के सब सही निम्नलिखित हैं :

( 1 ) A.Length() > 0 ;

( 2 ) B.Length() > 0 ;

( 3 ) Abs(Dot(A,B)) = 0 .

नीचे दिए गए कोड निर्धारित करता है तो एक जोड़ी वैक्टर सीधा कर रहे हैं .  फ़्लोटिंग बिन्दु संख्या जमा कर सकते हैं त्रुटियों में आंशिक भाग के कारण परिशुद्धता के सीमित है , और इसलिए , कंप्यूटर कोड शामिल होनी चाहिए , जब गैर शून्य tolerances तुलना चल बिन्दु संख्या है .

उदाहरण के मूल्यों सहिष्णुता कोड शामिल हैं , लेकिन सहिष्णुता का उदाहरण मान नहीं किया जा सकता है कुछ कार्यों के लिए उपयुक्त है .

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 )

       &