# Vec3¶

```#include <Imath/ImathVec.h>
```

The `Vec3` class template represents a 3D vector, with predefined typedefs for vectors of type `short`, `int`, `int64_t`, `float`, and `double`.

Note that the integer specializations of `Vec3` lack the `length()` and `normalize()` methods that are present in the `float` and `double` versions, because the results don’t fit into integer quantities.

There are also various utility functions that operate on vectors defined in `ImathVecAlgo.h` and described in Vector Functions.

Individual components of a vector `V` may be referenced as either `V[i]` or `V.x`, `V.y`, `V.z`. Obviously, the `[]` notation is more suited to looping over components, or in cases where a variable determines which coordinate is needed. However, when the coordinate is known, it can be more efficient to directly address the components, such as `V.y` rather than `V`. While both appear to do the same thing (and indeed do generate the same machine operations for ordinary scalar code), when used inside loops that you hope to parallelize (either through compiler auto-vectorization or explicit hints such as `#pragma omp simd`), the function call and pointer casting of `operator[]` can confuse the compiler just enough to prevent vectorization of the loop.

Example:

```#include <Imath/ImathVec.h>
#include <cassert>

void
vec3_example ()
{
Imath::V3f a (1.0f, 2.0f, 3.0f);
Imath::V3f b; // b is uninitialized

b.x = a;
b.y = a;
b.z = a;

assert (a == b);

assert (a.length () == sqrt (a ^ a));

a.normalize ();
assert (Imath::equalWithAbsError (a.length (), 1.0f, 1e-6f));
}
```
typedef Vec3<short> Imath::V3s

Vec3 of short.

typedef Vec3<int> Imath::V3i

Vec3 of integer.

typedef Vec3<int64_t> Imath::V3i64

Vec3 of int64_t.

typedef Vec3<float> Imath::V3f

Vec3 of float.

typedef Vec3<double> Imath::V3d

Vec3 of double.

template<class T>
class Vec3

3-element vector

Subclassed by Imath::Color3< T >, Imath::Euler< T >

T x
T y
T z

Constructors and Assignment

inline Vec3() noexcept

Uninitialized by default.

inline explicit constexpr Vec3(T a) noexcept

Initialize to a scalar `(a,a,a)`

inline constexpr Vec3(T a, T b, T c) noexcept

Initialize to given elements `(a,b,c)`

inline constexpr Vec3(const Vec3 &v) noexcept

Copy constructor.

template<class S>
inline constexpr Vec3(const Vec3<S> &v) noexcept

Construct from Vec3 of another base type.

template<class S>
inline explicit constexpr Vec3(const Vec4<S> &v) noexcept

Vec4 to Vec3 conversion: divide x, y and z by w, even if w is 0.

The result depends on how the environment handles floating-point exceptions.

template<class S>
inline explicit constexpr Vec3(const Vec4<S> &v, InfException)

Vec4 to Vec3 conversion: divide x, y and z by w.

Throws an exception if w is zero or if division by w would overflow.

inline constexpr const Vec3 &operator=(const Vec3 &v) noexcept

Assignment.

~Vec3() noexcept = default

Destructor.

Compatibility with Sb

template<class S>
inline void setValue(S a, S b, S c) noexcept

Set the value.

template<class S>
inline void setValue(const Vec3<S> &v) noexcept

Set the value.

template<class S>
inline void getValue(S &a, S &b, S &c) const noexcept

Return the value in `a`, `b`, and `c`

template<class S>
inline void getValue(Vec3<S> &v) const noexcept

Return the value in `v`

inline T *getValue() noexcept

Return a raw pointer to the array of values.

inline const T *getValue() const noexcept

Return a raw pointer to the array of values.

Arithmetic and Comparison

template<class S>
inline constexpr bool operator==(const Vec3<S> &v) const noexcept

Equality.

template<class S>
inline constexpr bool operator!=(const Vec3<S> &v) const noexcept

Inequality.

inline constexpr bool equalWithAbsError(const Vec3<T> &v, T e) const noexcept

Compare two matrices and test if they are “approximately equal”:

Returns

True if the coefficients of this and `m` are the same with an absolute error of no more than e, i.e., for all i, j:

```abs (this[i][j] - m[i][j]) <= e
```

inline constexpr bool equalWithRelError(const Vec3<T> &v, T e) const noexcept

Compare two matrices and test if they are “approximately equal”:

Returns

True if the coefficients of this and m are the same with a relative error of no more than e, i.e., for all i, j:

```abs (this[i] - v[i][j]) <= e * abs (this[i][j])
```

inline constexpr T dot(const Vec3 &v) const noexcept

Dot product.

inline constexpr T operator^(const Vec3 &v) const noexcept

Dot product.

inline constexpr Vec3 cross(const Vec3 &v) const noexcept

Right-handed cross product.

inline constexpr const Vec3 &operator%=(const Vec3 &v) noexcept

Right-handed cross product.

inline constexpr Vec3 operator%(const Vec3 &v) const noexcept

Right-handed cross product.

inline constexpr const Vec3 &operator+=(const Vec3 &v) noexcept

inline constexpr Vec3 operator+(const Vec3 &v) const noexcept

inline constexpr const Vec3 &operator-=(const Vec3 &v) noexcept

Component-wise subtraction.

inline constexpr Vec3 operator-(const Vec3 &v) const noexcept

Component-wise subtraction.

inline constexpr Vec3 operator-() const noexcept

Component-wise multiplication by -1.

inline constexpr const Vec3 &negate() noexcept

Component-wise multiplication by -1.

inline constexpr const Vec3 &operator*=(const Vec3 &v) noexcept

Component-wise multiplication.

inline constexpr const Vec3 &operator*=(T a) noexcept

Component-wise multiplication.

inline constexpr Vec3 operator*(const Vec3 &v) const noexcept

Component-wise multiplication.

inline constexpr Vec3 operator*(T a) const noexcept

Component-wise multiplication.

inline constexpr const Vec3 &operator/=(const Vec3 &v) noexcept

Component-wise division.

inline constexpr const Vec3 &operator/=(T a) noexcept

Component-wise division.

inline constexpr Vec3 operator/(const Vec3 &v) const noexcept

Component-wise division.

inline constexpr Vec3 operator/(T a) const noexcept

Component-wise division.

Query and Manipulation

inline T length() const noexcept

Return the Euclidean norm.

inline constexpr T length2() const noexcept

Return the square of the Euclidean norm, i.e.

the dot product with itself.

inline const Vec3 &normalize() noexcept

Normalize in place. If length()==0, return a null vector.

inline const Vec3 &normalizeExc()

Normalize in place. If length()==0, throw an exception.

inline const Vec3 &normalizeNonNull() noexcept

Normalize without any checks for length()==0.

Slightly faster than the other normalization routines, but if v.length() is 0.0, the result is undefined.

inline Vec3<T> normalized() const noexcept

Return a normalized vector. Does not modify *this.

inline Vec3<T> normalizedExc() const

Return a normalized vector.

Does not modify *this. Throw an exception if length()==0.

inline Vec3<T> normalizedNonNull() const noexcept

Return a normalized vector.

Does not modify *this, and does not check for length()==0. Slightly faster than the other normalization routines, but if v.length() is 0.0, the result is undefined.

Numeric Limits

static inline constexpr T baseTypeLowest() noexcept

Largest possible negative value.

static inline constexpr T baseTypeMax() noexcept

Largest possible positive value.

static inline constexpr T baseTypeSmallest() noexcept

Smallest possible positive value.

static inline constexpr T baseTypeEpsilon() noexcept

Smallest possible e for which 1+e != 1.

Public Types

typedef T BaseType

The base type: In templates that accept a parameter `V`, you can refer to `T` as `V::BaseType`

Public Functions

inline constexpr T &operator[](int i) noexcept

Element access by index.

inline constexpr const T &operator[](int i) const noexcept

Element access by index.

Public Static Functions

static inline constexpr unsigned int dimensions() noexcept

Return the number of dimensions, i.e. 3.

template<class T>
std::ostream &Imath::operator<<(std::ostream &s, const Vec3<T> &v)

Stream output, as “(x y z)”.