Vector

Imath.V2s

class Imath.V2s

short: None

short: None

V2s() → V2s

V2s(V2s 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)

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&

length() const -> short

length2() const -> short

normalize() → V2s&

normalizeExc() → V2s&

normalizeNonNull() → V2s&

normalized() const -> V2s

normalizedExc() const -> V2s

normalizedNonNull() const -> V2s

project(V2s v) const -> V2s

orthogonal(V2s v) const -> V2s

reflect(V2s v) const -> V2s

toTable() const -> table[2]

static dimensions() → int

static baseTypeMin() → 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(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)

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&

length() const -> int

length2() const -> int

normalize() → V2i&

normalizeExc() → V2i&

normalizeNonNull() → V2i&

normalized() const -> V2i

normalizedExc() const -> V2i

normalizedNonNull() const -> V2i

project(V2i v) const -> V2i

orthogonal(V2i v) const -> V2i

reflect(V2i v) const -> V2i

toTable() const -> table[2]

static dimensions() → int

static baseTypeMin() → 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(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)

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 baseTypeMin() → 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(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)

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 baseTypeMin() → 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(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)

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&

length() const -> short

length2() const -> short

normalize() → V3s&

normalizeExc() → V3s&

normalizeNonNull() → V3s&

normalized() const -> V3s

normalizedExc() const -> V3s

normalizedNonNull() const -> V3s

project(V3s v) const -> V3s

orthogonal(V3s v) const -> V3s

reflect(V3s v) const -> V3s

toTable() const -> table[3]

static dimensions() → int

static baseTypeMin() → 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(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)

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&

length() const -> int

length2() const -> int

normalize() → V3i&

normalizeExc() → V3i&

normalizeNonNull() → V3i&

normalized() const -> V3i

normalizedExc() const -> V3i

normalizedNonNull() const -> V3i

project(V3i v) const -> V3i

orthogonal(V3i v) const -> V3i

reflect(V3i v) const -> V3i

toTable() const -> table[3]

static dimensions() → int

static baseTypeMin() → 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(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)

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 baseTypeMin() → 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(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)

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 baseTypeMin() → 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(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)

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&

length() const -> short

length2() const -> short

normalize() → V4s&

normalizeExc() → V4s&

normalizeNonNull() → V4s&

normalized() const -> V4s

normalizedExc() const -> V4s

normalizedNonNull() const -> V4s

project(V4s v) const -> V4s

orthogonal(V4s v) const -> V4s

reflect(V4s v) const -> V4s

toTable() const -> table[4]

static dimensions() → int

static baseTypeMin() → 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(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)

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&

length() const -> int

length2() const -> int

normalize() → V4i&

normalizeExc() → V4i&

normalizeNonNull() → V4i&

normalized() const -> V4i

normalizedExc() const -> V4i

normalizedNonNull() const -> V4i

project(V4i v) const -> V4i

orthogonal(V4i v) const -> V4i

reflect(V4i v) const -> V4i

toTable() const -> table[4]

static dimensions() → int

static baseTypeMin() → 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(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)

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 baseTypeMin() → 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(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)

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 baseTypeMin() → double

static baseTypeMax() → double

static baseTypeSmallest() → double

static baseTypeEpsilon() → double

static closestVertex(V4d v0, V4d v1, V4d v2, V4d p) → V4d