# 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.

Example:

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

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

b.x = a[0];
b.y = a[1];
b.z = a[2];

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 Imath::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.

template<>
short length() const noexcept = delete
template<>
const Vec3<short> &normalize() noexcept = delete
template<>
const Vec3<short> &normalizeExc() = delete
template<>
const Vec3<short> &normalizeNonNull() noexcept = delete
template<>
Vec3<short> normalized() const noexcept = delete
template<>
Vec3<short> normalizedExc() const = delete
template<>
Vec3<short> normalizedNonNull() const noexcept = delete
template<>
int length() const noexcept = delete
template<>
const Vec3<int> &normalize() noexcept = delete
template<>
const Vec3<int> &normalizeExc() = delete
template<>
const Vec3<int> &normalizeNonNull() noexcept = delete
template<>
Vec3<int> normalized() const noexcept = delete
template<>
Vec3<int> normalizedExc() const = delete
template<>
Vec3<int> normalizedNonNull() const noexcept = delete
template<>
int64_t length() const noexcept = delete
template<>
const Vec3<int64_t> &normalize() noexcept = delete
template<>
const Vec3<int64_t> &normalizeExc() = delete
template<>
const Vec3<int64_t> &normalizeNonNull() noexcept = delete
template<>
Vec3<int64_t> normalized() const noexcept = delete
template<>
Vec3<int64_t> normalizedExc() const = delete
template<>
Vec3<int64_t> normalizedNonNull() const noexcept = delete

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)”.