Para definir vectores con R, simplemente utilizamos la función c()

x = c(1,2,3,4,5,6,7,8,9,0)
x

 [1] 1 2 3 4 5 6 7 8 9 0

Para saber la longitud de un vector (la dimensión), utilizamos la función length()

length(x)

[1] 10

Sumar y restar dos o más vectores es muy simple, siempre y cuando sean de la misma dimensión:

x = c(0,3,-1,3,5)
y = c(1,2,3,-1,0)
x+y

[1] 1 5 2 2 5

x-y

[1] -1  1 -4  4  5

El producto por un escalar también funciona de forma sencilla:

x = c(1,0,-1,0,2,0,-2)
2*x

[1]  2  0 -2  0  4  0 -4

-2*x

[1] -2  0  2  0 -4  0  4

5*x

[1]   5   0  -5   0  10   0 -10

El producto escalar no está definido en R, pero es sencillo crear una función que nos lo calcule:

productoEscalar = function(x,y){
  if (length(x) == length(y)){
    sum(x*y)
  }else{
    print("ERROR: No se puede calcular el producto escalar de estos dos vectores porque 
          no son de la misma dimensión")
  }
}

Simplemente, lo que hace la función anterior es calcular el producto escalar de dos vectores, siempre y cuando estos tengan la misma dimensión.

Si no, salta un mensaje explicando el error cometido.

x = c(0,3,-1,3,5)
y = c(1,2,3,-1,0)
productoEscalar(x,y)

[1] 0

Para calcular la norma euclídea de un vector, utilizamos la función Norm()

x = c(1,2,0,3,-1,1)
Norm(x)

[1] 4

La distancia entre dos puntos \(x,y\), se define como la norma del vector \(\vec{xy}\), es decir \(\text{d}(x,y) = ||x-y||\). Para calcularla, definimos la función distancia() del siguiente modo:

distancia = function(x,y){
  if (length(x) == length(y)){
    Norm(x-y)
  }else{
    print("ERROR: No se puede calcular la distancia entre estos dos puntos porque 
          no son de la misma dimensión")
  }
}

x = c(0,3,-1,3,5)
y = c(1,2,3,-1,0)
distancia(x,y)

[1] 7.681146

Simplemente, lo que hace la función anterior es calcular la distancia Euclídea entre dos puntos, siempre y cuando estos tengan la misma dimensión.

Si no, salta un mensaje explicando el error cometido.

Si queremos calcular el ángulo entre dos vectores, debemos definir nosotros mismos la función

angleRad = function(x,y){
  if (length(x) == length(y)){
    acos(productoEscalar(x,y)/(Norm(x)*Norm(y)))
  }else{
    print("ERROR: No se puede calcular el ángulo entre estos dos vectores porque 
          no son de la misma dimensión")
  }
}
angleRad(x,y)

[1] 1.570796

Nuestra función nos devuelve el resultado en Radianes. En caso de querer el resultado en grados, lo que podemos hacer es una pequeña conversión:

angleGrad = function(x,y){
  if (length(x) == length(y)){
    acos(productoEscalar(x,y)/(Norm(x)*Norm(y)))*360/(2*pi)
  }else{
    print("ERROR: No se puede calcular el ángulo entre estos dos vectores porque 
          no son de la misma dimensión")
  }
}
angleGrad(x,y)

[1] 90

proyeccionOrt = function(u,v){
  if (length(u) == length(v)){
    productoEscalar(u,v)/Norm(u)^2*u
  }else{
    print("ERROR: No se puede calcular la proyección ortogonal de v sobre 
          u porque no son de la misma dimensión")
  }
}
u = c(3,1)
v = c(1,2)
proyeccionOrt(u,v)

[1] 1.5 0.5

productoVectorial= function(x,y){
  if (length(x) == length(y) & length(x) == 3){
    c(x[2]*y[3] - x[3]*y[2], -(x[1]*y[3]-x[3]*y[1]), x[1]*y[2]-x[2]*y[1])
  }else{
    print("No se cumplen las condiciones necesarias para calcular el 
          producto vectorial de estos dos vectores")
  }
}

x = c(1,2,3)
y = c(0,-1,1)
productoVectorial(x,y)

[1]  5 -1 -1

productoMixto = function(x,y,z){
  if (length(x) == length(y) & length(x) == length(z) & length(x) == 3){
    det(rbind(x,y,z))
  }else{
    print("No se cumplen las condiciones necesarias para calcular el 
          producto mixto de estos tres vectores")
  }
}

x = c(1,2,3)
y = c(0,-1,1)
z = c(2,0,-3)
productoMixto(x,y,z)

[1] 13

Para crear un vector en Python, utilizamos numpy.array()

import numpy as np
x = np.array([1,2,3,4,5,6,7,8,9,0])
x

array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])

Para calcular la longitud (la dimensión), utilizamos la función len()

len(x)

10

Sumar y restar dos o más vectores es muy simple, siempre y cuando sean de la misma dimensión:

x = np.array([0, 3, -1, 3, 5])
y = np.array([1, 2, 3, -1, 0])
x+y

array([1, 5, 2, 2, 5])

x-y

array([-1,  1, -4,  4,  5])

El producto por un escalar también funciona de forma sencilla:

x = np.array([1,0,-1,0,2,0,-2])
2*x

array([ 2,  0, -2,  0,  4,  0, -4])

-2*x

array([-2,  0,  2,  0, -4,  0,  4])

5*x

array([  5,   0,  -5,   0,  10,   0, -10])

def productoEscalar(x,y):
  if len(x) == len(y):
    suma = 0
    for i in range(0,len(x)):
      suma = suma + x[i]*y[i]
    return suma
  else:
   return "ERROR: las longitudes de los vectores no coinciden"
x = np.array([0, 3, -1, 3, 5])
y = np.array([1, 2, 3, -1, 0])
productoEscalar(x,y)

0

Simplemente, lo que hace la función anterior es calcular el producto escalar de dos vectores, siempre y cuando estos tengan la misma dimensión.

Si no, salta un mensaje explicando el error cometido.

Para calcular la norma de un vector, lo que hacemos es utilizar la función numpy.linalg.norm():

x = np.array([1,2,0,3,-1,1])
np.linalg.norm(x)

4.0

Para calcular la distancia entre dos puntos, la definimos la norma del vector que los une, es decir \(d(x,y)=||x−y||\). En nuestro caso vamos a utilizar la función distancia(), la cual definimos del siguiente modo:

def distancia(x,y):
  import numpy as np
  if len(x) == len(y):
    dist =  np.linalg.norm(x-y)
    return dist
  else:
   return "ERROR: las longitudes de los vectores no coinciden"

x = np.array([0, 3, -1, 3, 5])
y = np.array([1, 2, 3, -1, 0])
distancia(x,y)

7.6811457478686078

def angleRad(x,y):
  import numpy as np
  import math
  if len(x) == len(y):
    angle = math.acos(productoEscalar(x,y)/(np.linalg.norm(x)*np.linalg.norm(y)))
    return angle
  else:
    return "ERROR: Las dimensiones no coinciden" 
          
x = np.array([0, 3, -1, 3, 5])
y = np.array([1, 2, 3, -1, 0])
angleRad(x,y)

1.5707963267948966

Si lo que queremos es el resultado en grados,

def angleGrad(x,y):
  import numpy as np
  import math
  if len(x) == len(y):
    angle = math.acos(productoEscalar(x,y)/(np.linalg.norm(x)*np.linalg.norm(y)))
    return angle/(2*math.pi)*360
  else:
    return "ERROR: Las dimensiones no coinciden" 
          
x = np.array([0, 3, -1, 3, 5])
y = np.array([1, 2, 3, -1, 0])
angleGrad(x,y)

90.0

def proyeccionOrt(u,v):
  import numpy as np
  if len(u) == len(v):
    proy = (productoEscalar(u,v)/pow(np.linalg.norm(u),2))*u
    return proy
  else:
    return "ERROR: Las dimensiones no coinciden"
    
u = np.array([3,1])
v = np.array([1,2])
proyeccionOrt(u,v)

array([ 1.5,  0.5])

def productoVectorial(x,y):
  import numpy as np
  if len(x) == len(y) and len(x) == 3:
    z = np.array([x[1]*y[2] - x[2]*y[1], -(x[0]*y[2]-x[2]*y[0]), x[0]*y[1]-x[1]*y[0]])
    return z
  else:
    return "ERROR"

x = np.array([1,2,3])
y = np.array([0,-1,1])
productoVectorial(x,y)

array([ 5, -1, -1])

def productoMixto(x,y,z):
  import numpy as np
  if len(x) == len(y) and len(x) == len(z) and len(z) == 3:
    return np.linalg.det(np.array([x,y,z]))
  else:
    return "ERROR"

x = np.array([1,2,3])
y = np.array([0,-1,1])
z = np.array([2,0,-3])
productoMixto(x,y,z)

13.0

Todo lo relativo a vectores con Octave se encuentra en un script en la carpeta codigo, subcarpeta Octave, del GitHub.