OCCT3D OCCT 8.0.1
OCCT documentation

Search guides and API reference

Enter at least two characters.

    Open CASCADE Technology Reference Manual 8.0.1
    gp_Vec Class Reference

    Defines a non-persistent vector in 3D space. More...

    #include <gp_Vec.hxx>

    Public Member Functions

    constexpr gp_Vec () noexcept=default
     Creates a zero vector.
    constexpr gp_Vec (const gp_Dir &theV)
     Creates a unitary vector from a direction theV.
    constexpr gp_Vec (const gp_XYZ &theCoord) noexcept
     Creates a vector with a triplet of coordinates.
    constexpr gp_Vec (const double theXv, const double theYv, const double theZv) noexcept
     Creates a point with its three cartesian coordinates.
    constexpr gp_Vec (const gp_Pnt &theP1, const gp_Pnt &theP2)
     Creates a vector from two points. The length of the vector is the distance between theP1 and theP2.
    constexpr void SetCoord (const int theIndex, const double theXi)
     Changes the coordinate of range theIndex theIndex = 1 => X is modified theIndex = 2 => Y is modified theIndex = 3 => Z is modified Raised if theIndex != {1, 2, 3}.
    constexpr void SetCoord (const double theXv, const double theYv, const double theZv) noexcept
     For this vector, assigns.
    constexpr void SetX (const double theX) noexcept
     Assigns the given value to the X coordinate of this vector.
    constexpr void SetY (const double theY) noexcept
     Assigns the given value to the X coordinate of this vector.
    constexpr void SetZ (const double theZ) noexcept
     Assigns the given value to the X coordinate of this vector.
    constexpr void SetXYZ (const gp_XYZ &theCoord) noexcept
     Assigns the three coordinates of theCoord to this vector.
    constexpr double Coord (const int theIndex) const
     Returns the coordinate of range theIndex : theIndex = 1 => X is returned theIndex = 2 => Y is returned theIndex = 3 => Z is returned Raised if theIndex != {1, 2, 3}.
    constexpr void Coord (double &theXv, double &theYv, double &theZv) const noexcept
     For this vector returns its three coordinates theXv, theYv, and theZv inline.
    constexpr double X () const noexcept
     For this vector, returns its X coordinate.
    constexpr double Y () const noexcept
     For this vector, returns its Y coordinate.
    constexpr double Z () const noexcept
     For this vector, returns its Z coordinate.
    constexpr const gp_XYZXYZ () const noexcept
     For this vector, returns.
    bool IsEqual (const gp_Vec &theOther, const double theLinearTolerance, const double theAngularTolerance) const
     Returns True if the two vectors have the same magnitude value and the same direction. The precision values are theLinearTolerance for the magnitude and theAngularTolerance for the direction.
    bool IsNormal (const gp_Vec &theOther, const double theAngularTolerance) const
     Returns True if abs(<me>.Angle(theOther) - PI/2.) <= theAngularTolerance Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution or theOther.Magnitude() <= Resolution from gp.
    bool IsOpposite (const gp_Vec &theOther, const double theAngularTolerance) const
     Returns True if PI - <me>.Angle(theOther) <= theAngularTolerance Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution or Other.Magnitude() <= Resolution from gp.
    bool IsParallel (const gp_Vec &theOther, const double theAngularTolerance) const
     Returns True if Angle(<me>, theOther) <= theAngularTolerance or PI - Angle(<me>, theOther) <= theAngularTolerance This definition means that two parallel vectors cannot define a plane but two vectors with opposite directions are considered as parallel. Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution or Other.Magnitude() <= Resolution from gp.
    double Angle (const gp_Vec &theOther) const
     Computes the angular value between <me> and <theOther> Returns the angle value between 0 and PI in radian. Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution from gp or theOther.Magnitude() <= Resolution because the angular value is indefinite if one of the vectors has a null magnitude.
    double AngleWithRef (const gp_Vec &theOther, const gp_Vec &theVRef) const
     Computes the angle, in radians, between this vector and vector theOther. The result is a value between -Pi and Pi. For this, theVRef defines the positive sense of rotation: the angular value is positive, if the cross product this ^ theOther has the same orientation as theVRef relative to the plane defined by the vectors this and theOther. Otherwise, the angular value is negative. Exceptions gp_VectorWithNullMagnitude if the magnitude of this vector, the vector theOther, or the vector theVRef is less than or equal to gp::Resolution(). Standard_DomainError if this vector, the vector theOther, and the vector theVRef are coplanar, unless this vector and the vector theOther are parallel.
    double Magnitude () const
     Computes the magnitude of this vector.
    constexpr double SquareMagnitude () const noexcept
     Computes the square magnitude of this vector.
    constexpr void Add (const gp_Vec &theOther) noexcept
     Adds two vectors.
    constexpr void operator+= (const gp_Vec &theOther) noexcept
    constexpr gp_Vec Added (const gp_Vec &theOther) const noexcept
     Adds two vectors.
    constexpr gp_Vec operator+ (const gp_Vec &theOther) const noexcept
    constexpr void Subtract (const gp_Vec &theRight) noexcept
     Subtracts two vectors.
    constexpr void operator-= (const gp_Vec &theRight) noexcept
    constexpr gp_Vec Subtracted (const gp_Vec &theRight) const noexcept
     Subtracts two vectors.
    constexpr gp_Vec operator- (const gp_Vec &theRight) const noexcept
    constexpr void Multiply (const double theScalar) noexcept
     Multiplies a vector by a scalar.
    constexpr void operator*= (const double theScalar) noexcept
    constexpr gp_Vec Multiplied (const double theScalar) const noexcept
     Multiplies a vector by a scalar.
    constexpr gp_Vec operator* (const double theScalar) const noexcept
    constexpr void Divide (const double theScalar)
     Divides a vector by a scalar.
    constexpr void operator/= (const double theScalar)
    constexpr gp_Vec Divided (const double theScalar) const
     Divides a vector by a scalar.
    constexpr gp_Vec operator/ (const double theScalar) const
    constexpr void Cross (const gp_Vec &theRight) noexcept
     computes the cross product between two vectors
    constexpr void operator^= (const gp_Vec &theRight) noexcept
    constexpr gp_Vec Crossed (const gp_Vec &theRight) const noexcept
     computes the cross product between two vectors
    constexpr gp_Vec operator^ (const gp_Vec &theRight) const noexcept
    double CrossMagnitude (const gp_Vec &theRight) const
     Computes the magnitude of the cross product between <me> and theRight. Returns || <me> ^ theRight ||.
    constexpr double CrossSquareMagnitude (const gp_Vec &theRight) const noexcept
     Computes the square magnitude of the cross product between <me> and theRight. Returns || <me> ^ theRight ||**2.
    constexpr void CrossCross (const gp_Vec &theV1, const gp_Vec &theV2) noexcept
     Computes the triple vector product. <me> ^= (theV1 ^ theV2).
    constexpr gp_Vec CrossCrossed (const gp_Vec &theV1, const gp_Vec &theV2) const noexcept
     Computes the triple vector product. <me> ^ (theV1 ^ theV2).
    constexpr double Dot (const gp_Vec &theOther) const noexcept
     computes the scalar product
    constexpr double operator* (const gp_Vec &theOther) const noexcept
    constexpr double DotCross (const gp_Vec &theV1, const gp_Vec &theV2) const noexcept
     Computes the triple scalar product <me> * (theV1 ^ theV2).
    void Normalize ()
     normalizes a vector Raises an exception if the magnitude of the vector is lower or equal to Resolution from gp.
    gp_Vec Normalized () const
     normalizes a vector Raises an exception if the magnitude of the vector is lower or equal to Resolution from gp.
    constexpr void Reverse () noexcept
     Reverses the direction of a vector.
    constexpr gp_Vec Reversed () const noexcept
     Reverses the direction of a vector.
    constexpr gp_Vec operator- () const noexcept
    constexpr void SetLinearForm (const double theA1, const gp_Vec &theV1, const double theA2, const gp_Vec &theV2, const double theA3, const gp_Vec &theV3, const gp_Vec &theV4) noexcept
     <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2 + theA3 * theV3 + theV4
    constexpr void SetLinearForm (const double theA1, const gp_Vec &theV1, const double theA2, const gp_Vec &theV2, const double theA3, const gp_Vec &theV3) noexcept
     <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2 + theA3 * theV3
    constexpr void SetLinearForm (const double theA1, const gp_Vec &theV1, const double theA2, const gp_Vec &theV2, const gp_Vec &theV3) noexcept
     <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2 + theV3
    constexpr void SetLinearForm (const double theA1, const gp_Vec &theV1, const double theA2, const gp_Vec &theV2) noexcept
     <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2
    constexpr void SetLinearForm (const double theA1, const gp_Vec &theV1, const gp_Vec &theV2) noexcept
     <me> is set to the following linear form : theA1 * theV1 + theV2
    constexpr void SetLinearForm (const gp_Vec &theV1, const gp_Vec &theV2) noexcept
     <me> is set to the following linear form : theV1 + theV2
    void Mirror (const gp_Vec &theV) noexcept
    gp_Vec Mirrored (const gp_Vec &theV) const noexcept
     Performs the symmetrical transformation of a vector with respect to the vector theV which is the center of the symmetry.
    void Mirror (const gp_Ax1 &theA1) noexcept
    gp_Vec Mirrored (const gp_Ax1 &theA1) const noexcept
     Performs the symmetrical transformation of a vector with respect to an axis placement which is the axis of the symmetry.
    void Mirror (const gp_Ax2 &theA2) noexcept
    gp_Vec Mirrored (const gp_Ax2 &theA2) const noexcept
     Performs the symmetrical transformation of a vector with respect to a plane. The axis placement theA2 locates the plane of the symmetry : (Location, XDirection, YDirection).
    void Rotate (const gp_Ax1 &theA1, const double theAng)
    gp_Vec Rotated (const gp_Ax1 &theA1, const double theAng) const
     Rotates a vector. theA1 is the axis of the rotation. theAng is the angular value of the rotation in radians.
    constexpr void Scale (const double theS) noexcept
    constexpr gp_Vec Scaled (const double theS) const noexcept
     Scales a vector. theS is the scaling value.
    void Transform (const gp_Trsf &theT)
     Transforms a vector with the transformation theT.
    gp_Vec Transformed (const gp_Trsf &theT) const
     Transforms a vector with the transformation theT.
    void DumpJson (Standard_OStream &theOStream, int theDepth=-1) const
     Dumps the content of me into the stream.

    Detailed Description

    Defines a non-persistent vector in 3D space.

    Constructor & Destructor Documentation

    ◆ gp_Vec() [1/5]

    gp_Vec::gp_Vec ( )
    constexprdefaultnoexcept

    Creates a zero vector.

    ◆ gp_Vec() [2/5]

    gp_Vec::gp_Vec ( const gp_Dir & theV)
    inlineconstexpr

    Creates a unitary vector from a direction theV.

    ◆ gp_Vec() [3/5]

    gp_Vec::gp_Vec ( const gp_XYZ & theCoord)
    inlineconstexprnoexcept

    Creates a vector with a triplet of coordinates.

    ◆ gp_Vec() [4/5]

    gp_Vec::gp_Vec ( const double theXv,
    const double theYv,
    const double theZv )
    inlineconstexprnoexcept

    Creates a point with its three cartesian coordinates.

    ◆ gp_Vec() [5/5]

    gp_Vec::gp_Vec ( const gp_Pnt & theP1,
    const gp_Pnt & theP2 )
    inlineconstexpr

    Creates a vector from two points. The length of the vector is the distance between theP1 and theP2.

    Member Function Documentation

    ◆ Add()

    void gp_Vec::Add ( const gp_Vec & theOther)
    inlineconstexprnoexcept

    Adds two vectors.

    ◆ Added()

    gp_Vec gp_Vec::Added ( const gp_Vec & theOther) const
    inlinenodiscardconstexprnoexcept

    Adds two vectors.

    ◆ Angle()

    double gp_Vec::Angle ( const gp_Vec & theOther) const
    inline

    Computes the angular value between <me> and <theOther> Returns the angle value between 0 and PI in radian. Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution from gp or theOther.Magnitude() <= Resolution because the angular value is indefinite if one of the vectors has a null magnitude.

    ◆ AngleWithRef()

    double gp_Vec::AngleWithRef ( const gp_Vec & theOther,
    const gp_Vec & theVRef ) const
    inline

    Computes the angle, in radians, between this vector and vector theOther. The result is a value between -Pi and Pi. For this, theVRef defines the positive sense of rotation: the angular value is positive, if the cross product this ^ theOther has the same orientation as theVRef relative to the plane defined by the vectors this and theOther. Otherwise, the angular value is negative. Exceptions gp_VectorWithNullMagnitude if the magnitude of this vector, the vector theOther, or the vector theVRef is less than or equal to gp::Resolution(). Standard_DomainError if this vector, the vector theOther, and the vector theVRef are coplanar, unless this vector and the vector theOther are parallel.

    ◆ Coord() [1/2]

    double gp_Vec::Coord ( const int theIndex) const
    inlineconstexpr

    Returns the coordinate of range theIndex : theIndex = 1 => X is returned theIndex = 2 => Y is returned theIndex = 3 => Z is returned Raised if theIndex != {1, 2, 3}.

    ◆ Coord() [2/2]

    void gp_Vec::Coord ( double & theXv,
    double & theYv,
    double & theZv ) const
    inlineconstexprnoexcept

    For this vector returns its three coordinates theXv, theYv, and theZv inline.

    ◆ Cross()

    void gp_Vec::Cross ( const gp_Vec & theRight)
    inlineconstexprnoexcept

    computes the cross product between two vectors

    ◆ CrossCross()

    void gp_Vec::CrossCross ( const gp_Vec & theV1,
    const gp_Vec & theV2 )
    inlineconstexprnoexcept

    Computes the triple vector product. <me> ^= (theV1 ^ theV2).

    ◆ CrossCrossed()

    gp_Vec gp_Vec::CrossCrossed ( const gp_Vec & theV1,
    const gp_Vec & theV2 ) const
    inlinenodiscardconstexprnoexcept

    Computes the triple vector product. <me> ^ (theV1 ^ theV2).

    ◆ Crossed()

    gp_Vec gp_Vec::Crossed ( const gp_Vec & theRight) const
    inlinenodiscardconstexprnoexcept

    computes the cross product between two vectors

    ◆ CrossMagnitude()

    double gp_Vec::CrossMagnitude ( const gp_Vec & theRight) const
    inline

    Computes the magnitude of the cross product between <me> and theRight. Returns || <me> ^ theRight ||.

    ◆ CrossSquareMagnitude()

    double gp_Vec::CrossSquareMagnitude ( const gp_Vec & theRight) const
    inlineconstexprnoexcept

    Computes the square magnitude of the cross product between <me> and theRight. Returns || <me> ^ theRight ||**2.

    ◆ Divide()

    void gp_Vec::Divide ( const double theScalar)
    inlineconstexpr

    Divides a vector by a scalar.

    ◆ Divided()

    gp_Vec gp_Vec::Divided ( const double theScalar) const
    inlinenodiscardconstexpr

    Divides a vector by a scalar.

    ◆ Dot()

    double gp_Vec::Dot ( const gp_Vec & theOther) const
    inlineconstexprnoexcept

    computes the scalar product

    ◆ DotCross()

    double gp_Vec::DotCross ( const gp_Vec & theV1,
    const gp_Vec & theV2 ) const
    inlineconstexprnoexcept

    Computes the triple scalar product <me> * (theV1 ^ theV2).

    ◆ DumpJson()

    void gp_Vec::DumpJson ( Standard_OStream & theOStream,
    int theDepth = -1 ) const

    Dumps the content of me into the stream.

    ◆ IsEqual()

    bool gp_Vec::IsEqual ( const gp_Vec & theOther,
    const double theLinearTolerance,
    const double theAngularTolerance ) const

    Returns True if the two vectors have the same magnitude value and the same direction. The precision values are theLinearTolerance for the magnitude and theAngularTolerance for the direction.

    ◆ IsNormal()

    bool gp_Vec::IsNormal ( const gp_Vec & theOther,
    const double theAngularTolerance ) const
    inline

    Returns True if abs(<me>.Angle(theOther) - PI/2.) <= theAngularTolerance Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution or theOther.Magnitude() <= Resolution from gp.

    ◆ IsOpposite()

    bool gp_Vec::IsOpposite ( const gp_Vec & theOther,
    const double theAngularTolerance ) const
    inline

    Returns True if PI - <me>.Angle(theOther) <= theAngularTolerance Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution or Other.Magnitude() <= Resolution from gp.

    ◆ IsParallel()

    bool gp_Vec::IsParallel ( const gp_Vec & theOther,
    const double theAngularTolerance ) const
    inline

    Returns True if Angle(<me>, theOther) <= theAngularTolerance or PI - Angle(<me>, theOther) <= theAngularTolerance This definition means that two parallel vectors cannot define a plane but two vectors with opposite directions are considered as parallel. Raises VectorWithNullMagnitude if <me>.Magnitude() <= Resolution or Other.Magnitude() <= Resolution from gp.

    ◆ Magnitude()

    double gp_Vec::Magnitude ( ) const
    inline

    Computes the magnitude of this vector.

    ◆ Mirror() [1/3]

    void gp_Vec::Mirror ( const gp_Ax1 & theA1)
    noexcept

    ◆ Mirror() [2/3]

    void gp_Vec::Mirror ( const gp_Ax2 & theA2)
    noexcept

    ◆ Mirror() [3/3]

    void gp_Vec::Mirror ( const gp_Vec & theV)
    noexcept

    ◆ Mirrored() [1/3]

    gp_Vec gp_Vec::Mirrored ( const gp_Ax1 & theA1) const
    nodiscardnoexcept

    Performs the symmetrical transformation of a vector with respect to an axis placement which is the axis of the symmetry.

    ◆ Mirrored() [2/3]

    gp_Vec gp_Vec::Mirrored ( const gp_Ax2 & theA2) const
    nodiscardnoexcept

    Performs the symmetrical transformation of a vector with respect to a plane. The axis placement theA2 locates the plane of the symmetry : (Location, XDirection, YDirection).

    ◆ Mirrored() [3/3]

    gp_Vec gp_Vec::Mirrored ( const gp_Vec & theV) const
    nodiscardnoexcept

    Performs the symmetrical transformation of a vector with respect to the vector theV which is the center of the symmetry.

    ◆ Multiplied()

    gp_Vec gp_Vec::Multiplied ( const double theScalar) const
    inlinenodiscardconstexprnoexcept

    Multiplies a vector by a scalar.

    ◆ Multiply()

    void gp_Vec::Multiply ( const double theScalar)
    inlineconstexprnoexcept

    Multiplies a vector by a scalar.

    ◆ Normalize()

    void gp_Vec::Normalize ( )
    inline

    normalizes a vector Raises an exception if the magnitude of the vector is lower or equal to Resolution from gp.

    ◆ Normalized()

    gp_Vec gp_Vec::Normalized ( ) const
    inlinenodiscard

    normalizes a vector Raises an exception if the magnitude of the vector is lower or equal to Resolution from gp.

    ◆ operator*() [1/2]

    gp_Vec gp_Vec::operator* ( const double theScalar) const
    inlinenodiscardconstexprnoexcept

    ◆ operator*() [2/2]

    double gp_Vec::operator* ( const gp_Vec & theOther) const
    inlineconstexprnoexcept

    ◆ operator*=()

    void gp_Vec::operator*= ( const double theScalar)
    inlineconstexprnoexcept

    ◆ operator+()

    gp_Vec gp_Vec::operator+ ( const gp_Vec & theOther) const
    inlinenodiscardconstexprnoexcept

    ◆ operator+=()

    void gp_Vec::operator+= ( const gp_Vec & theOther)
    inlineconstexprnoexcept

    ◆ operator-() [1/2]

    gp_Vec gp_Vec::operator- ( ) const
    inlinenodiscardconstexprnoexcept

    ◆ operator-() [2/2]

    gp_Vec gp_Vec::operator- ( const gp_Vec & theRight) const
    inlinenodiscardconstexprnoexcept

    ◆ operator-=()

    void gp_Vec::operator-= ( const gp_Vec & theRight)
    inlineconstexprnoexcept

    ◆ operator/()

    gp_Vec gp_Vec::operator/ ( const double theScalar) const
    inlinenodiscardconstexpr

    ◆ operator/=()

    void gp_Vec::operator/= ( const double theScalar)
    inlineconstexpr

    ◆ operator^()

    gp_Vec gp_Vec::operator^ ( const gp_Vec & theRight) const
    inlinenodiscardconstexprnoexcept

    ◆ operator^=()

    void gp_Vec::operator^= ( const gp_Vec & theRight)
    inlineconstexprnoexcept

    ◆ Reverse()

    void gp_Vec::Reverse ( )
    inlineconstexprnoexcept

    Reverses the direction of a vector.

    ◆ Reversed()

    gp_Vec gp_Vec::Reversed ( ) const
    inlinenodiscardconstexprnoexcept

    Reverses the direction of a vector.

    ◆ Rotate()

    void gp_Vec::Rotate ( const gp_Ax1 & theA1,
    const double theAng )
    inline

    ◆ Rotated()

    gp_Vec gp_Vec::Rotated ( const gp_Ax1 & theA1,
    const double theAng ) const
    inlinenodiscard

    Rotates a vector. theA1 is the axis of the rotation. theAng is the angular value of the rotation in radians.

    ◆ Scale()

    void gp_Vec::Scale ( const double theS)
    inlineconstexprnoexcept

    ◆ Scaled()

    gp_Vec gp_Vec::Scaled ( const double theS) const
    inlinenodiscardconstexprnoexcept

    Scales a vector. theS is the scaling value.

    ◆ SetCoord() [1/2]

    void gp_Vec::SetCoord ( const double theXv,
    const double theYv,
    const double theZv )
    inlineconstexprnoexcept

    For this vector, assigns.

    • the values theXv, theYv and theZv to its three coordinates.

    ◆ SetCoord() [2/2]

    void gp_Vec::SetCoord ( const int theIndex,
    const double theXi )
    inlineconstexpr

    Changes the coordinate of range theIndex theIndex = 1 => X is modified theIndex = 2 => Y is modified theIndex = 3 => Z is modified Raised if theIndex != {1, 2, 3}.

    ◆ SetLinearForm() [1/6]

    void gp_Vec::SetLinearForm ( const double theA1,
    const gp_Vec & theV1,
    const double theA2,
    const gp_Vec & theV2 )
    inlineconstexprnoexcept

    <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2

    ◆ SetLinearForm() [2/6]

    void gp_Vec::SetLinearForm ( const double theA1,
    const gp_Vec & theV1,
    const double theA2,
    const gp_Vec & theV2,
    const double theA3,
    const gp_Vec & theV3 )
    inlineconstexprnoexcept

    <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2 + theA3 * theV3

    ◆ SetLinearForm() [3/6]

    void gp_Vec::SetLinearForm ( const double theA1,
    const gp_Vec & theV1,
    const double theA2,
    const gp_Vec & theV2,
    const double theA3,
    const gp_Vec & theV3,
    const gp_Vec & theV4 )
    inlineconstexprnoexcept

    <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2 + theA3 * theV3 + theV4

    ◆ SetLinearForm() [4/6]

    void gp_Vec::SetLinearForm ( const double theA1,
    const gp_Vec & theV1,
    const double theA2,
    const gp_Vec & theV2,
    const gp_Vec & theV3 )
    inlineconstexprnoexcept

    <me> is set to the following linear form : theA1 * theV1 + theA2 * theV2 + theV3

    ◆ SetLinearForm() [5/6]

    void gp_Vec::SetLinearForm ( const double theA1,
    const gp_Vec & theV1,
    const gp_Vec & theV2 )
    inlineconstexprnoexcept

    <me> is set to the following linear form : theA1 * theV1 + theV2

    ◆ SetLinearForm() [6/6]

    void gp_Vec::SetLinearForm ( const gp_Vec & theV1,
    const gp_Vec & theV2 )
    inlineconstexprnoexcept

    <me> is set to the following linear form : theV1 + theV2

    ◆ SetX()

    void gp_Vec::SetX ( const double theX)
    inlineconstexprnoexcept

    Assigns the given value to the X coordinate of this vector.

    ◆ SetXYZ()

    void gp_Vec::SetXYZ ( const gp_XYZ & theCoord)
    inlineconstexprnoexcept

    Assigns the three coordinates of theCoord to this vector.

    ◆ SetY()

    void gp_Vec::SetY ( const double theY)
    inlineconstexprnoexcept

    Assigns the given value to the X coordinate of this vector.

    ◆ SetZ()

    void gp_Vec::SetZ ( const double theZ)
    inlineconstexprnoexcept

    Assigns the given value to the X coordinate of this vector.

    ◆ SquareMagnitude()

    double gp_Vec::SquareMagnitude ( ) const
    inlineconstexprnoexcept

    Computes the square magnitude of this vector.

    ◆ Subtract()

    void gp_Vec::Subtract ( const gp_Vec & theRight)
    inlineconstexprnoexcept

    Subtracts two vectors.

    ◆ Subtracted()

    gp_Vec gp_Vec::Subtracted ( const gp_Vec & theRight) const
    inlinenodiscardconstexprnoexcept

    Subtracts two vectors.

    ◆ Transform()

    void gp_Vec::Transform ( const gp_Trsf & theT)

    Transforms a vector with the transformation theT.

    ◆ Transformed()

    gp_Vec gp_Vec::Transformed ( const gp_Trsf & theT) const
    inlinenodiscard

    Transforms a vector with the transformation theT.

    ◆ X()

    double gp_Vec::X ( ) const
    inlineconstexprnoexcept

    For this vector, returns its X coordinate.

    ◆ XYZ()

    const gp_XYZ & gp_Vec::XYZ ( ) const
    inlineconstexprnoexcept

    For this vector, returns.

    • its three coordinates as a number triple

    ◆ Y()

    double gp_Vec::Y ( ) const
    inlineconstexprnoexcept

    For this vector, returns its Y coordinate.

    ◆ Z()

    double gp_Vec::Z ( ) const
    inlineconstexprnoexcept

    For this vector, returns its Z coordinate.


    The documentation for this class was generated from the following file: