{{task}}

A vector is defined as having three dimensions as being represented by an ordered collection of three numbers: (X, Y, Z).

If you imagine a graph with the '''x''' and '''y''' axis being at right angles to each other and having a third, '''z''' axis coming out of the page, then a triplet of numbers, (X, Y, Z) would represent a point in the region, and a vector from the origin to the point.

Given the vectors: A = (a₁, a₂, a₃) B = (b₁, b₂, b₃) C = (c₁, c₂, c₃) then the following common vector products are defined:

• '''The dot product''' (a scalar quantity) :::: A • B = a₁b₁ + a₂b₂ + a₃b₃
• '''The cross product''' (a vector quantity) :::: A x B = (a₂b₃ - a₃b₂, a₃b₁ - a₁b₃, a₁b₂ - a₂b₁)
• '''The scalar triple product''' (a scalar quantity) :::: A • (B x C)
• '''The vector triple product''' (a vector quantity) :::: A x (B x C)

;Task: Given the three vectors: a = ( 3, 4, 5) b = ( 4, 3, 5) c = (-5, -12, -13)

Create a named function/subroutine/method to compute the dot product of two vectors.

Create a function to compute the cross product of two vectors.

Optionally create a function to compute the scalar triple product of three vectors.

Optionally create a function to compute the vector triple product of three vectors.

Compute and display: a • b

Compute and display: a x b

Compute and display: a • (b x c), the scalar triple product.

Compute and display: a x (b x c), the vector triple product.

;References:

• A starting page on Wolfram MathWorld is {{Wolfram|Vector|Multiplication}}.
• Wikipedia [[wp:Dot product|dot product]].
• Wikipedia [[wp:Cross product|cross product]].
• Wikipedia [[wp:Triple product|triple product]].

;Related tasks:

• [[Dot product]]
• [[Quaternion type]]

Ada

not using Ada.Numerics.Real_Arrays, to show some features of the language.

Ada determines which function to call not only on the types of the parameters, but also on the return type. That way we can use the same name for all multiplications (scalar and cross). But, if we add another one to stretch the vector, we get an ambiguity error, since the compiler can't know if A*(BC) with result-type Vector is meant to be A stretched by the scalar product of B and C, or the cross product of A and the result of the cross product of B and C. Here, I used type qualification to tell the compiler that the result of (BC) is of type Vector.

vector.adb:

with Ada.Text_IO;

procedure Vector is
   type Float_Vector is array (Positive range <>) of Float;
   package Float_IO is new Ada.Text_IO.Float_IO (Float);

   procedure Vector_Put (X : Float_Vector) is
   begin
      Ada.Text_IO.Put ("(");
      for I in X'Range loop
         Float_IO.Put (X (I), Aft => 1, Exp => 0);
         if I /= X'Last then
            Ada.Text_IO.Put (", ");
         end if;
      end loop;
      Ada.Text_IO.Put (")");
   end Vector_Put;

   -- cross product
   function "*" (Left, Right : Float_Vector) return Float_Vector is
   begin
      if Left'Length /= Right'Length then
         raise Constraint_Error with "vectors of different size in dot product";
      end if;
      if Left'Length /= 3 then
         raise Constraint_Error with "dot product only implemented for R**3";
      end if;
      return Float_Vector'(Left (Left'First + 1) * Right (Right'First + 2) -
                             Left (Left'First + 2) * Right (Right'First + 1),
                           Left (Left'First + 2) * Right (Right'First) -
                             Left (Left'First) * Right (Right'First + 2),
                           Left (Left'First) * Right (Right'First + 1) -
                             Left (Left'First + 1) * Right (Right'First));
   end "*";

   -- scalar product
   function "*" (Left, Right : Float_Vector) return Float is
      Result : Float := 0.0;
      I, J : Positive;
   begin
      if Left'Length /= Right'Length then
         raise Constraint_Error with "vectors of different size in scalar product";
      end if;
      I := Left'First; J := Right'First;
      while I <= Left'Last and then J <= Right'Last loop
         Result := Result + Left (I) * Right (J);
         I := I + 1; J := J + 1;
      end loop;
      return Result;
   end "*";

   -- stretching
   function "*" (Left : Float_Vector; Right : Float) return Float_Vector is
      Result : Float_Vector (Left'Range);
   begin
      for I in Left'Range loop
         Result (I) := Left (I) * Right;
      end loop;
      return Result;
   end "*";

   A : constant Float_Vector := (3.0, 4.0, 5.0);
   B : constant Float_Vector := (4.0, 3.0, 5.0);
   C : constant Float_Vector := (-5.0, -12.0, -13.0);
begin
   Ada.Text_IO.Put ("A: "); Vector_Put (A); Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("B: "); Vector_Put (B); Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("C: "); Vector_Put (C); Ada.Text_IO.New_Line;
   Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("A dot B = "); Float_IO.Put (A * B, Aft => 1, Exp => 0);
   Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("A x B = "); Vector_Put (A * B);
   Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("A dot (B x C) = "); Float_IO.Put (A * (B * C), Aft => 1, Exp => 0);
   Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("A x (B x C) = "); Vector_Put (A * Float_Vector'(B * C));
   Ada.Text_IO.New_Line;
end Vector;

Output:

A: ( 3.0,  4.0,  5.0)
B: ( 4.0,  3.0,  5.0)
C: (-5.0, -12.0, -13.0)

A dot B = 49.0
A x B = ( 5.0,  5.0, -7.0)
A dot (B x C) =  6.0
A x (B x C) = (-267.0, 204.0, -3.0)

ALGOL 68

{{trans|Python}} Note: This specimen retains the original [[#Python|Python]] coding style. {{works with|ALGOL 68|Revision 1 - no extensions to language used.}} {{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}} {{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

MODE FIELD = INT;
FORMAT field fmt = $g(-0)$;

MODE VEC = [3]FIELD;
FORMAT vec fmt = $"("f(field fmt)", "f(field fmt)", "f(field fmt)")"$;

PROC crossp = (VEC a, b)VEC:(
    #Cross product of two 3D vectors#
    CO ASSERT(LWB a = LWB b AND UPB a = UPB b AND UPB b = 3 # "For 3D vectors only" #); CO
    (a[2]*b[3] - a[3]*b[2], a[3]*b[1] - a[1]*b[3], a[1]*b[2] - a[2]*b[1])
);

PRIO MAXLWB = 8, MINUPB=8;

OP MAXLWB = (VEC a, b)INT: (LWB a<LWB b|LWB a|LWB b);
OP MINUPB = (VEC a, b)INT: (UPB a>UPB b|UPB a|UPB b);

PROC dotp = (VEC a, b)FIELD:(
    #Dot product of two vectors#
    FIELD sum := 0;
    FOR i FROM a MAXLWB b TO a MINUPB b DO sum +:= a[i]*b[i] OD;
    sum
);

PROC scalartriplep = (VEC a, b, c)VEC:(
    #Scalar triple product of three vectors: "a . (b x c)"#
    dotp(a, crossp(b, c))
);

PROC vectortriplep = (VEC a, b, c)VEC:(
    #Vector triple product of three vectors: "a x (b x c)"#
    crossp(a, crossp(b, c))
);

# Declare some useful operators #
PRIO DOT = 5, X = 5;
OP (VEC, VEC)FIELD DOT = dotp;
OP (VEC, VEC)VEC X = crossp;

main:(
    VEC a=(3, 4, 5), b=(4, 3, 5), c=(-5, -12, -13);
    printf(($"a = "f(vec fmt)";  b = "f(vec fmt)";  c = "f(vec fmt)l$ , a, b, c));
    printf($"Using PROCedures:"l$);
    printf(($"a . b = "f(field fmt)l$, dotp(a,b)));
    printf(($"a x b = "f(vec fmt)l$, crossp(a,b)));
    printf(($"a . (b x c) = "f(field fmt)l$, scalartriplep(a, b, c)));
    printf(($"a x (b x c) = "f(vec fmt)l$, vectortriplep(a, b, c)));
    printf($"Using OPerators:"l$);
    printf(($"a . b = "f(field fmt)l$, a DOT b));
    printf(($"a x b = "f(vec fmt)l$, a X b));
    printf(($"a . (b x c) = "f(field fmt)l$, a DOT (b X c)));
    printf(($"a x (b x c) = "f(vec fmt)l$, a X (b X c)))
)

Output:

a = (3, 4, 5);  b = (4, 3, 5);  c = (-5, -12, -13)
Using PROCedures:
a . b = 49
a x b = (5, 5, -7)
a . (b x c) = 6
a x (b x c) = (-267, 204, -3)
Using OPerators:
a . b = 49
a x b = (5, 5, -7)
a . (b x c) = 6
a x (b x c) = (-267, 204, -3)

ALGOL W

begin
    % define the Vector record type                                          %
    record Vector( integer X, Y, Z );

    % calculates the dot product of two Vectors                              %
    integer procedure dotProduct( reference(Vector) value A, B ) ;
        ( X(A) * X(B) ) + ( Y(A) * Y(B) ) + ( Z(A) * Z(B) );

    % calculates the cross product or two Vectors                            %
    reference(Vector) procedure crossProduct( reference(Vector) value A, B ) ;
        Vector( ( Y(A) * Z(B) ) - ( Z(A) * Y(B) )
              , ( Z(A) * X(B) ) - ( X(A) * Z(B) )
              , ( X(A) * Y(B) ) - ( Y(A) * X(B) )
              );

    % calculates the scaler triple product of two vectors                    %
    integer procedure scalerTripleProduct( reference(Vector) value A, B, C ) ;
        dotProduct( A, crossProduct( B, C ) );

    % calculates the vector triple product of two vectors                    %
    reference(Vector) procedure vectorTripleProduct( reference(Vector) value A, B, C ) ;
        crossProduct( A, crossProduct( B, C ) );

    % test the Vector routines                                               %
    begin
        procedure writeonVector( reference(Vector) value v ) ;
            writeon( "(", X(v), ", ", Y(v), ", ", Z(v), ")" );

        Reference(Vector) a, b, c;

        a := Vector(  3,   4,   5 );
        b := Vector(  4,   3,   5 );
        c := Vector( -5, -12, -13 );

        i_w := 1; s_w := 0; % set output formatting                          %

        write( "            a: " ); writeonVector( a );
        write( "            b: " ); writeonVector( b );
        write( "            c: " ); writeonVector( c );
        write( "        a . b: ", dotProduct( a, b ) );
        write( "        a x b: " ); writeonVector( crossProduct( a, b ) );
        write( "a . ( b x c ): ", scalerTripleProduct( a, b, c ) );
        write( "a x ( b x c ): " ); writeonVector( vectorTripleProduct( a, b, c ) )
    end
end.

{{out}}

            a: (3, 4, 5)
            b: (4, 3, 5)
            c: (-5, -12, -13)
        a . b: 49
        a x b: (5, 5, -7)
a . ( b x c ): 6
a x ( b x c ): (-267, 204, -3)

AutoHotkey

{{works with|AutoHotkey_L}}

V := {a: [3, 4, 5], b: [4, 3, 5], c: [-5, -12, -13]}

for key, val in V
	Out .= key " = (" val[1] ", " val[2] ", " val[3] ")`n"

CP := CrossProduct(V.a, V.b)
VTP := VectorTripleProduct(V.a, V.b, V.c)

MsgBox, % Out "`na • b = " DotProduct(V.a, V.b) "`n"
	. "a x b = (" CP[1] ", " CP[2] ", " CP[3] ")`n"
	. "a • b x c = " ScalerTripleProduct(V.a, V.b, V.c) "`n"
	. "a x b x c = (" VTP[1] ", " VTP[2] ", " VTP[3] ")"

DotProduct(v1, v2) {
	return, v1[1] * v2[1] + v1[2] * v2[2] + v1[3] * v2[3]
}

CrossProduct(v1, v2) {
	return, [v1[2] * v2[3] - v1[3] * v2[2]
	      ,  v1[3] * v2[1] - v1[1] * v2[3]
	      ,  v1[1] * v2[2] - v1[2] * v2[1]]
}

ScalerTripleProduct(v1, v2, v3) {
	return, DotProduct(v1, CrossProduct(v2, v3))
}

VectorTripleProduct(v1, v2, v3) {
	return, CrossProduct(v1, CrossProduct(v2, v3))
}

'''Output:'''

a = (3, 4, 5)
b = (4, 3, 5)
c = (-5, -12, -13)

a • b = 49
a x b = (5, 5, -7)
a • b x c = 6
a x b x c = (-267, 204, -3)

AWK

#!/usr/bin/awk -f
BEGIN {
     a[1] = 3; a[2]= 4; a[3] = 5;
     b[1] = 4; b[2]= 3; b[3] = 5;
     c[1] = -5; c[2]= -12; c[3] = -13;

     print "a = ",printVec(a);
     print "b = ",printVec(b);
     print "c = ",printVec(c);
     print "a.b = ",dot(a,b);
     ## upper case variables are used as temporary or intermediate results
     cross(a,b,D);print "a.b = ",printVec(D);
     cross(b,c,D);print "a.(b x c) = ",dot(a,D);
     cross(b,c,D);cross(a,D,E); print "a x (b x c) = ",printVec(E);
}

function dot(A,B) {
     return A[1]*B[1]+A[2]*B[2]+A[3]*B[3];
}

function cross(A,B,C) {
     C[1] = A[2]*B[3]-A[3]*B[2];
     C[2] = A[3]*B[1]-A[1]*B[3];
     C[3] = A[1]*B[2]-A[2]*B[1];
}

function printVec(C) {
    return "[ "C[1]" "C[2]" "C[3]" ]";
}

Output:

a =  [ 3 4 5 ]
b =  [ 4 3 5 ]
c =  [ -5 -12 -13 ]
A.b =  49
a.b =  [ 5 5 -7 ]
a.(b x c) =  6
a x (b x c) =  [ -267 204 -3 ]

BASIC256

{{works with|BASIC256 }}

 a={3,4,5}:b={4,3,5}:c={-5,-12,-13}

print "A.B = "+dot_product(ref(a),ref(b))
call cross_product(ref(a),ref(b),ref(y))
Print "AxB = ("+y[0]+","+y[1]+","+y[2]+")"
print "A.(BxC) = "+s_tri(ref(a),ref(b),ref(c))
call v_tri(ref(a),ref(b),ref(c),ref(x),ref(y))
Print "A x (BxC) = ("+y[0]+","+y[1]+","+y[2]+")"

function dot_product(ref(x1),ref(x2))
    dot_product= 0
   for t = 0 to 2
      dot_product += x1[t]*x2[t]
   next t
end function

subroutine cross_product(ref(x1),ref(x2),ref(y1))
   y1={0,0,0}
   y1[0]=x1[1]*x2[2]-x1[2]*x2[1]
   y1[1]=x1[2]*x2[0]-x1[0]*x2[2]
   y1[2]=x1[0]*x2[1]-x1[1]*x2[0]
end subroutine

function s_tri(ref(x1),ref(x2),ref(x3))
   call cross_product(ref(x2),ref(x3),ref(y1))
   s_tri=dot_product(ref(x1),ref(y1))
end function

subroutine v_tri(ref(x1),ref(x2),ref(x3),ref(y1),ref(y2))
  call cross_product(ref(x2),ref(x3),ref(y1))
  call cross_product(ref(x1),ref(y1),ref(y2))
end subroutine

Output:

A.B = 49
AxB = (5,5,-7)
A.(BxC) = 6
A x (BxC) = (-267,204,-3)

BBC BASIC

{{works with|BBC BASIC for Windows}}

      DIM a(2), b(2), c(2), d(2)
      a() = 3, 4, 5
      b() = 4, 3, 5
      c() = -5, -12, -13

      PRINT "a . b = "; FNdot(a(),b())
      PROCcross(a(),b(),d())
      PRINT "a x b = (";d(0)", ";d(1)", ";d(2)")"
      PRINT "a . (b x c) = "; FNscalartriple(a(),b(),c())
      PROCvectortriple(a(),b(),c(),d())
      PRINT "a x (b x c) = (";d(0)", ";d(1)", ";d(2)")"
      END

      DEF FNdot(A(),B())
      LOCAL C() : DIM C(0,0)
      C() = A().B()
      = C(0,0)

      DEF PROCcross(A(),B(),C())
      C() = A(1)*B(2)-A(2)*B(1), A(2)*B(0)-A(0)*B(2), A(0)*B(1)-A(1)*B(0)
      ENDPROC

      DEF FNscalartriple(A(),B(),C())
      LOCAL D() : DIM D(2)
      PROCcross(B(),C(),D())
      = FNdot(A(),D())

      DEF PROCvectortriple(A(),B(),C(),D())
      PROCcross(B(),C(),D())
      PROCcross(A(),D(),D())
      ENDPROC

Output:

a . b = 49
a x b = (5, 5, -7)
a . (b x c) = 6
a x (b x c) = (-267, 204, -3)

C

#include <stdio.h>

typedef struct{
	float i,j,k;
	}Vector;

Vector a = {3, 4, 5},b = {4, 3, 5},c = {-5, -12, -13};

float dotProduct(Vector a, Vector b)
{
	return a.i*b.i+a.j*b.j+a.k*b.k;
}

Vector crossProduct(Vector a,Vector b)
{
	Vector c = {a.j*b.k - a.k*b.j, a.k*b.i - a.i*b.k, a.i*b.j - a.j*b.i};

	return c;
}

float scalarTripleProduct(Vector a,Vector b,Vector c)
{
	return dotProduct(a,crossProduct(b,c));
}

Vector vectorTripleProduct(Vector a,Vector b,Vector c)
{
	return crossProduct(a,crossProduct(b,c));
}

void printVector(Vector a)
{
	printf("( %f, %f, %f)",a.i,a.j,a.k);
}

int main()
{
	printf("\n a = "); printVector(a);
	printf("\n b = "); printVector(b);
	printf("\n c = "); printVector(c);
	printf("\n a . b = %f",dotProduct(a,b));
	printf("\n a x b = "); printVector(crossProduct(a,b));
	printf("\n a . (b x c) = %f",scalarTripleProduct(a,b,c));
	printf("\n a x (b x c) = "); printVector(vectorTripleProduct(a,b,c));

	return 0;
}

Output:

 a = ( 3.000000, 4.000000, 5.000000)
 b = ( 4.000000, 3.000000, 5.000000)
 c = ( -5.000000, -12.000000, -13.000000)
 a . b = 49.000000
 a x b = ( 5.000000, 5.000000, -7.000000)
 a . (b x c) = 6.000000
 a x (b x c) = ( -267.000000, 204.000000, -3.000000)

C#

using System;
using System.Windows.Media.Media3D;

class VectorProducts
{
    static double ScalarTripleProduct(Vector3D a, Vector3D b, Vector3D c)
    {
        return Vector3D.DotProduct(a, Vector3D.CrossProduct(b, c));
    }

    static Vector3D VectorTripleProduct(Vector3D a, Vector3D b, Vector3D c)
    {
        return Vector3D.CrossProduct(a, Vector3D.CrossProduct(b, c));
    }

    static void Main()
    {
        var a = new Vector3D(3, 4, 5);
        var b = new Vector3D(4, 3, 5);
        var c = new Vector3D(-5, -12, -13);

        Console.WriteLine(Vector3D.DotProduct(a, b));
        Console.WriteLine(Vector3D.CrossProduct(a, b));
        Console.WriteLine(ScalarTripleProduct(a, b, c));
        Console.WriteLine(VectorTripleProduct(a, b, c));
    }
}

Output:

49
5;5;-7
6
-267;204;-3

C++

#include <iostream>

template< class T >
class D3Vector {

template< class U >
friend std::ostream & operator<<( std::ostream & , const D3Vector<U> & ) ;

public :
   D3Vector( T a , T b , T c ) {
      x = a ;
      y = b ;
      z = c ;
   }

   T dotproduct ( const D3Vector & rhs ) {
      T scalar = x * rhs.x + y * rhs.y + z * rhs.z ;
      return scalar ;
   }

   D3Vector crossproduct ( const D3Vector & rhs ) {
      T a = y * rhs.z - z * rhs.y ;
      T b = z * rhs.x - x * rhs.z ;
      T c = x * rhs.y - y * rhs.x ;
      D3Vector product( a , b , c ) ;
      return product ;
   }

   D3Vector triplevec( D3Vector & a , D3Vector & b ) {
      return crossproduct ( a.crossproduct( b ) ) ;
   }

   T triplescal( D3Vector & a, D3Vector & b ) {
      return dotproduct( a.crossproduct( b ) ) ;
   }

private :
   T x , y , z ;
} ;

template< class T >
std::ostream & operator<< ( std::ostream & os , const D3Vector<T> & vec ) {
   os << "( "  << vec.x << " ,  " << vec.y << " ,  " << vec.z << " )" ;
   return os ;
}

int main( ) {
   D3Vector<int> a( 3 , 4 , 5 ) , b ( 4 , 3 , 5 ) , c( -5 , -12 , -13 ) ;
   std::cout << "a . b : " << a.dotproduct( b ) << "\n" ;
   std::cout << "a x b : " << a.crossproduct( b ) << "\n" ;
   std::cout << "a . b x c : " << a.triplescal( b , c ) << "\n" ;
   std::cout << "a x b x c : " << a.triplevec( b , c ) << "\n" ;
   return 0 ;
}

Output:

a . b : 49
a x b : ( 5 , 5 , -7 )
a . b x c : 6
a x b x c : ( -267 , 204 , -3 )

Ceylon

shared void run() {

	alias Vector => Float[3];

	function dot(Vector a, Vector b) =>
			a[0] * b[0] + a[1] * b[1] + a[2] * b[2];

	function cross(Vector a, Vector b) => [
		a[1] * b[2] - a[2] * b[1],
		a[2] * b[0] - a[0] * b[2],
		a[0] * b[1] - a[1] * b[0]
	];

	function scalarTriple(Vector a, Vector b, Vector c) =>
			dot(a, cross(b, c));

	function vectorTriple(Vector a, Vector b, Vector c) =>
			cross(a, cross(b, c));

	value a = [ 3.0,    4.0,    5.0 ];
	value b = [ 4.0,    3.0,    5.0 ];
	value c = [-5.0,  -12.0,  -13.0 ];

	print("``a`` . ``b`` = ``dot(a, b)``");
	print("``a`` X ``b`` = ``cross(a, b)``");
	print("``a`` . ``b`` X ``c`` = ``scalarTriple(a, b, c)``");
	print("``a`` X ``b`` X ``c`` = ``vectorTriple(a, b, c)``");
}

{{out}}

[3.0, 4.0, 5.0] . [4.0, 3.0, 5.0] = 49.0
[3.0, 4.0, 5.0] X [4.0, 3.0, 5.0] = [5.0, 5.0, -7.0]
[3.0, 4.0, 5.0] . [4.0, 3.0, 5.0] X [-5.0, -12.0, -13.0] = 6.0
[3.0, 4.0, 5.0] X [4.0, 3.0, 5.0] X [-5.0, -12.0, -13.0] = [-267.0, 204.0, -3.0]

Clojure

(defrecord Vector [x y z])

(defn dot
  [U V]
  (+ (* (:x U) (:x V))
     (* (:y U) (:y V))
     (* (:z U) (:z V))))

(defn cross
  [U V]
  (new Vector
       (- (* (:y U) (:z V)) (* (:z U) (:y V)))
       (- (* (:z U) (:x V)) (* (:x U) (:z V)))
       (- (* (:x U) (:y V)) (* (:y U) (:x V)))))

(let [a (new Vector 3 4 5)
      b (new Vector 4 3 5)
      c (new Vector -5 -12 -13)]
  (doseq
    [prod (list
            (dot a b)
            (cross a b)
            (dot a (cross b c))
            (cross a (cross b c)))]
    (println prod)))

Output:

49
#:user.Vector{:x 5, :y 5, :z -7}
6
#:user.Vector{:x -267, :y 204, :z -3}

Common Lisp

Using the Common Lisp Object System.

(defclass 3d-vector ()
  ((x :type number :initarg :x)
   (y :type number :initarg :y)
   (z :type number :initarg :z)))

(defmethod print-object ((object 3d-vector) stream)
  (print-unreadable-object (object stream :type t)
    (with-slots (x y z) object
      (format stream "~a ~a ~a" x y z))))

(defun make-3d-vector (x y z)
  (make-instance '3d-vector :x x :y y :z z))

(defmethod dot-product ((a 3d-vector) (b 3d-vector))
  (with-slots ((a1 x) (a2 y) (a3 z)) a
    (with-slots ((b1 x) (b2 y) (b3 z)) b
      (+ (* a1 b1) (* a2 b2) (* a3 b3)))))

(defmethod cross-product ((a 3d-vector)
                                 (b 3d-vector))
  (with-slots ((a1 x) (a2 y) (a3 z)) a
    (with-slots ((b1 x) (b2 y) (b3 z)) b
      (make-instance '3d-vector
                     :x (- (* a2 b3) (* a3 b2))
                     :y (- (* a3 b1) (* a1 b3))
                     :z (- (* a1 b2) (* a2 b1))))))

(defmethod scalar-triple-product ((a 3d-vector)
                                  (b 3d-vector)
                                  (c 3d-vector))
  (dot-product a (cross-product b c)))

(defmethod vector-triple-product ((a 3d-vector)
                                  (b 3d-vector)
                                  (c 3d-vector))
  (cross-product a (cross-product b c)))

(defun vector-products-example ()
  (let ((a (make-3d-vector 3 4 5))
        (b (make-3d-vector 4 3 5))
        (c (make-3d-vector -5 -12 -13)))
    (values (dot-product a b)
            (cross-product a b)
            (scalar-triple-product a b c)
            (vector-triple-product a b c))))

Output: CL-USER> (vector-products-example) 49 #<3D-VECTOR 5 5 -7> 6 #<3D-VECTOR -267 204 -3>

Using vector type

(defun cross (a b)
  (when (and (equal (length a) 3) (equal (length b) 3))
      (vector
       (- (* (elt a 1) (elt b 2)) (* (elt a 2) (elt b 1)))
       (- (* (elt a 2) (elt b 0)) (* (elt a 0) (elt b 2)))
       (- (* (elt a 0) (elt b 1)) (* (elt a 1) (elt b 0))))))

(defun dot (a b)
  (when (equal (length a) (length b))
      (loop for ai across a for bi across b sum (* ai bi))))

(defun scalar-triple (a b c)
  (dot a (cross b c)))

(defun vector-triple (a b c)
  (cross a (cross b c)))

(defun task (a b c)
  (values (dot a b)
          (cross a b)
          (scalar-triple a b c)
          (vector-triple a b c)))

Output: CL-USER> (task (vector 3 4 5) (vector 4 3 5) (vector -5 -12 -13)) 49 #(5 5 -7) 6 #(-267 204 -3)

D

import std.stdio, std.conv, std.numeric;

struct V3 {
    union {
        immutable struct { double x, y, z; }
        immutable double[3] v;
    }

    double dot(in V3 rhs) const pure nothrow /*@safe*/ @nogc {
        return dotProduct(v, rhs.v);
    }

    V3 cross(in V3 rhs) const pure nothrow @safe @nogc {
        return V3(y * rhs.z - z * rhs.y,
                  z * rhs.x - x * rhs.z,
                  x * rhs.y - y * rhs.x);
    }

    string toString() const { return v.text; }
}

double scalarTriple(in V3 a, in V3 b, in V3 c) /*@safe*/ pure nothrow {
    return a.dot(b.cross(c));
    // function vector_products.V3.cross (const(V3) rhs) immutable
    // is not callable using argument types (const(V3)) const
}

V3 vectorTriple(in V3 a, in V3 b, in V3 c) @safe pure nothrow @nogc {
    return a.cross(b.cross(c));
}

void main() {
    immutable V3 a = {3, 4, 5},
                 b = {4, 3, 5},
                 c = {-5, -12, -13};

    writeln("a = ", a);
    writeln("b = ", b);
    writeln("c = ", c);
    writeln("a . b = ", a.dot(b));
    writeln("a x b = ", a.cross(b));
    writeln("a . (b x c) = ", scalarTriple(a, b, c));
    writeln("a x (b x c) = ", vectorTriple(a, b, c));
}

{{out}}

a = [3, 4, 5]
b = [4, 3, 5]
c = [-5, -12, -13]
a . b = 49
a x b = [5, 5, -7]
a . (b x c) = 6
a x (b x c) = [-267, 204, -3]

EchoLisp

The '''math''' library includes the '''dot-product''' and '''cross-product''' functions. They work on complex or real vectors.

(lib 'math)

(define (scalar-triple-product a b c)
  (dot-product a (cross-product b c)))

(define (vector-triple-product a b c)
  (cross-product a (cross-product b c)))

(define a #(3 4 5))
(define b #(4 3 5))
(define c #(-5 -12 -13))

(cross-product a b)
    → #( 5 5 -7)
(dot-product a b)
    → 49
(scalar-triple-product a b c)
    → 6
(vector-triple-product a b c)
    → #( -267 204 -3)

Elixir

defmodule Vector do
  def dot_product({a1,a2,a3}, {b1,b2,b3}), do: a1*b1 + a2*b2 + a3*b3

  def cross_product({a1,a2,a3}, {b1,b2,b3}), do: {a2*b3 - a3*b2, a3*b1 - a1*b3, a1*b2 - a2*b1}

  def scalar_triple_product(a, b, c), do: dot_product(a, cross_product(b, c))

  def vector_triple_product(a, b, c), do: cross_product(a, cross_product(b, c))
end

a = {3, 4, 5}
b = {4, 3, 5}
c = {-5, -12, -13}

IO.puts "a = #{inspect a}"
IO.puts "b = #{inspect b}"
IO.puts "c = #{inspect c}"
IO.puts "a . b = #{inspect Vector.dot_product(a, b)}"
IO.puts "a x b = #{inspect Vector.cross_product(a, b)}"
IO.puts "a . (b x c) = #{inspect Vector.scalar_triple_product(a, b, c)}"
IO.puts "a x (b x c) = #{inspect Vector.vector_triple_product(a, b, c)}"

{{out}}

a = {3, 4, 5}
b = {4, 3, 5}
c = {-5, -12, -13}
a . b = 49
a x b = {5, 5, -7}
a . (b x c) = 6
a x (b x c) = {-267, 204, -3}

Erlang

-module(vector).
-export([main/0]).
vector_product(X,Y)->
[X1,X2,X3]=X,
[Y1,Y2,Y3]=Y,
Ans=[X2*Y3-X3*Y2,X3*Y1-X1*Y3,X1*Y2-X2*Y1],
Ans.
dot_product(X,Y)->
[X1,X2,X3]=X,
[Y1,Y2,Y3]=Y,
Ans=X1*Y1+X2*Y2+X3*Y3,
io:fwrite("~p~n",[Ans]).
main()->
{ok, A} = io:fread("Enter vector A : ", "~d ~d ~d"),
{ok, B} = io:fread("Enter vector B : ", "~d ~d ~d"),
{ok, C} = io:fread("Enter vector C : ", "~d ~d ~d"),
dot_product(A,B),
Ans=vector_product(A,B),
io:fwrite("~p,~p,~p~n",Ans),
dot_product(C,vector_product(A,B)),
io:fwrite("~p,~p,~p~n",vector_product(C,vector_product(A,B))).

ERRE

PROGRAM VECTORPRODUCT

!$DOUBLE

TYPE TVECTOR=(X,Y,Z)

DIM A:TVECTOR,B:TVECTOR,C:TVECTOR

DIM AA:TVECTOR,BB:TVECTOR,CC:TVECTOR
DIM DD:TVECTOR,EE:TVECTOR,FF:TVECTOR

PROCEDURE DOTPRODUCT(DD.,EE.->DOTP)
    DOTP=DD.X*EE.X+DD.Y*EE.Y+DD.Z*EE.Z
END PROCEDURE

PROCEDURE CROSSPRODUCT(DD.,EE.->FF.)
  FF.X=DD.Y*EE.Z-DD.Z*EE.Y
  FF.Y=DD.Z*EE.X-DD.X*EE.Z
  FF.Z=DD.X*EE.Y-DD.Y*EE.X
END PROCEDURE

PROCEDURE SCALARTRIPLEPRODUCT(AA.,BB.,CC.->SCALARTP)
  CROSSPRODUCT(BB.,CC.->FF.)
  DOTPRODUCT(AA.,FF.->SCALARTP)
END PROCEDURE

PROCEDURE VECTORTRIPLEPRODUCT(AA.,BB.,CC.->FF.)
  CROSSPRODUCT(BB.,CC.->FF.)
  CROSSPRODUCT(AA.,FF.->FF.)
END PROCEDURE

PROCEDURE PRINTVECTOR(AA.)
  PRINT("(";AA.X;",";AA.Y;",";AA.Z;")")
END PROCEDURE

BEGIN
  A.X=3  A.Y=4    A.Z=5
  B.X=4  B.Y=3    B.Z=5
  C.X=-5 C.Y=-12  C.Z=-13

  PRINT("A: ";) PRINTVECTOR(A.)
  PRINT("B: ";) PRINTVECTOR(B.)
  PRINT("C: ";) PRINTVECTOR(C.)

  PRINT
  DOTPRODUCT(A.,B.->DOTP)
  PRINT("A.B    =";DOTP)

  CROSSPRODUCT(A.,B.->FF.)
  PRINT("AxB    =";) PRINTVECTOR(FF.)

  SCALARTRIPLEPRODUCT(A.,B.,C.->SCALARTP)
  PRINT("A.(BxC)=";SCALARTP)

  VECTORTRIPLEPRODUCT(A.,B.,C.->FF.)
  PRINT("Ax(BxC)=";) PRINTVECTOR(FF.)
END PROGRAM

Euphoria

constant X = 1, Y = 2, Z = 3

function dot_product(sequence a, sequence b)
    return a[X]*b[X] + a[Y]*b[Y] + a[Z]*b[Z]
end function

function cross_product(sequence a, sequence b)
    return { a[Y]*b[Z] - a[Z]*b[Y],
             a[Z]*b[X] - a[X]*b[Z],
             a[X]*b[Y] - a[Y]*b[X] }
end function

function scalar_triple(sequence a, sequence b, sequence c)
    return dot_product( a, cross_product( b, c ) )
end function

function vector_triple( sequence a, sequence b, sequence c)
    return cross_product( a, cross_product( b, c ) )
end function

constant a = { 3, 4, 5 }, b = { 4, 3, 5 }, c = { -5, -12, -13 }

puts(1,"a = ")
? a
puts(1,"b = ")
? b
puts(1,"c = ")
? c
puts(1,"a dot b = ")
? dot_product( a, b )
puts(1,"a x b = ")
? cross_product( a, b )
puts(1,"a dot (b x c) = ")
? scalar_triple( a, b, c )
puts(1,"a x (b x c) = ")
? vector_triple( a, b, c )

Output:

a = {3,4,5}
b = {4,3,5}
c = {-5,-12,-13}
a dot b = 49
a x b = {5,5,-7}
a dot (b x c) = 6
a x (b x c) = {-267,204,-3}

=={{header|F#|F sharp}}==

let dot (ax, ay, az) (bx, by, bz) =
    ax * bx + ay * by + az * bz

let cross (ax, ay, az) (bx, by, bz) =
    (ay*bz - az*by, az*bx - ax*bz, ax*by - ay*bx)

let scalTrip a b c =
    dot a (cross b c)

let vecTrip a b c =
    cross a (cross b c)

[<EntryPoint>]
let main _ =
    let a = (3.0, 4.0, 5.0)
    let b = (4.0, 3.0, 5.0)
    let c = (-5.0, -12.0, -13.0)
    printfn "%A" (dot a b)
    printfn "%A" (cross a b)
    printfn "%A" (scalTrip a b c)
    printfn "%A" (vecTrip a b c)
    0 // return an integer exit code

{{out}}

49.0
(5.0, 5.0, -7.0)
6.0
(-267.0, 204.0, -3.0)

Factor

Factor has a fantastic math.vectors vocabulary, but in the spirit of the task, it is not used.

USING: arrays io locals math prettyprint sequences ;
IN: rosetta-code.vector-products

: dot-product ( a b -- dp ) [ * ] 2map sum ;

:: cross-product ( a b -- cp )
    a first :> a1 a second :> a2 a third :> a3
    b first :> b1 b second :> b2 b third :> b3
    a2 b3 * a3 b2 * - ! X
    a3 b1 * a1 b3 * - ! Y
    a1 b2 * a2 b1 * - ! Z
    3array ;

: scalar-triple-product ( a b c -- stp )
    cross-product dot-product ;

: vector-triple-product ( a b c -- vtp )
    cross-product cross-product ;

[let
    { 3 4 5 }      :> a
    { 4 3 5 }      :> b
    { -5 -12 -13 } :> c
    "a: " write a .
    "b: " write b .
    "c: " write c . nl
    "a . b: " write a b dot-product .
    "a x b: " write a b cross-product .
    "a . (b x c): " write a b c scalar-triple-product .
    "a x (b x c): " write a b c vector-triple-product .
]

{{out}}

a: { 3 4 5 }
b: { 4 3 5 }
c: { -5 -12 -13 }

a . b: 49
a x b: { 5 5 -7 }
a . (b x c): 6
a x (b x c): { -267 204 -3 }

Fantom

class Main
{
  Int dot_product (Int[] a, Int[] b)
  {
    a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
  }

  Int[] cross_product (Int[] a, Int[] b)
  {
    [a[1]*b[2] - a[2]*b[1], a[2]*b[0] - a[0]*b[2], a[0]*b[1]-a[1]*b[0]]
  }

  Int scalar_triple_product (Int[] a, Int[] b, Int[] c)
  {
    dot_product (a, cross_product (b, c))
  }

  Int[] vector_triple_product (Int[] a, Int[] b, Int[] c)
  {
    cross_product (a, cross_product (b, c))
  }

  Void main ()
  {
    a := [3, 4, 5]
    b := [4, 3, 5]
    c := [-5, -12, -13]

    echo ("a . b = " + dot_product (a, b))
    echo ("a x b = [" + cross_product(a, b).join (", ") + "]")
    echo ("a . (b x c) = " + scalar_triple_product (a, b, c))
    echo ("a x (b x c) = [" + vector_triple_product(a, b, c).join (", ") + "]")
  }
}

Output:

a . b = 49
a x b = [5, 5, -7]
a . (b x c) = 6
a x (b x c) = [-267, 204, -3]

Forth

{{works with|Forth|1994 ANSI with a separate floating point stack.}}

: 3f!    ( &v - ) ( f: x y z - ) dup float+ dup float+ f! f! f! ;

: Vector \ Compiletime: ( f: x y z - ) ( <name> - )
   create here [ 3 floats ] literal allot 3f! ; \ Runtime: ( - &v )

: >fx@    ( &v - ) ( f: - n ) postpone f@ ; immediate
: >fy@    ( &v - ) ( f: - n ) float+ f@ ;
: >fz@    ( &v - ) ( f: - n ) float+ float+ f@ ;
: .Vector ( &v - ) dup >fz@ dup >fy@ >fx@ f. f. f. ;

: Dot*    ( &v1 &v2 - ) ( f - DotPrd )
   2dup >fx@  >fx@ f*
   2dup >fy@  >fy@ f* f+
        >fz@  >fz@ f* f+ ;

: Cross*  ( &v1 &v2 &vResult - )
   >r 2dup >fz@  >fy@ f*
      2dup >fy@  >fz@ f* f-
      2dup >fx@  >fz@ f*
      2dup >fz@  >fx@ f* f-
      2dup >fy@  >fx@ f*
           >fx@  >fy@ f* f-
   r> 3f! ;

: ScalarTriple* ( &v1 &v2 &v3 - ) ( f: - ScalarTriple* )
   >r pad Cross* pad r> Dot* ;

: VectorTriple* ( &v1 &v2 &v3 &vDest - )
   >r swap r@ Cross* r> tuck Cross* ;

 3e   4e   5e Vector A
 4e   3e   5e Vector B
-5e -12e -13e Vector C

cr
cr .( a . b = ) A B Dot* f.
cr .( a x b = ) A B pad Cross* pad .Vector
cr .( a . [b x c] = ) A B C ScalarTriple* f.
cr .( a x [b x c] = ) A B C pad VectorTriple* pad .Vector

{{out}}

a . b = 49.0000
a x b = 5.00000 5.00000 -7.00000
a . [b x c] = 6.00000
a x [b x c] = -267.000 204.000 -3.00000

{{libheader|Forth Scientific Library}}

S" fsl-util.fs" REQUIRED
: 3f! 3 SWAP }fput ;
: vector
  CREATE
    HERE 3 DUP FLOAT DUP , * ALLOT SWAP CELL+ }fput
  DOES>
    CELL+ ;
: >fx@ 0 } F@ ;
: >fy@ 1 } F@ ;
: >fz@ 2 } F@ ;
: .Vector 3 SWAP }fprint ;
 0e   0e   0e vector pad  \ NB: your system will be non-standard after this line
\ From here on is identical to the above example

Fortran

{{works with|Fortran|95 and later}} Specialized for 3-dimensional vectors.

program VectorProducts

  real, dimension(3)  :: a, b, c

  a = (/ 3, 4, 5 /)
  b = (/ 4, 3, 5 /)
  c = (/ -5, -12, -13 /)

  print *, dot_product(a, b)
  print *, cross_product(a, b)
  print *, s3_product(a, b, c)
  print *, v3_product(a, b, c)

contains

  function cross_product(a, b)
    real, dimension(3) :: cross_product
    real, dimension(3), intent(in) :: a, b

    cross_product(1) = a(2)*b(3) - a(3)*b(2)
    cross_product(2) = a(3)*b(1) - a(1)*b(3)
    cross_product(3) = a(1)*b(2) - b(1)*a(2)
  end function cross_product

  function s3_product(a, b, c)
    real :: s3_product
    real, dimension(3), intent(in) :: a, b, c

    s3_product = dot_product(a, cross_product(b, c))
  end function s3_product

  function v3_product(a, b, c)
    real, dimension(3) :: v3_product
    real, dimension(3), intent(in) :: a, b, c

    v3_product = cross_product(a, cross_product(b, c))
  end function v3_product

end program VectorProducts

Output

     49.0000
     5.00000         5.00000        -7.00000
     6.00000
    -267.000         204.000        -3.00000

FreeBASIC

  'Construct only required operators for this.
Type V3
    As double x,y,z
    declare operator cast() as string
End Type
#define dot *
#define cross ^
#define Show(t1,t) ? #t1;tab(22);t

operator V3.cast() as string
return "("+str(x)+","+str(y)+","+str(z)+")"
end operator

Operator dot(v1 As v3,v2 As v3) As double
Return v1.x*v2.x+v1.y*v2.y+v1.z*v2.z
End Operator

Operator cross(v1 As v3,v2 As v3) As v3
Return type<v3>(v1.y*v2.z-v2.y*v1.z,-(v1.x*v2.z-v2.x*v1.z),v1.x*v2.y-v2.x*v1.y)
End Operator

dim as V3 a = (3, 4, 5), b = (4, 3, 5), c = (-5, -12, -13)

Show(a,a)
Show(b,b)
Show(c,c)
?
Show(a . b,a dot b)
Show(a X b,a cross b)
Show(a . b X c,a dot b cross c)
Show(a X (b X c),a cross (b cross c))
sleep

{{out}}

a                    (3,4,5)
b                    (4,3,5)
c                    (-5,-12,-13)

a . b                 49
a X b                (5,5,-7)
a . b X c             6
a X (b X c)          (-267,204,-3)

FunL

A = (3, 4, 5)
B = (4, 3, 5)
C = (-5, -12, -13)

def dot( u, v ) = sum( u(i)v(i) | i <- 0:u.>length() )
def cross( u, v ) = (u(1)v(2) - u(2)v(1), u(2)v(0) - u(0)v(2), u(0)v(1) - u(1)v(0) )
def scalarTriple( u, v, w ) = dot( u, cross(v, w) )
def vectorTriple( u, v, w ) = cross( u, cross(v, w) )

println( "A\u00b7B = ${dot(A, B)}" )
println( "A\u00d7B = ${cross(A, B)}" )
println( "A\u00b7(B\u00d7C) = ${scalarTriple(A, B, C)}" )
println( "A\u00d7(B\u00d7C) = ${vectorTriple(A, B, C)}" )

{{out}}

A·B = 49
A×B = (5, 5, -7)
A·(B×C) = 6
A×(B×C) = (-267, 204, -3)

GAP

DotProduct := function(u, v)
	return u*v;
end;

CrossProduct := function(u, v)
	return [
		u[2]*v[3] - u[3]*v[2],
		u[3]*v[1] - u[1]*v[3],
		u[1]*v[2] - u[2]*v[1] ];
end;

ScalarTripleProduct := function(u, v, w)
	return DotProduct(u, CrossProduct(v, w));
end;

VectorTripleProduct := function(u, v, w)
	return CrossProduct(u, CrossProduct(v, w));
end;

a := [3, 4, 5];
b := [4, 3, 5];
c := [-5, -12, -13];

DotProduct(a, b);
# 49

CrossProduct(a, b);
# [ 5, 5, -7 ]

ScalarTripleProduct(a, b, c);
# 6

# Another way to get it
Determinant([a, b, c]);
# 6

VectorTripleProduct(a, b, c);
# [ -267, 204, -3 ]

GLSL

{{trans|C}}

vec3 a = vec3(3, 4, 5),b = vec3(4, 3, 5),c = vec3(-5, -12, -13);

float dotProduct(vec3 a, vec3 b)
{
	return a.x*b.x+a.y*b.y+a.z*b.z;
}

vec3 crossProduct(vec3 a,vec3 b)
{
	vec3 c = vec3(a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y- a.y*b.x);

	return c;
}

float scalarTripleProduct(vec3 a,vec3 b,vec3 c)
{
	return dotProduct(a,crossProduct(b,c));
}

vec3 vectorTripleProduct(vec3 a,vec3 b,vec3 c)
{
	return crossProduct(a,crossProduct(b,c));
}

Go

package main

import "fmt"

type vector struct {
    x, y, z float64
}

var (
    a = vector{3, 4, 5}
    b = vector{4, 3, 5}
    c = vector{-5, -12, -13}
)

func dot(a, b vector) float64 {
    return a.x*b.x + a.y*b.y + a.z*b.z
}

func cross(a, b vector) vector {
    return vector{a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x}
}

func s3(a, b, c vector) float64 {
    return dot(a, cross(b, c))
}

func v3(a, b, c vector) vector {
    return cross(a, cross(b, c))
}

func main() {
    fmt.Println(dot(a, b))
    fmt.Println(cross(a, b))
    fmt.Println(s3(a, b, c))
    fmt.Println(v3(a, b, c))
}

Output:

49
{5 5 -7}
6
{-267 204 -3}

Groovy

Dot Product Solution:

def pairwiseOperation = { x, y, Closure binaryOp ->
    assert x && y && x.size() == y.size()
    [x, y].transpose().collect(binaryOp)
}

def pwMult =  pairwiseOperation.rcurry { it[0] * it[1] }

def dotProduct = { x, y ->
    assert x && y && x.size() == y.size()
    pwMult(x, y).sum()
}

Cross Product Solution, using scalar operations:

def crossProductS = { x, y ->
    assert x && y && x.size() == 3 && y.size() == 3
    [x[1]*y[2] - x[2]*y[1], x[2]*y[0] - x[0]*y[2] , x[0]*y[1] - x[1]*y[0]]
}

Cross Product Solution, using "vector" operations:

def rotR = {
    assert it && it.size() > 2
    [it[-1]] + it[0..-2]
}

def rotL = {
    assert it && it.size() > 2
    it[1..-1] + [it[0]]
}

def pwSubtr = pairwiseOperation.rcurry { it[0] - it[1] }

def crossProductV = { x, y ->
    assert x && y && x.size() == 3 && y.size() == 3
    pwSubtr(pwMult(rotL(x), rotR(y)), pwMult(rotL(y), rotR(x)))
}

Test program (including triple products):

def test = { crossProduct ->

    def scalarTripleProduct = { x, y, z ->
        dotProduct(x, crossProduct(y, z))
    }

    def vectorTripleProduct = { x, y, z ->
        crossProduct(x, crossProduct(y, z))
    }

    def a = [3, 4, 5]
    def b = [4, 3, 5]
    def c = [-5, -12, -13]

    println("      a . b = " + dotProduct(a,b))
    println("      a x b = " + crossProduct(a,b))
    println("a . (b x c) = " + scalarTripleProduct(a,b,c))
    println("a x (b x c) = " + vectorTripleProduct(a,b,c))
    println()
}

test(crossProductS)
test(crossProductV)

Output:

      a . b = 49
      a x b = [5, 5, -7]
a . (b x c) = 6
a x (b x c) = [-267, 204, -3]

      a . b = 49
      a x b = [5, 5, -7]
a . (b x c) = 6
a x (b x c) = [-267, 204, -3]

Haskell

import Data.Monoid ((<>))

type Vector a = [a]

type Scalar a = a

a, b, c, d :: Vector Int
a = [3, 4, 5]

b = [4, 3, 5]

c = [-5, -12, -13]

d = [3, 4, 5, 6]

dot
  :: (Num t)
  => Vector t -> Vector t -> Scalar t
dot u v
  | length u == length v = sum $ zipWith (*) u v
  | otherwise = error "Dotted Vectors must be of equal dimension."

cross
  :: (Num t)
  => Vector t -> Vector t -> Vector t
cross u v
  | length u == 3 && length v == 3 =
    [ u !! 1 * v !! 2 - u !! 2 * v !! 1
    , u !! 2 * head v - head u * v !! 2
    , head u * v !! 1 - u !! 1 * head v
    ]
  | otherwise = error "Crossed Vectors must both be three dimensional."

scalarTriple
  :: (Num t)
  => Vector t -> Vector t -> Vector t -> Scalar t
scalarTriple q r s = dot q $ cross r s

vectorTriple
  :: (Num t)
  => Vector t -> Vector t -> Vector t -> Vector t
vectorTriple q r s = cross q $ cross r s

main :: IO ()
main =
  mapM_
    putStrLn
    [ "a . b     = " <> show (dot a b)
    , "a x b     = " <> show (cross a b)
    , "a . b x c = " <> show (scalarTriple a b c)
    , "a x b x c = " <> show (vectorTriple a b c)
    , "a . d     = " <> show (dot a d)
    ]

Output:

a . b     = 49
a x b     = [5,5,-7]
a . b x c = 6
a x b x c = [-267,204,-3]
** Exception: Dotted Vectors must be of equal dimension.
a . d     =

Or using '''Either''' and '''(>>=)''', rather than '''error''', to pass on intelligible messages:

dotProduct
  :: Num a
  => [a] -> [a] -> Either String a
dotProduct xs ys
  | length xs /= length ys =
    Left "Dot product not defined - vectors differ in dimension."
  | otherwise = Right (sum $ zipWith (*) xs ys)

crossProduct
  :: Num a
  => [a] -> [a] -> Either String [a]
crossProduct xs ys
  | 3 /= length xs || 3 /= length ys =
    Left "crossProduct is defined only for 3d vectors."
  | otherwise = Right [x2 * y3 - x3 * y2, x3 * y1 - x1 * y3, x1 * y2 - x2 * y1]
  where
    [x1, x2, x3] = xs
    [y1, y2, y3] = ys

scalarTriple
  :: Num a
  => [a] -> [a] -> [a] -> Either String a
scalarTriple q r s = crossProduct r s >>= dotProduct q

vectorTriple
  :: Num a
  => [a] -> [a] -> [a] -> Either String [a]
vectorTriple q r s = crossProduct r s >>= crossProduct q

-- TEST ---------------------------------------------------
a = [3, 4, 5]

b = [4, 3, 5]

c = [-5, -12, -13]

d = [3, 4, 5, 6]

main :: IO ()
main =
  mapM_ putStrLn $
  zipWith
    (++)
    ["a . b", "a x b", "a . b x c", "a x b x c", "a . d", "a . (b x d)"]
    [ sh $ dotProduct a b
    , sh $ crossProduct a b
    , sh $ scalarTriple a b c
    , sh $ vectorTriple a b c
    , sh $ dotProduct a d
    , sh $ scalarTriple a b d
    ]

sh
  :: Show a
  => Either String a -> String
sh = either (" => " ++) ((" = " ++) . show)

{{Out}}

a . b = 49
a x b = [5,5,-7]
a . b x c = 6
a x b x c = [-267,204,-3]
a . d => Dot product not defined - vectors differ in dimension.
a . (b x d) => crossProduct is defined only for 3d vectors.

=={{header|Icon}} and {{header|Unicon}}==

# record type to store a 3D vector
record Vector3D(x, y, z)

# procedure to display vector as a string
procedure toString (vector)
  return "(" || vector.x || ", " || vector.y || ", " || vector.z || ")"
end

procedure dotProduct (a, b)
  return a.x * b.x + a.y * b.y + a.z * b.z
end

procedure crossProduct (a, b)
  x := a.y * b.z - a.z * b.y
  y := a.z * b.x - a.x * b.z
  z := a.x * b.y - a.y * b.x
  return Vector3D(x, y, z)
end

procedure scalarTriple (a, b, c)
  return dotProduct (a, crossProduct (b, c))
end

procedure vectorTriple (a, b, c)
  return crossProduct (a, crossProduct (b, c))
end

# main procedure, to run given test
procedure main ()
  a := Vector3D(3, 4, 5)
  b := Vector3D(4, 3, 5)
  c := Vector3D(-5, -12, -13)

  writes ("A.B : " || toString(a) || "." || toString(b) || " = ")
  write (dotProduct (a, b))
  writes ("AxB : " || toString(a) || "x" || toString(b) || " = ")
  write (toString(crossProduct (a, b)))
  writes ("A.(BxC) : " || toString(a) || ".(" || toString(b) || "x" || toString(c) || ") = ")
  write (scalarTriple (a, b, c))
  writes ("Ax(BxC) : " || toString(a) || "x(" || toString(b) || "x" || toString(c) || ") = ")
  write (toString(vectorTriple (a, b, c)))
end

Output:

A.B : (3, 4, 5).(4, 3, 5) = 49
AxB : (3, 4, 5)x(4, 3, 5) = (5, 5, -7)
A.(BxC) : (3, 4, 5).((4, 3, 5)x(-5, -12, -13)) = 6
Ax(BxC) : (3, 4, 5)x((4, 3, 5)x(-5, -12, -13)) = (-267, 204, -3)

J

Perhaps the most straightforward definition for cross product in J uses rotate multiply and subtract:

cross=: (1&|.@[ * 2&|.@]) - 2&|.@[ * 1&|.@]

However, there are other valid approaches. For example, a "generalized approach" based on [[j:Essays/Complete Tensor]]:

CT=: C.!.2 @ (#:i.) @ $~
ip=: +/ .*    NB. inner product
cross=: ] ip CT@#@[ ip [

Note that there are a variety of other generalizations have cross products as a part of what they do.

An alternative definition for cross (based on finding the determinant of a 3 by 3 matrix where one row is unit vectors) could be:

 [: -&.>/ .(*&.>) (<"1=i.3) , ,:&:(<"0)

With an implementation of cross product and inner product, the rest of the task becomes trivial:

a=:  3 4 5
b=:  4 3 5
c=: -5 12 13

A=: 0 {:: ]    NB. contents of the first box on the right
B=: 1 {:: ]    NB. contents of the second box on the right
C=: 2 {:: ]    NB. contents of the third box on the right

dotP=: A ip B
crossP=: A cross B
scTriP=: A ip B cross C
veTriP=: A cross B cross C

Required example:

   dotP a;b
49
   crossP a;b
5 5 _7
   scTriP a;b;c
6
   veTriP a;b;c
_267 204 _3

Java

{{works with|Java|1.5+}} All operations which return vectors give vectors containing Doubles.

public class VectorProds{
    public static class Vector3D<T extends Number>{
        private T a, b, c;

        public Vector3D(T a, T b, T c){
            this.a = a;
            this.b = b;
            this.c = c;
        }

        public double dot(Vector3D<?> vec){
            return (a.doubleValue() * vec.a.doubleValue() +
                    b.doubleValue() * vec.b.doubleValue() +
                    c.doubleValue() * vec.c.doubleValue());
        }

        public Vector3D<Double> cross(Vector3D<?> vec){
            Double newA = b.doubleValue()*vec.c.doubleValue() - c.doubleValue()*vec.b.doubleValue();
            Double newB = c.doubleValue()*vec.a.doubleValue() - a.doubleValue()*vec.c.doubleValue();
            Double newC = a.doubleValue()*vec.b.doubleValue() - b.doubleValue()*vec.a.doubleValue();
            return new Vector3D<Double>(newA, newB, newC);
        }

        public double scalTrip(Vector3D<?> vecB, Vector3D<?> vecC){
            return this.dot(vecB.cross(vecC));
        }

        public Vector3D<Double> vecTrip(Vector3D<?> vecB, Vector3D<?> vecC){
            return this.cross(vecB.cross(vecC));
        }

        @Override
        public String toString(){
            return "<" + a.toString() + ", " + b.toString() + ", " + c.toString() + ">";
        }
    }

    public static void main(String[] args){
        Vector3D<Integer> a = new Vector3D<Integer>(3, 4, 5);
        Vector3D<Integer> b = new Vector3D<Integer>(4, 3, 5);
        Vector3D<Integer> c = new Vector3D<Integer>(-5, -12, -13);

        System.out.println(a.dot(b));
        System.out.println(a.cross(b));
        System.out.println(a.scalTrip(b, c));
        System.out.println(a.vecTrip(b, c));
    }
}

Output:

49.0
<5.0, 5.0, -7.0>
6.0
<-267.0, 204.0, -3.0>

{{works with|Java|1.8+}} This solution uses Java SE new Stream API

import java.util.Arrays;
import java.util.stream.IntStream;

public class VectorsOp {
	// Vector dot product using Java SE 8 stream abilities
	// the method first create an array of size values,
	// and map the product of each vectors components in a new array (method map())
	// and transform the array to a scalr by summing all elements (method reduce)
	// the method parallel  is there for optimization
	private static int dotProduct(int[] v1, int[] v2,int length) {

	int result = IntStream.range(0, length)
	                           .parallel()
	                            .map( id -> v1[id] * v2[id])
	                            .reduce(0, Integer::sum);

	    return result;
	}

	// Vector Cross product using Java SE 8 stream abilities
	// here we map in a new array where each element is equal to the cross product
	// With Stream is is easier to handle N dimensions vectors
	private static int[] crossProduct(int[] v1, int[] v2,int length) {

		int  result[] = new int[length] ;
		//result[0] = v1[1] * v2[2] - v1[2]*v2[1] ;
		//result[1] = v1[2] * v2[0] - v1[0]*v2[2] ;
		// result[2] = v1[0] * v2[1] - v1[1]*v2[0] ;

		result = IntStream.range(0, length)
			.parallel()
	 		.map( i ->   v1[(i+1)%length] * v2[(i+2)%length] -  v1[(i+2)%length]*v2[(i+1)%length])
	 		.toArray();

		 return result;
	}

	public static void main (String[] args)
	{
	   	int[] vect1 = {3, 4, 5};
	   	int[] vect2 = {4, 3, 5};
	    int[] vect3 = {-5, -12, -13};

	    System.out.println("dot product =:" + dotProduct(vect1,vect2,3));

	    int[] prodvect = new int[3];
	    prodvect = crossProduct(vect1,vect2,3);
	    System.out.println("cross product =:[" + prodvect[0] + ","
	    	                                   + prodvect[1] + ","
	    	                                   + prodvect[2] + "]");

	    prodvect = crossProduct(vect2,vect3,3);
	    System.out.println("scalar product =:" + dotProduct(vect1,prodvect,3));

	    prodvect = crossProduct(vect1,prodvect,3);

	    System.out.println("triple product =:[" + prodvect[0] + ","
	    	                                   + prodvect[1] + ","
	    	                                   + prodvect[2] + "]");

	   }
}

result is the same as above , fortunately

dot product =:49
cross product =:[5,5,-7]
scalar product =:6
triple product =:[-267,204,-3]

JavaScript

ES5

The dotProduct() function is generic and will create a dot product of any set of vectors provided they are all the same dimension. The crossProduct() function expects two 3D vectors.

function dotProduct() {
  var len = arguments[0] && arguments[0].length;
  var argsLen = arguments.length;
  var i, j = len;
  var prod, sum = 0;

  // If no arguments supplied, return undefined
  if (!len) {
    return;
  }

  // If all vectors not same length, return undefined
  i = argsLen;
  while (i--) {

    if (arguments[i].length != len) {
      return;  // return undefined
    }
  }

  // Sum terms
  while (j--) {
    i = argsLen;
    prod = 1;

    while (i--) {
      prod *= arguments[i][j];
    }
    sum += prod;
  }
  return sum;
}

function crossProduct(a, b) {

  // Check lengths
  if (a.length != 3 || b.length != 3) {
     return;
  }

  return [a[1]*b[2] - a[2]*b[1],
          a[2]*b[0] - a[0]*b[2],
          a[0]*b[1] - a[1]*b[0]];

}

function scalarTripleProduct(a, b, c) {
  return dotProduct(a, crossProduct(b, c));
}

function vectorTripleProduct(a, b, c) {
  return crossProduct(a, crossProduct(b, c));
}

// Run tests
(function () {
  var a = [3, 4, 5];
  var b = [4, 3, 5];
  var c = [-5, -12, -13];

  alert(
    'A . B: ' + dotProduct(a, b) +
    '\n' +
    'A x B: ' + crossProduct(a, b) +
    '\n' +
    'A . (B x C): ' + scalarTripleProduct(a, b, c) +
    '\n' +
    'A x (B x C): ' + vectorTripleProduct(a, b, c)
  );
}());

{{Out}}

A . B: 49
A x B: 5,5,-7
A . (B x C): 6
A x (B x C): -267,204,-3

ES6

(() => {
    'use strict';

    // dotProduct :: [a] -> [a] -> Either String a
    const dotProduct = xs =>
        // Dot product of two vectors of equal dimension.
        ys => xs.length !== ys.length ? (
            Left('Dot product not defined - vectors differ in dimension.')
        ) : Right(sum(
            zipWith(mul)(Array.from(xs))(Array.from(ys))
        ));

    // crossProduct :: Num a => (a, a, a) -> (a, a, a)
    // Either String -> (a, a, a)
    const crossProduct = xs =>
        // Cross product of two 3D vectors.
        ys => 3 !== xs.length || 3 !== ys.length ? (
            Left('crossProduct is defined only for 3d vectors.')
        ) : Right((() => {
            const [x1, x2, x3] = Array.from(xs);
            const [y1, y2, y3] = Array.from(ys);
            return [
                x2 * y3 - x3 * y2,
                x3 * y1 - x1 * y3,
                x1 * y2 - x2 * y1
            ];
        })());

    // scalarTriple :: Num a => (a, a, a) -> (a, a, a) -> (a, a a) ->
    // Either String -> a
    const scalarTriple = q =>
        // The scalar triple product.
        r => s => bindLR(crossProduct(r)(s))(
            dotProduct(q)
        );

    // vectorTriple :: Num a => (a, a, a) -> (a, a, a) -> (a, a a) ->
    // Either String -> (a, a, a)
    const vectorTriple = q =>
        // The vector triple product.
        r => s => bindLR(crossProduct(r)(s))(
            crossProduct(q)
        );

    // main :: IO ()
    const main = () => {
        // TEST -------------------------------------------
        const
            a = [3, 4, 5],
            b = [4, 3, 5],
            c = [-5, -12, -13],
            d = [3, 4, 5, 6];

        console.log(unlines(
            zipWith(k => f => k + show(
                saturated(f)([a, b, c])
            ))(['a . b', 'a x b', 'a . (b x c)', 'a x (b x c)'])(
                [dotProduct, crossProduct, scalarTriple, vectorTriple]
            )
            .concat([
                'a . d' + show(
                    dotProduct(a)(d)
                ),
                'a . (b x d)' + show(
                    scalarTriple(a)(b)(d)
                )
            ])
        ));
    };


    // GENERIC FUNCTIONS ----------------------------------

    // Left :: a -> Either a b
    const Left = x => ({
        type: 'Either',
        Left: x
    });

    // Right :: b -> Either a b
    const Right = x => ({
        type: 'Either',
        Right: x
    });

    // bindLR (>>=) :: Either a -> (a -> Either b) -> Either b
    const bindLR = m => mf =>
        undefined !== m.Left ? (
            m
        ) : mf(m.Right);

    // either :: (a -> c) -> (b -> c) -> Either a b -> c
    const either = fl => fr => e =>
        'Either' === e.type ? (
            undefined !== e.Left ? (
                fl(e.Left)
            ) : fr(e.Right)
        ) : undefined;

    // identity :: a -> a
    const identity = x => x;

    // mul (*) :: Num a => a -> a -> a
    const mul = a => b => a * b;

    // Curried function -> [Argument] -> a more saturated value
    const saturated = f =>
        // A curried function applied successively to
        // a list of arguments up to, but not beyond,
        // the point of saturation.
        args => 0 < args.length ? (
            args.slice(1).reduce(
                (a, x) => 'function' !== typeof a ? (
                    a
                ) : a(x),
                f(args[0])
            )
        ) : f;

    // show :: Either String a -> String
    const show = x =>
        either(x => ' => ' + x)(
            x => ' = ' + JSON.stringify(x)
        )(x);

    // sum :: [Num] -> Num
    const sum = xs => xs.reduce((a, x) => a + x, 0);

    // unlines :: [String] -> String
    const unlines = xs => xs.join('\n');

    // zipWith:: (a -> b -> c) -> [a] -> [b] -> [c]
    const zipWith = f => xs => ys =>
        xs.slice(
            0, Math.min(xs.length, ys.length)
        ).map((x, i) => f(x)(ys[i]));

    // MAIN ---
    return main();
})();

{{Out}}

a . b = 49
a x b = [5,5,-7]
a . (b x c) = 6
a x (b x c) = [-267,204,-3]
a . d => Dot product not defined - vectors differ in dimension.
a . (b x d) => crossProduct is defined only for 3d vectors.

jq

The dot_product() function is generic and will create a dot product of any pair of vectors provided they are both the same dimension. The other functions expect 3D vectors.

def dot_product(a; b):
  reduce range(0;a|length) as $i (0; . + (a[$i] * b[$i]) );

# for 3d vectors
def cross_product(a;b):
  [ a[1]*b[2] - a[2]*b[1], a[2]*b[0] - a[0]*b[2], a[0]*b[1]-a[1]*b[0] ];

def scalar_triple_product(a;b;c):
  dot_product(a; cross_product(b; c));

def vector_triple_product(a;b;c):
  cross_product(a; cross_product(b; c));

def main:
  [3, 4, 5] as $a
  | [4, 3, 5] as $b
  | [-5, -12, -13] as $c
  | "a . b = \(dot_product($a; $b))",
    "a x b = [\( cross_product($a; $b) | map(tostring) | join (", ") )]" ,
    "a . (b x c) = \( scalar_triple_product ($a; $b; $c)) )",
    "a x (b x c) = [\( vector_triple_product($a; $b; $c)|map(tostring)|join (", ") )]" ;

Output:

"a . b = 49"
"a x b = [5, 5, -7]"
"a . (b x c) = 6 )"
"a x (b x c) = [-267, 204, -3]"

Julia

{{works with|Julia|0.6}} Julia provides dot and cross products as built-ins. It's easy enough to use these to construct the triple products.

function scalarproduct(a::AbstractVector{T}, b::AbstractVector{T}, c::AbstractVector{T}) where {T<:Number}
    return dot(a, cross(b, c))
end

function vectorproduct(a::AbstractVector{T}, b::AbstractVector{T}, c::AbstractVector{T}) where {T<:Number}
    return cross(a, cross(b, c))
end

const a = [3, 4, 5]
const b = [4, 3, 5]
const c = [-5, -12, -13]

println("Test Vectors:")
@show a b c

println("\nVector Products:")
@show dot(a, b)
@show cross(a, b)
@show scalarproduct(a, b, c)
@show vectorproduct(a, b, c)

{{out}}

Test Vectors:
a = [3, 4, 5]
b = [4, 3, 5]
c = [-5, -12, -13]

Vector Products:
dot(a, b) = 49
cross(a, b) = [5, 5, -7]
scalarproduct(a, b, c) = 6
vectorproduct(a, b, c) = [-267, 204, -3]

Kotlin

// version 1.1.2

class Vector3D(val x: Double, val y: Double, val z: Double) {
    infix fun dot(v: Vector3D) = x * v.x + y * v.y + z * v.z

    infix fun cross(v: Vector3D) =
        Vector3D(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x)

    fun scalarTriple(v: Vector3D, w: Vector3D) = this dot (v cross w)

    fun vectorTriple(v: Vector3D, w: Vector3D) = this cross (v cross w)

    override fun toString() = "($x, $y, $z)"
}

fun main(args: Array<String>) {
    val a = Vector3D(3.0, 4.0, 5.0)
    val b = Vector3D(4.0, 3.0, 5.0)
    val c = Vector3D(-5.0, -12.0, -13.0)
    println("a = $a")
    println("b = $b")
    println("c = $c")
    println()
    println("a . b     = ${a dot b}")
    println("a x b     = ${a cross b}")
    println("a . b x c = ${a.scalarTriple(b, c)}")
    println("a x b x c = ${a.vectorTriple(b, c)}")
}

{{out}}

a = (3.0, 4.0, 5.0)
b = (4.0, 3.0, 5.0)
c = (-5.0, -12.0, -13.0)

a . b     = 49.0
a x b     = (5.0, 5.0, -7.0)
a . b x c = 6.0
a x b x c = (-267.0, 204.0, -3.0)

Liberty BASIC

    print "Vector products of 3-D vectors"

    print "Dot   product of 3,4,5 and 4,3,5 is "
    print DotProduct(   "3,4,5", "4,3,5")
    print "Cross product of 3,4,5 and 4,3,5 is "
    print CrossProduct$( "3,4,5", "4,3,5")
    print "Scalar triple product of 3,4,5,    4,3,5    -5, -12, -13 is "
    print ScalarTripleProduct( "3,4,5", "4,3,5", "-5, -12, -13")
    print "Vector triple product of 3,4,5,    4,3,5    -5, -12, -13 is "
    print VectorTripleProduct$( "3,4,5", "4,3,5", "-5, -12, -13")


    end

    function DotProduct( i$, j$)
        ix =val( word$( i$, 1, ","))
        iy =val( word$( i$, 2, ","))
        iz =val( word$( i$, 3, ","))
        jx =val( word$( j$, 1, ","))
        jy =val( word$( j$, 2, ","))
        jz =val( word$( j$, 3, ","))
        DotProduct = ix *jx +iy *jy + iz *jz
    end function

    function CrossProduct$( i$, j$)
        ix =val( word$( i$, 1, ","))
        iy =val( word$( i$, 2, ","))
        iz =val( word$( i$, 3, ","))
        jx =val( word$( j$, 1, ","))
        jy =val( word$( j$, 2, ","))
        jz =val( word$( j$, 3, ","))
        cpx =iy *jz -iz *jy
        cpy =iz *jx -ix *jz
        cpz =ix *jy -iy *jx
        CrossProduct$ =str$( cpx); ","; str$( cpy); ","; str$( cpz)
    end function

    function ScalarTripleProduct( i$, j$, k$))
        ScalarTripleProduct =DotProduct( i$, CrossProduct$( j$, k$))
    end function

    function VectorTripleProduct$( i$, j$, k$))
        VectorTripleProduct$ =CrossProduct$( i$, CrossProduct$( j$, k$))
    end function
 END SUB

Lingo

Lingo has a built-in vector data type that supports calculation of both dot and cross products:

a = vector(1,2,3)
b = vector(4,5,6)

put a * b
-- 32.0000

put a.dot(b)
-- 32.0000

put a.cross(b)
-- vector( -3.0000, 6.0000, -3.0000 )

Lua

Vector = {}
function Vector.new( _x, _y, _z )
    return { x=_x, y=_y, z=_z }
end

function Vector.dot( A, B )
    return A.x*B.x + A.y*B.y + A.z*B.z
end

function Vector.cross( A, B )
    return { x = A.y*B.z - A.z*B.y,
             y = A.z*B.x - A.x*B.z,
             z = A.x*B.y - A.y*B.x }
end

function Vector.scalar_triple( A, B, C )
    return Vector.dot( A, Vector.cross( B, C ) )
end

function Vector.vector_triple( A, B, C )
    return Vector.cross( A, Vector.cross( B, C ) )
end


A = Vector.new( 3, 4, 5 )
B = Vector.new( 4, 3, 5 )
C = Vector.new( -5, -12, -13 )

print( Vector.dot( A, B ) )

r = Vector.cross(A, B )
print( r.x, r.y, r.z )

print( Vector.scalar_triple( A, B, C ) )

r = Vector.vector_triple( A, B, C )
print( r.x, r.y, r.z )

49
5	5	-7
6
-267	204	-3

M2000 Interpreter

Module checkit {
            class Vector {
                  \\ by default are double
                  a,b,c
                  Property ToString$ {
                        Value {
                            link parent a,b,c to a,b,c
                             value$=format$("({0}, {1}, {2})",a,b,c)
                        }
                  }
                  Operator "==" {
                        read n
                        push .a==n.a and .b==n.b and .c==n.c
                  }
                  Operator Unary {
                        .a-! : .b-! : .c-!
                  }
                  Operator "+"  {
                        Read v2
                        For this, v2 {
                              .a+=..a :.b+=..b:.c+=..c:
                        }
                  }
                  Function Mul(r)  {
                        vv=this
                        for vv {
                              .a*=r:.b*=r:.c*=r
                        }
                        =vv
                  }
                  Function Dot(v2)  {
                        def double sum
                        for  this, v2 {
                            sum=.a*..a+.b*..b+.c*..c
                        }
                        =sum
                  }
                  Operator "*" {
                        Read v2
                        For This, v2 {
                              Push .b*..c-.c*..b
                              Push .c*..a-.a*..c
                              .c<=.a*..b-.b*..a
                              Read .b, .a
                        }
                  }
                  class:
                  module Vector {
                        if match("NNN") then {
                              Read .a,.b,.c
                        }
                  }
            }
            A=Vector(3,4,5)
            B=Vector(4,3,5)
            C=Vector(-5,-12,-13)
            Print "A=";A.toString$
            Print "B=";B.toString$
            Print "C=";C.toString$
            Print "A dot B="; A.dot(B)
            AxB=A*B
            Print "A x B="; AxB.toString$
            Print "A dot (B x C)=";A.dot(B*C)
            AxBxC=A*(B*C)
            Print "A x (B x C)=";AxBxC.toString$
            Def ToString$(a)=a.toString$
            Print "A x (B x C)=";ToString$(A*(B*C))
}
Checkit

{{out}}

A=(3, 4, 5)
B=(4, 3, 5)
C=(-5, -12, -13)
A dot B=49
A x B=(5, 5, -7)
A dot (B x C)=6
A x (B x C)=(-267, 204, -3)
A x (B x C)=(-267, 204, -3)