# Vec4¶

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

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

Note that the integer specializations of `Vec4` 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
vec4_example()
{
Imath::V4f   a (1.0f, 2.0f, 3.0f, 4.0f);
Imath::V4f   b; // b is uninitialized

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

assert (a == b);

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

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

Vec4 of short.

typedef Vec4<int> Imath::V4i

Vec4 of integer.

typedef Vec4<int64_t> Imath::V4i64

Vec4 of int64_t.

typedef Vec4<float> Imath::V4f

Vec4 of float.

typedef Vec4<double> Imath::V4d

Vec4 of double.

template<class T>
class Imath::Vec4

4-element vector

T x
T y
T z
T w

Constructors and Assignment

inline Vec4() noexcept

Uninitialized by default.

inline explicit constexpr Vec4(T a) noexcept

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

inline constexpr Vec4(T a, T b, T c, T d) noexcept

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

inline constexpr Vec4(const Vec4 &v) noexcept

Copy constructor.

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

Construct from Vec4 of another base type.

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

Vec3 to Vec4 conversion, sets w to 1.

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

Assignment.

~Vec4() noexcept = default

Destructor.

Arithmetic and Comparison

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

Equality.

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

Inequality.

inline constexpr bool equalWithAbsError(const Vec4<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 Vec4<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 Vec4 &v) const noexcept

Dot product.

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

Dot product.

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

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

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

Component-wise subtraction.

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

Component-wise subtraction.

inline constexpr Vec4 operator-() const noexcept

Component-wise multiplication by -1.

inline constexpr const Vec4 &negate() noexcept

Component-wise multiplication by -1.

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

Component-wise multiplication.

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

Component-wise multiplication.

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

Component-wise multiplication.

inline constexpr Vec4 operator*(T a) const noexcept

Component-wise multiplication.

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

Component-wise division.

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

Component-wise division.

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

Component-wise division.

inline constexpr Vec4 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 Vec4 &normalize() noexcept

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

inline const Vec4 &normalizeExc()

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

inline const Vec4 &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 Vec4<T> normalized() const noexcept

Return a normalized vector. Does not modify *this.

inline Vec4<T> normalizedExc() const

Return a normalized vector.

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

inline Vec4<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 Vec4<short> &normalize() noexcept = delete
template<>
const Vec4<short> &normalizeExc() = delete
template<>
const Vec4<short> &normalizeNonNull() noexcept = delete
template<>
Vec4<short> normalized() const noexcept = delete
template<>
Vec4<short> normalizedExc() const = delete
template<>
Vec4<short> normalizedNonNull() const noexcept = delete
template<>
int length() const noexcept = delete
template<>
const Vec4<int> &normalize() noexcept = delete
template<>
const Vec4<int> &normalizeExc() = delete
template<>
const Vec4<int> &normalizeNonNull() noexcept = delete
template<>
Vec4<int> normalized() const noexcept = delete
template<>
Vec4<int> normalizedExc() const = delete
template<>
Vec4<int> normalizedNonNull() const noexcept = delete
template<>
int64_t length() const noexcept = delete
template<>
const Vec4<int64_t> &normalize() noexcept = delete
template<>
const Vec4<int64_t> &normalizeExc() = delete
template<>
const Vec4<int64_t> &normalizeNonNull() noexcept = delete
template<>
Vec4<int64_t> normalized() const noexcept = delete
template<>
Vec4<int64_t> normalizedExc() const = delete
template<>
Vec4<int64_t> normalizedNonNull() const noexcept = delete

Public Static Functions

static inline constexpr unsigned int dimensions() noexcept

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

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

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