Vector Calculations in Python

Question

If you are looking for a simple script to do vector calculations in python, you can use this one. Enjoy ;) I didn't find some other easy to use scripts, so created my own. You can do these basic calculations with the vector class

• sum
• norm
• scalar product
• cross product
• etc

Answer 1

I think your scalar product calculation is wrong…scalar product should yield a real number, not a vector. Other calculations use this, so those are also broken.

Answer 2

import math
class Vector:
    def __init__(self, values):
        """
        create vector
        """
        self.__values = tuple(values)

    def get_values(self):
        """
        get the coordinates
        """
        return self.__values

    def get_size(self):
        """
        get number of coordinates
        """
        return len(self.get_values())

    def __add__(self, other):
        """
        add two vectors
        """
        if self.get_size() == other.get_size():
            return Vector(tuple(map(lambda x, y: x + y, self.get_values(), other.get_values())))

    def __eq__(self, other):
        """
        compare two vectors
        """
        if self.get_size() == other.get_size():
            return all(map(lambda x, y: x == y, self.get_values(), other.get_values()))

    def __mul__(self, other):
        """
        multiply by a scalar
        """
        return Vector(tuple(map(lambda x: x * other, self.get_values())))

    def scalar_product(self, other):
        """
        scalar product or dot product of two vectors
        """
        return Vector(tuple(map(lambda x, y: x * y, self.get_values(), other.get_values())))

    def cross_product(self, other):
        """
        Cross product
        """
        return Vector((self.get_values()[1] * other.get_values()[2] - self.get_values()[2] * other.get_values()[1], \
                       self.get_values()[2] * other.get_values()[0] - self.get_values()[0] * other.get_values()[2], \
                       self.get_values()[0] * other.get_values()[1] - self.get_values()[1] * other.get_values()[0]))

    def __str__(self):
        """
        printing a vector
        """
        return str(list(self.get_values()))

    def get_norm(self):
        """
        get the norm, or length
        """
        return math.sqrt(sum(self.get_values()[x] ** 2 for x in range(0, self.get_size())))

    def get_angle_radians(self, other):
        """
        angle between two vectors in radians
        """
        return math.acos(self.scalar_product(other).get_norm() / (self.get_norm() * other.get_norm()))

    def get_angle_degrees(self, other):
        """
            angle between two vectors in degrees
        """
        return 180 / math.pi * self.get_angle_radians(other)

    def get_direction(self):
        """
            get direction
        """
        return self * (1/ self.get_norm())

    def __sub__(self, other):
        """
        substract two vectors
        """
        return self+ (other*-1)

    def __truediv__(self,other):
        """
        devide two vectors
        """
        return self*(1/other)

vec1 = Vector((1, 2, 3))
vec2 = Vector((3, 2, 1))
vec3 = Vector((4, 4, 4))
vec4 = Vector((1, 1, 1))
vec5 = Vector((3, 4, 3))
vec6 = Vector((0, 0, 0))
vec7 = Vector((1, 1, 1, 1))
vec8 = Vector((0, 0, 1))
vec9 = Vector((1, 0, 0))
vec10 = Vector((-4,8,-4))
assert vec1 + vec2 == vec3
assert vec4 * 4 == vec3
assert Vector.scalar_product(vec1, vec2) == vec5
assert Vector.cross_product(vec4, vec3) == vec6
assert Vector.cross_product(vec1, vec2) == vec10
assert Vector.get_norm(vec7) == 2
assert Vector.get_angle_radians(vec8, vec9) == math.pi/2
assert Vector.get_angle_degrees(vec8, vec9) ==90
assert Vector.get_direction(vec9) == vec9
assert vec3-vec2 == vec1
assert vec3/4 == vec4