# Vector¶

## Imath.V2s¶

class Imath.V2s
short: None
short: None
V2s() V2s
V2s(V2s v) V2s
V2s(V2d v) V2s
V2s(V2f v) V2s
V2s(V2i v) V2s
V2s(short a) V2s
V2s(short a, short b) V2s
V2s(table[2] t) V2s
operator==(V2s v) const -> boolean
operator!=(V2s v) const -> boolean
operator+(V2s v) const -> V2s
operator-(V2s v) const -> V2s
operator-() const -> V2s
operator*(V2s) const -> V2s
operator*(short s) const -> V2s
operator/(V2s v) const -> V2s
operator/(short s) const -> V2s
operator[](int idx) const -> short
operator[](int idx, short value)
equals(V2d v) const -> boolean
equals(V2f v) const -> boolean
equals(V2i v) const -> boolean
equals(V2s v) const -> boolean
equalWithAbsError(V2s v, short e) const -> boolean
equalWithRelError(V2s v, short e) const -> boolean
dot(V2s v) short
cross(V2s v) const -> short
negate() V2s&
toTable() const -> table[2]
static dimensions() int
static baseTypeLowest() short
static baseTypeMax() short
static baseTypeSmallest() short
static baseTypeEpsilon() short
static closestVertex(V2s v0, V2s v1, V2s v2, V2s p) V2s

## Imath.V2i¶

class Imath.V2i
int: None
int: None
V2i() V2i
V2i(V2i v) V2i
V2i(V2d v) V2i
V2i(V2f v) V2i
V2i(V2s v) V2i
V2i(int a) V2i
V2i(int a, int b) V2i
V2i(table[2] t) V2i
operator==(V2i v) const -> boolean
operator!=(V2i v) const -> boolean
operator+(V2i v) const -> V2i
operator-(V2i v) const -> V2i
operator-() const -> V2i
operator*(V2i) const -> V2i
operator*(int s) const -> V2i
operator/(V2i v) const -> V2i
operator/(int s) const -> V2i
operator[](int idx) const -> int
operator[](int idx, int value)
equals(V2d v) const -> boolean
equals(V2f v) const -> boolean
equals(V2i v) const -> boolean
equals(V2s v) const -> boolean
equalWithAbsError(V2i v, int e) const -> boolean
equalWithRelError(V2i v, int e) const -> boolean
dot(V2i v) int
cross(V2i v) const -> int
negate() V2i&
toTable() const -> table[2]
static dimensions() int
static baseTypeLowest() int
static baseTypeMax() int
static baseTypeSmallest() int
static baseTypeEpsilon() int
static closestVertex(V2i v0, V2i v1, V2i v2, V2i p) V2i

## Imath.V2f¶

class Imath.V2f
float: None
float: None
V2f() V2f
V2f(V2f v) V2f
V2f(V2d v) V2f
V2f(V2i v) V2f
V2f(V2s v) V2f
V2f(float a) V2f
V2f(float a, float b) V2f
V2f(table[2] t) V2f
operator==(V2f v) const -> boolean
operator!=(V2f v) const -> boolean
operator+(V2f v) const -> V2f
operator-(V2f v) const -> V2f
operator-() const -> V2f
operator*(V2f) const -> V2f
operator*(float s) const -> V2f
operator/(V2f v) const -> V2f
operator/(float s) const -> V2f
operator*(M33f m) const -> V2f
operator[](int idx) const -> float
operator[](int idx, float value)
equals(V2d v) const -> boolean
equals(V2f v) const -> boolean
equals(V2i v) const -> boolean
equals(V2s v) const -> boolean
equalWithAbsError(V2f v, float e) const -> boolean
equalWithRelError(V2f v, float e) const -> boolean
dot(V2f v) float
cross(V2f v) const -> float
negate() V2f&
length() const -> float
length2() const -> float
normalize() V2f&
normalizeExc() V2f&
normalizeNonNull() V2f&
normalized() const -> V2f
normalizedExc() const -> V2f
normalizedNonNull() const -> V2f
project(V2f v) const -> V2f
orthogonal(V2f v) const -> V2f
reflect(V2f v) const -> V2f
toTable() const -> table[2]
static dimensions() int
static baseTypeLowest() float
static baseTypeMax() float
static baseTypeSmallest() float
static baseTypeEpsilon() float
static closestVertex(V2f v0, V2f v1, V2f v2, V2f p) V2f

## Imath.V2d¶

class Imath.V2d
double: None
double: None
V2d() V2d
V2d(V2d v) V2d
V2d(V2f v) V2d
V2d(V2i v) V2d
V2d(V2s v) V2d
V2d(double a) V2d
V2d(double a, double b) V2d
V2d(table[2] t) V2d
operator==(V2d v) const -> boolean
operator!=(V2d v) const -> boolean
operator+(V2d v) const -> V2d
operator-(V2d v) const -> V2d
operator-() const -> V2d
operator*(V2d) const -> V2d
operator*(double s) const -> V2d
operator/(V2d v) const -> V2d
operator/(double s) const -> V2d
operator*(M33d m) const -> V2d
operator[](int idx) const -> double
operator[](int idx, double value)
equals(V2d v) const -> boolean
equals(V2f v) const -> boolean
equals(V2i v) const -> boolean
equals(V2s v) const -> boolean
equalWithAbsError(V2d v, double e) const -> boolean
equalWithRelError(V2d v, double e) const -> boolean
dot(V2d v) double
cross(V2d v) const -> double
negate() V2d&
length() const -> double
length2() const -> double
normalize() V2d&
normalizeExc() V2d&
normalizeNonNull() V2d&
normalized() const -> V2d
normalizedExc() const -> V2d
normalizedNonNull() const -> V2d
project(V2d v) const -> V2d
orthogonal(V2d v) const -> V2d
reflect(V2d v) const -> V2d
toTable() const -> table[2]
static dimensions() int
static baseTypeLowest() double
static baseTypeMax() double
static baseTypeSmallest() double
static baseTypeEpsilon() double
static closestVertex(V2d v0, V2d v1, V2d v2, V2d p) V2d

## Imath.V3s¶

InfException: None

`INF_EXCEPTION`

class Imath.V3s
short: None
short: None
short: None
V3s() V3s
V3s(V3s v) V3s
V3s(V3d v) V3s
V3s(V3f v) V3s
V3s(V3i v) V3s
V3s(short a) V3s
V3s(short a, short b, short c) V3s
V3s(table[3] t) V3s
V3s(V4s v) V3s
V3s(V4s v, InfException) V3s
operator==(V3s v) const -> boolean
operator!=(V3s v) const -> boolean
operator+(V3s v) const -> V3s
operator-(V3s v) const -> V3s
operator-() const -> V3s
operator*(V3s) const -> V3s
operator*(short s) const -> V3s
operator/(V3s v) const -> V3s
operator/(short s) const -> V3s
operator[](int idx) const -> short
operator[](int idx, short value)
equals(V3d v) const -> boolean
equals(V3f v) const -> boolean
equals(V3i v) const -> boolean
equals(V3s v) const -> boolean
equalWithAbsError(V3s v, short e) const -> boolean
equalWithRelError(V3s v, short e) const -> boolean
dot(V3s v) short
cross(V3s v) const -> V3s
negate() V3s&
toTable() const -> table[3]
static dimensions() int
static baseTypeLowest() short
static baseTypeMax() short
static baseTypeSmallest() short
static baseTypeEpsilon() short
static closestVertex(V3s v0, V3s v1, V3s v2, V3s p) V3s

## Imath.V3i¶

class Imath.V3i
int: None
int: None
int: None
V3i() V3i
V3i(V3i v) V3i
V3i(V3d v) V3i
V3i(V3f v) V3i
V3i(V3s v) V3i
V3i(int a) V3i
V3i(int a, int b, int c) V3i
V3i(table[3] t) V3i
V3i(V4i v) V3i
V3i(V4i v, InfException) V3i
operator==(V3i v) const -> boolean
operator!=(V3i v) const -> boolean
operator+(V3i v) const -> V3i
operator-(V3i v) const -> V3i
operator-() const -> V3i
operator*(V3i) const -> V3i
operator*(int s) const -> V3i
operator/(V3i v) const -> V3i
operator/(int s) const -> V3i
operator[](int idx) const -> int
operator[](int idx, int value)
equals(V3d v) const -> boolean
equals(V3f v) const -> boolean
equals(V3i v) const -> boolean
equals(V3s v) const -> boolean
equalWithAbsError(V3i v, int e) const -> boolean
equalWithRelError(V3i v, int e) const -> boolean
dot(V3i v) int
cross(V3i v) const -> V3i
negate() V3i&
toTable() const -> table[3]
static dimensions() int
static baseTypeLowest() int
static baseTypeMax() int
static baseTypeSmallest() int
static baseTypeEpsilon() int
static closestVertex(V3i v0, V3i v1, V3i v2, V3i p) V3i

## Imath.V3f¶

class Imath.V3f
float: None
float: None
float: None
V3f() V3f
V3f(V3f v) V3f
V3f(V3d v) V3f
V3f(V3i v) V3f
V3f(V3s v) V3f
V3f(float a) V3f
V3f(float a, float b, float c) V3f
V3f(table[3] t) V3f
V3f(V4f v) V3f
V3f(V4f v, InfException) V3f
operator==(V3f v) const -> boolean
operator!=(V3f v) const -> boolean
operator+(V3f v) const -> V3f
operator-(V3f v) const -> V3f
operator-() const -> V3f
operator*(V3f) const -> V3f
operator*(float s) const -> V3f
operator/(V3f v) const -> V3f
operator/(float s) const -> V3f
operator*(M33f m) const -> V3f
operator*(M44f m) const -> V3f
operator[](int idx) const -> float
operator[](int idx, float value)
equals(V3d v) const -> boolean
equals(V3f v) const -> boolean
equals(V3i v) const -> boolean
equals(V3s v) const -> boolean
equalWithAbsError(V3f v, float e) const -> boolean
equalWithRelError(V3f v, float e) const -> boolean
dot(V3f v) float
cross(V3f v) const -> V3f
negate() V3f&
length() const -> float
length2() const -> float
normalize() V3f&
normalizeExc() V3f&
normalizeNonNull() V3f&
normalized() const -> V3f
normalizedExc() const -> V3f
normalizedNonNull() const -> V3f
project(V3f v) const -> V3f
orthogonal(V3f v) const -> V3f
reflect(V3f v) const -> V3f
toTable() const -> table[3]
static dimensions() int
static baseTypeLowest() float
static baseTypeMax() float
static baseTypeSmallest() float
static baseTypeEpsilon() float
static closestVertex(V3f v0, V3f v1, V3f v2, V3f p) V3f

## Imath.V3d¶

class Imath.V3d
double: None
double: None
double: None
V3d() V3d
V3d(V3d v) V3d
V3d(V3f v) V3d
V3d(V3i v) V3d
V3d(V3s v) V3d
V3d(double a) V3d
V3d(double a, double b, double c) V3d
V3d(table[3] t) V3d
V3d(V4d v) V3d
V3d(V4d v, InfException) V3d
operator==(V3d v) const -> boolean
operator!=(V3d v) const -> boolean
operator+(V3d v) const -> V3d
operator-(V3d v) const -> V3d
operator-() const -> V3d
operator*(V3d) const -> V3d
operator*(double s) const -> V3d
operator/(V3d v) const -> V3d
operator/(double s) const -> V3d
operator*(M33d m) const -> V3d
operator*(M44d m) const -> V3d
operator[](int idx) const -> double
operator[](int idx, double value)
equals(V3d v) const -> boolean
equals(V3f v) const -> boolean
equals(V3i v) const -> boolean
equals(V3s v) const -> boolean
equalWithAbsError(V3d v, double e) const -> boolean
equalWithRelError(V3d v, double e) const -> boolean
dot(V3d v) double
cross(V3d v) const -> V3d
negate() V3d&
length() const -> double
length2() const -> double
normalize() V3d&
normalizeExc() V3d&
normalizeNonNull() V3d&
normalized() const -> V3d
normalizedExc() const -> V3d
normalizedNonNull() const -> V3d
project(V3d v) const -> V3d
orthogonal(V3d v) const -> V3d
reflect(V3d v) const -> V3d
toTable() const -> table[3]
static dimensions() int
static baseTypeLowest() double
static baseTypeMax() double
static baseTypeSmallest() double
static baseTypeEpsilon() double
static closestVertex(V3d v0, V3d v1, V3d v2, V3d p) V3d

## Imath.V4s¶

class Imath.V4s
short: None
short: None
short: None
short: None
V4s() V4s
V4s(V4s v) V4s
V4s(V4d v) V4s
V4s(V4f v) V4s
V4s(V4i v) V4s
V4s(short a) V4s
V4s(short a, short b, short c, short d) V4s
V4s(table[4] t) V4s
operator==(V4s v) const -> boolean
operator!=(V4s v) const -> boolean
operator+(V4s v) const -> V4s
operator-(V4s v) const -> V4s
operator-() const -> V4s
operator*(V4s) const -> V4s
operator*(short s) const -> V4s
operator/(V4s v) const -> V4s
operator/(short s) const -> V4s
operator[](int idx) const -> short
operator[](int idx, short value)
equals(V4d v) const -> boolean
equals(V4f v) const -> boolean
equals(V4i v) const -> boolean
equals(V4s v) const -> boolean
equalWithAbsError(V4s v, short e) const -> boolean
equalWithRelError(V4s v, short e) const -> boolean
dot(V4s v) short
cross(V4s v) const -> V4s
negate() V4s&
toTable() const -> table[4]
static dimensions() int
static baseTypeLowest() short
static baseTypeMax() short
static baseTypeSmallest() short
static baseTypeEpsilon() short
static closestVertex(V4s v0, V4s v1, V4s v2, V4s p) V4s

## Imath.V4i¶

class Imath.V4i
int: None
int: None
int: None
int: None
V4i() V4i
V4i(V4i v) V4i
V4i(V4d v) V4i
V4i(V4f v) V4i
V4i(V4s v) V4i
V4i(int a) V4i
V4i(int a, int b, int c, int d) V4i
V4i(table[4] t) V4i
operator==(V4i v) const -> boolean
operator!=(V4i v) const -> boolean
operator+(V4i v) const -> V4i
operator-(V4i v) const -> V4i
operator-() const -> V4i
operator*(V4i) const -> V4i
operator*(int s) const -> V4i
operator/(V4i v) const -> V4i
operator/(int s) const -> V4i
operator[](int idx) const -> int
operator[](int idx, int value)
equals(V4d v) const -> boolean
equals(V4f v) const -> boolean
equals(V4i v) const -> boolean
equals(V4s v) const -> boolean
equalWithAbsError(V4i v, int e) const -> boolean
equalWithRelError(V4i v, int e) const -> boolean
dot(V4i v) int
cross(V4i v) const -> V4i
negate() V4i&
toTable() const -> table[4]
static dimensions() int
static baseTypeLowest() int
static baseTypeMax() int
static baseTypeSmallest() int
static baseTypeEpsilon() int
static closestVertex(V4i v0, V4i v1, V4i v2, V4i p) V4i

## Imath.V4f¶

class Imath.V4f
float: None
float: None
float: None
float: None
V4f() V4f
V4f(V4f v) V4f
V4f(V4d v) V4f
V4f(V4i v) V4f
V4f(V4s v) V4f
V4f(float a) V4f
V4f(float a, float b, float c, float d) V4f
V4f(table[4] t) V4f
operator==(V4f v) const -> boolean
operator!=(V4f v) const -> boolean
operator+(V4f v) const -> V4f
operator-(V4f v) const -> V4f
operator-() const -> V4f
operator*(V4f) const -> V4f
operator*(float s) const -> V4f
operator/(V4f v) const -> V4f
operator/(float s) const -> V4f
operator*(M44f m) const -> V4f
operator[](int idx) const -> float
operator[](int idx, float value)
equals(V4d v) const -> boolean
equals(V4f v) const -> boolean
equals(V4i v) const -> boolean
equals(V4s v) const -> boolean
equalWithAbsError(V4f v, float e) const -> boolean
equalWithRelError(V4f v, float e) const -> boolean
dot(V4f v) float
cross(V4f v) const -> V4f
negate() V4f&
length() const -> float
length2() const -> float
normalize() V4f&
normalizeExc() V4f&
normalizeNonNull() V4f&
normalized() const -> V4f
normalizedExc() const -> V4f
normalizedNonNull() const -> V4f
project(V4f v) const -> V4f
orthogonal(V4f v) const -> V4f
reflect(V4f v) const -> V4f
toTable() const -> table[4]
static dimensions() int
static baseTypeLowest() float
static baseTypeMax() float
static baseTypeSmallest() float
static baseTypeEpsilon() float
static closestVertex(V4f v0, V4f v1, V4f v2, V4f p) V4f

## Imath.V4d¶

class Imath.V4d
double: None
double: None
double: None
double: None
V4d() V4d
V4d(V4d v) V4d
V4d(V4f v) V4d
V4d(V4i v) V4d
V4d(V4s v) V4d
V4d(double a) V4d
V4d(double a, double b, double c, double d) V4d
V4d(table[4] t) V4d
operator==(V4d v) const -> boolean
operator!=(V4d v) const -> boolean
operator+(V4d v) const -> V4d
operator-(V4d v) const -> V4d
operator-() const -> V4d
operator*(V4d) const -> V4d
operator*(double s) const -> V4d
operator/(V4d v) const -> V4d
operator/(double s) const -> V4d
operator*(M44d m) const -> V4d
operator[](int idx) const -> double
operator[](int idx, double value)
equals(V4d v) const -> boolean
equals(V4f v) const -> boolean
equals(V4i v) const -> boolean
equals(V4s v) const -> boolean
equalWithAbsError(V4d v, double e) const -> boolean
equalWithRelError(V4d v, double e) const -> boolean
dot(V4d v) double
cross(V4d v) const -> V4d
negate() V4d&
length() const -> double
length2() const -> double
normalize() V4d&
normalizeExc() V4d&
normalizeNonNull() V4d&
normalized() const -> V4d
normalizedExc() const -> V4d
normalizedNonNull() const -> V4d
project(V4d v) const -> V4d
orthogonal(V4d v) const -> V4d
reflect(V4d v) const -> V4d
toTable() const -> table[4]
static dimensions() int
static baseTypeLowest() double
static baseTypeMax() double
static baseTypeSmallest() double
static baseTypeEpsilon() double
static closestVertex(V4d v0, V4d v1, V4d v2, V4d p) V4d