# IC Python API:RLPy RVector2

## Description

This class represents a 2D vector (x, y). This class provides access to RLPy's internal 2D vector math library allowing 2D vectors to be handled easily, in a manner compatible with internal RLPy data structures. It also supports operators and provides some constants for your convenience:

Constant Description
RVector2.ZERO 2D zero vector2: (0, 0)
RVector2.UNIT_X 2D x unit vector2: (1, 0)
RVector2.UNIT_Y 2D y unit vector2: (0, 1)
RVector2.UNIT_XY 2D unit vector2: (1, 1)

## Constructors & Destructors

### __init__

Initialize a new RVector2 object as a zeroed 2D vector: (0, 0).

```a = RLPy.RVector2()
```

### __init__( self, x, y )

Initialize a new RVector2 object as a 2D vector: (x, y).

#### Parameters

x [IN] a numerical value for x coordinate - float / int
y [IN] a numerical value for y coordinate - float / int
```a = RLPy.RVector2(1, 2)
```

### __init__( self, args )

Initialize a new RVector2 object with another RVector2 object: args. This new RVector2 object has the same value as args.

```a = RLPy.RVector2(1, 2)
b = RLPy.RVector2(a)
```

## Operators

### ==

The "equal to" operator.

```a = RLPy.RVector2(1, 2)
b = a

print(a == b) #True
```

### !=

The "not equal to" operator.

```a = RLPy.RVector2()
b = RLPy.RVector2(1, 2)

print(a != b) #True
```

### <

The "less than" operator. Similar to string comparison: Returns True upon the first match that is less than, and False if it is greater than. If the current comparison is equal, continue onto the next element. If all elements are equal then return False.

```a = RLPy.RVector2(0, 0)
b = RLPy.RVector2(0, 1)
c = RLPy.RVector2(1, 0)
d = RLPy.RVector2(0, 0)

print(a< b) #True
print(b< c) #True
print(a< d) #False
```

### >

The "greater than" operator. Similar to string comparison: Returns True upon the first match that is greater than, and False if it is less than. If the current comparison is equal, continue onto the next element. If all elements are equal then return False.

```a = RLPy.RVector2(0, 0)
b = RLPy.RVector2(0, 1)
c = RLPy.RVector2(1, 0)
d = RLPy.RVector2(0, 0)

print(b >a) #True
print(c >b) #True
print(d >a) #False
```

### <=

The "less than or equal" operator. Similar to string comparison: Returns True upon the first match that is less than, and False if it is greater than. If the current comparison is equal, continue onto the next element. If all elements are equal then return True.

```a = RLPy.RVector2(0, 0)
b = RLPy.RVector2(0, 1)
c = RLPy.RVector2(1, 0)
d = RLPy.RVector2(0, 0)

print(a<= b) #True
print(b<= c) #True
print(a<= d) #True
```

### >=

The "greater than or equal" operator. Similar to string comparison: Returns True upon the first match that is greater than, and False if it is less than. If the current comparison is equal, continue onto the next element. If all elements are equal then return True.

```a = RLPy.RVector2(0, 0)
b = RLPy.RVector2(0, 1)
c = RLPy.RVector2(1, 0)
d = RLPy.RVector2(0, 0)

print(b >= a) #True
print(c >= b) #True
print(d >= a) #True
```

### +

```a = RLPy.RVector2(0, 1)
b = RLPy.RVector2(1, 2)
c = a + b

print(str(c.x) + ', ' + str(c.y)) # 1.0, 3.0
```

### -

The "subtraction" operator. Perform 2D vector subtraction.

```a = RLPy.RVector2(0, 1)
b = RLPy.RVector2(1, 3)
c = b - a

print(str(c.x) + ', ' + str(c.y)) # 1.0, 2.0
```

### *

The "multiplication" operator. Perform a scalar multiplication when the second operand is an integer or float. If the second operand is another 2D vector, then the corresponding elements are multiplied.

```a = RLPy.RVector2(1, 2)
b = a * 2
c = RLPy.RVector2(2, 3)
d = a * c

print(str(b.x) + ', ' + str(b.y)) # 2.0, 4.0
print(str(d.x) + ', ' + str(d.y)) # 2.0, 6.0
```

### /

The "division" operator. Perform a scalar division when the second operand is an integer or float. If the second operand is another 2D vector, then the corresponding elements are divided.

```a = RLPy.RVector2(1, 2)
b = a / 2
c = RLPy.RVector2(2, 3)
d = a / c

print(str(b.x) + ', ' + str(b.y)) # 0.5, 1.0
print(str(d.x) + ', ' + str(d.y)) # 0.5, 0.6666666865348816
```

### -

The "unary minus" operator. Inverse the sign of each element.

```a = RLPy.RVector2(1, 2)
b = -a

print(str(b.x) + ', ' + str(b.y)) # -1.0, -2.0
```

### +=

```a = RLPy.RVector2(0, 1)
b = RLPy.RVector2(1, 2)
a += b

print(str(a.x) + ', ' + str(a.y)) # 1.0, 3.0
```

### -=

The "subtraction assignment" operator.

```a = RLPy.RVector2(0, 1)
b = RLPy.RVector2(1, 2)
a -= b

print(str(a.x) + ', ' + str(a.y)) # -1.0, -1.0
```

### *=

The "multiplication assignment" operator. For the calculation method, refer to the * operator.

```a = RLPy.RVector2(1, 2)
a *= 2
b = RLPy.RVector2(1, 2)
c = RLPy.RVector2(2, 3)
b *= c

print(str(a.x) + ', ' + str(a.y)) # 2.0, 4.0
print(str(b.x) + ', ' + str(b.y)) # 2.0, 6.0
```

### /=

The "division assignment" operator. For the calculation method, refer to the / operator.

```a = RLPy.RVector2(1, 2)
a /= 2
b = RLPy.RVector2(1, 2)
c = RLPy.RVector2(2, 3)
b /= c

print(str(a.x) + ', ' + str(a.y)) # 0.5, 1.0
print(str(b.x) + ', ' + str(b.y)) # 0.5, 0.6666666865348816
```

## Member Functions

### AddWithWeight ( self, vSrc, fWeight )

Add this and another 2D vector with weighting.

#### Parameters

vSrc [IN] The 2D vector to add - RVector2
fWeight [IN] The weight value - float
```a = RLPy.RVector2(0, 1)
b = RLPy.RVector2(1, 2)

print(str(a.x) + ', ' + str(a.y)) # 2.0, 5.0
```

### Dot ( self, vV )

Calculate dot production of the two vectors.

#### Parameters

vV [IN] Another 2D vector to compute dot product - RVector2

#### Returns

The value of the dot product - float
```a = RLPy.RVector2(1, 2)
dot = a.Dot( RLPy.RVector2(3, 5) )

print(dot) #13.0
```

### Inverse ( self )

Return the inverse of this 2D vector by inverting its x, y elements.

#### Returns

A new 2D vector that is the inverse of this 2D vector - RVector2
```a = RLPy.RVector2(0.5, 4)
b = a.Inverse()

print(str(b.x) + ', ' + str(b.y)) # 2.0, 0.25
```

### Length ( self )

Get the length of this 2D vector.

#### Returns

The length of this 2D vector - float
```a = RLPy.RVector2(3, 4)

print( str(a.Length()) ) # 5.0
```

### Normalize ( self )

Normalize this 2D vector.

#### Returns

The length of this 2D vector before normalization - float
```a = RLPy.RVector2(1, 1)
b = a.Normalize()

print(str(a.x) + ', ' + str(a.y)) # 0.7071067690849304, 0.7071067690849304
print(b) # 1.4142135381698608
```

### SetX ( self, tX )

Set the value of the x-axis on this 2D vector.

#### Parameters

tX [IN] the value of the x-axis - float
```a = RLPy.RVector2(1, 1)
a.SetX(10)

print(str(a.x) + ', ' + str(a.y)) # 10.0, 1.0
```

### SetY ( self, tY )

Set the value of the y-axis on this 2D vector.

#### Parameters

tY [IN] The value of the y-axis.
```a = RLPy.RVector2(1, 1)
a.SetY(10)

print(str(a.x) + ', ' + str(a.y)) # 1.0, 10.0
```

### SquaredLength ( self )

Get the squared length of this 2D vector.

#### Returns

The squared length of this 2D vector - float
```a = RLPy.RVector2(1, 1)

print(a.SquaredLength()) # 2.0
```