Vector products: Difference between revisions

*   [[Quaternion type]]

<br><br>

 

=={{header|Ada}}==

 

vector.adb:

 

procedure Vector is

Ada.Text_IO.Put ("A x (B x C) = "); Vector_Put (A * Float_Vector'(B * C));

Ada.Text_IO.New_Line;

Output:

<pre>A: ( 3.0, 4.0, 5.0)

{{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''.}}

FORMAT field fmt = $g(-0)$;

 

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:

<pre>

 

=={{header|ALGOL W}}==

% define the Vector record type %

record Vector( integer X, Y, Z );

write( "a x ( b x c ): " ); writeonVector( vectorTripleProduct( a, b, c ) )

end

{{out}}

<pre>

a x ( b x c ): (-267, 204, -3)

</pre>

 

=={{header|AppleScript}}==

 

-- dotProduct :: Num a => [a] -> [a] -> Either String a

return lst

end tell

{{Out}}

<pre>a . b = 49

a x d = Dot product not defined for vectors of differing dimension.

a . (b x d) = Cross product is defined only for 3d vectors</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

 

for key, val in V

VectorTripleProduct(v1, v2, v3) {

return, CrossProduct(v1, CrossProduct(v2, v3))

'''Output:'''

<pre>a = (3, 4, 5)

 

=={{header|AWK}}==

BEGIN {

a[1] = 3; a[2]= 4; a[3] = 5;

function printVec(C) {

return "[ "C[1]" "C[2]" "C[3]" ]";

Output:

<pre>a = [ 3 4 5 ]

=={{header|BASIC256}}==

{{works with|BASIC256 }}

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

 

end subroutine

 

Output:

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

a() = 3, 4, 5

b() = 4, 3, 5

PROCcross(B(),C(),D())

PROCcross(A(),D(),D())

Output:

<pre>

a x (b x c) = (-267, 204, -3)

</pre>

 

=={{header|C}}==

 

typedef struct{

return 0;

Output:

<pre>

 

=={{header|C sharp|C#}}==

using System.Windows.Media.Media3D;

 

Console.WriteLine(VectorTripleProduct(a, b, c));

}

Output:

<pre>49

 

=={{header|C++}}==

 

template< class T >

std::cout << "a x b x c : " << a.triplevec( b , c ) << "\n" ;

return 0 ;

Output:<PRE>a . b : 49

a x b : ( 5 , 5 , -7 )

 

=={{header|Ceylon}}==

 

alias Vector => Float[3];

print("``a`` . ``b`` X ``c`` = ``scalarTriple(a, b, c)``");

print("``a`` X ``b`` X ``c`` = ``vectorTriple(a, b, c)``");

{{out}}

<pre>[3.0, 4.0, 5.0] . [4.0, 3.0, 5.0] = 49.0

 

=={{header|Clojure}}==

 

(defn dot

(dot a (cross b c))

(cross a (cross b c)))]

Output:<PRE>

49

6

#:user.Vector{:x -267, :y 204, :z -3}</PRE>

 

=={{header|Common Lisp}}==

Using the Common Lisp Object System.

 

((x :type number :initarg :x)

(y :type number :initarg :y)

(cross-product a b)

(scalar-triple-product a b c)

Output:

CL-USER> (vector-products-example)

Using vector type

 

(when (and (equal (length a) 3) (equal (length b) 3))

(vector

(scalar-triple a b c)

(vector-triple a b c)))

 

Output:

6

#(-267 204 -3)

 

=={{header|Crystal}}==

property x, y, z

puts "a cross b = #{a.cross_product(b).to_s}"

puts "a dot (b cross c) = #{a.scalar_triple_product b, c}"

{{out}}

<pre>a = (3, 4, 5)

 

=={{header|D}}==

 

struct V3 {

writeln("a . (b x c) = ", scalarTriple(a, b, c));

writeln("a x (b x c) = ", vectorTriple(a, b, c));

{{out}}

<pre>a = [3, 4, 5]

a . (b x c) = 6

a x (b x c) = [-267, 204, -3]</pre>

 

=={{header|EchoLisp}}==

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

(lib 'math)

 

(vector-triple-product a b c)

→ #( -267 204 -3)

 

=={{header|Elixir}}==

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

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)}"

 

{{out}}

 

=={{header|Erlang}}==

-module(vector).

-export([main/0]).

dot_product(C,vector_product(A,B)),

io:fwrite("~p,~p,~p~n",vector_product(C,vector_product(A,B))).

 

=={{header|ERRE}}==

PROGRAM VECTORPRODUCT

 

PRINT("Ax(BxC)=";) PRINTVECTOR(FF.)

END PROGRAM

 

=={{header|Euphoria}}==

 

function dot_product(sequence a, sequence b)

? scalar_triple( a, b, c )

puts(1,"a x (b x c) = ")

Output:

<pre>a = {3,4,5}

 

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

ax * bx + ay * by + az * bz

 

printfn "%A" (scalTrip a b c)

printfn "%A" (vecTrip a b c)

{{out}}

<pre>49.0

=={{header|Factor}}==

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

 

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

"a . (b x c): " write a b c scalar-triple-product .

"a x (b x c): " write a b c vector-triple-product .

{{out}}

<pre>

 

=={{header|Fantom}}==

{

Int dot_product (Int[] a, Int[] b)

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

}

Output:

<pre>

 

=={{header|Forth}}==

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

 

cr .( a x b = ) A B pad Cross* pad .Vector

cr .( a . [b x c] = ) A B C ScalarTriple* f.

{{out}}

<pre>

a x [b x c] = -267.000 204.000 -3.00000

</pre>

S" fsl-util.fs" REQUIRED

: 3f! 3 SWAP }fput ;

: .Vector 3 SWAP }fprint ;

0e 0e 0e vector pad \ NB: your system will be non-standard after this line

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

Specialized for 3-dimensional vectors.

 

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

end function v3_product

 

Output

<pre> 49.0000

 

=={{header|FreeBASIC}}==

Type V3

As double x,y,z

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

Show(a X (b X c),a cross (b cross c))

{{out}}

<pre>a (3,4,5)

 

=={{header|FunL}}==

B = (4, 3, 5)

C = (-5, -12, -13)

println( "A\u00d7B = ${cross(A, B)}" )

println( "A\u00b7(B\u00d7C) = ${scalarTriple(A, B, C)}" )

 

{{out}}

 

=={{header|GAP}}==

return u*v;

end;

 

VectorTripleProduct(a, b, c);

 

=={{header|GLSL}}==

{{trans|C}}

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

return crossProduct(a,crossProduct(b,c));

}

 

=={{header|Go}}==

 

import "fmt"

fmt.Println(s3(a, b, c))

fmt.Println(v3(a, b, c))

Output:

<pre>

=={{header|Groovy}}==

Dot Product Solution:

assert x && y && x.size() == y.size()

[x, y].transpose().collect(binaryOp)

assert x && y && x.size() == y.size()

pwMult(x, y).sum()

Cross Product Solution, using scalar operations:

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:

assert it && it.size() > 2

[it[-1]] + it[0..-2]

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 scalarTripleProduct = { x, y, z ->

 

test(crossProductS)

Output:

<pre> a . b = 49

 

=={{header|Haskell}}==

 

type Vector a = [a]

, "a x b x c = " <> show (vectorTriple a b c)

, "a . d = " <> show (dot a d)

Output:<pre>a . b = 49

a x b = [5,5,-7]

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

 

:: Num a

=> [a] -> [a] -> Either String a

:: Show a

=> Either String a -> String

{{Out}}

<pre>a . b = 49

 

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

record Vector3D(x, y, z)

 

writes ("Ax(BxC) : " || toString(a) || "x(" || toString(b) || "x" || toString(c) || ") = ")

write (toString(vectorTriple (a, b, c)))

Output:

<pre>

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

 

 

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

ip=: +/ .* NB. inner product

 

 

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

 

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

 

b=: 4 3 5

c=: -5 12 13

crossP=: A cross B

scTriP=: A ip B cross C

Required example:

49

crossP a;b

6

veTriP a;b;c

 

=={{header|Java}}==

{{works with|Java|1.5+}}

All operations which return vectors give vectors containing <code>Double</code>s.

public static class Vector3D<T extends Number>{

private T a, b, c;

System.out.println(a.vecTrip(b, c));

}

Output:

<pre>49.0

{{works with|Java|1.8+}}

This solution uses Java SE new Stream API

import java.util.stream.IntStream;

 

 

}

result is the same as above , fortunately

<pre>dot product =:49

The <code>dotProduct()</code> function is generic and will create a dot product of any set of vectors provided they are all the same dimension.

The <code>crossProduct()</code> function expects two 3D vectors.

var len = arguments[0] && arguments[0].length;

var argsLen = arguments.length;

'A x (B x C): ' + vectorTripleProduct(a, b, c)

);

{{Out}}

<pre>A . B: 49

 

===ES6===

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>a . b = 49

 

=={{header|jq}}==

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

 

"a x b = [\( cross_product($a; $b) | map(tostring) | join (", ") )]" ,

"a . (b x c) = \( scalar_triple_product ($a; $b; $c)) )",

Output:

"a x b = [5, 5, -7]"

"a . (b x c) = 6 )"

 

=={{header|Julia}}==

Julia provides dot and cross products with LinearAlgebra. It's easy enough to use these to construct the triple products.

 

const a = [3, 4, 5]

 

println("\nVector Products:")

 

{{out}}

a = [3, 4, 5]

b = [4, 3, 5]

 

Vector Products:

 

=={{header|Kotlin}}==

 

class Vector3D(val x: Double, val y: Double, val z: Double) {

println("a . b x c = ${a.scalarTriple(b, c)}")

println("a x b x c = ${a.vectorTriple(b, c)}")

 

{{out}}

a x b x c = (-267.0, 204.0, -3.0)

</pre>

 

=={{header|Lambdatalk}}==

{def dotProduct

{lambda {:a :b}

A.(BxC) : {dotProduct {A} {crossProduct {B} {C}}} -> 6

Ax(BxC) : {crossProduct {A} {crossProduct {B} {C}}} -> [-267,204,-3]

 

=={{header|Liberty BASIC}}==

 

print "Dot product of 3,4,5 and 4,3,5 is "

VectorTripleProduct$ =CrossProduct$( i$, CrossProduct$( j$, k$))

end function

 

=={{header|Lingo}}==

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

b = vector(4,5,6)

 

 

put a.cross(b)

 

=={{header|Lua}}==

function Vector.new( _x, _y, _z )

return { x=_x, y=_y, z=_z }

 

r = Vector.vector_triple( A, B, C )

<pre>49

5 5 -7

 

=={{header|M2000 Interpreter}}==

Module checkit {

class Vector {

}

Checkit

{{out}}

<pre >

 

=={{header|Maple}}==

A := Vector([3,4,5]):

B := Vector([4,3,5]):

6

>>>CrossProduct(A,CrossProduct(B,C));

 

b={4,3,5};

c={-5,-12,-13};

Cross[a,b]

a.Cross[b,c]

<pre>49

{5,5,-7}

=={{header|MATLAB}} / {{header|Octave}}==

Matlab / Octave use double precesion numbers per default, and pi is a builtin constant value. Arbitrary precision is only implemented in some additional toolboxes (e.g. symbolic toolbox).

dot(a,b)

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

dot(a,cross(b,c))

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

 

Code for testing:

 

=={{header|Mercury}}==

:- interface.

 

 

to_string(vector3d(X, Y, Z)) =

 

=={{header|MiniScript}}==

vectorB = [4, 3, 5]

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

print "Scalar Triple Product = " + dotProduct(vectorA, crossProduct(vectorB,vectorC))

print "Vector Triple Product = " + crossProduct(vectorA, crossProduct(vectorB,vectorC))

{{out}}

<pre>

 

=={{header|МК-61/52}}==

ИП0 ИП3 ИП6 П3 -> П0 -> П6

ИП1 ИП4 ИП7 П4 -> П1 -> П7

ИП1 ИП5 * ИП2 ИП4 * - П9

ИП2 ИП3 * ИП0 ИП5 * - ПA

 

''Instruction'': Р0 - a₁, Р1 - a₂, Р2 - a₃, Р3 - b₁, Р4 - b₂, Р5 - b₃, Р6 - c₁, Р7 - c₂, Р8 - c₃; В/О С/П.

 

=={{header|Modula-2}}==

FROM RealStr IMPORT RealToStr;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Nemerle}}==

 

module VectorProducts3d

WriteLine(VectorTriple(a, b, c));

}

Outputs

<pre>49

 

=={{header|Never}}==

prints("[" + a[0] + ", " + a[1] + ", " + a[2] + "]\n");

0

0

}

Output:

<pre>

 

=={{header|Nim}}==

 

type Vector3 = array[1..3, float]

 

proc `$`(a: Vector3): string =

 

result = [a[2]*b[3] - a[3]*b[2], a[3]*b[1] - a[1]*b[3], a[1]*b[2] - a[2]*b[1]]

 

for i in a.low..a.high:

result += a[i] * b[i]

 

 

 

let

b = [4.0, 3.0, 5.0]

c = [-5.0, -12.0, -13.0]

 

=={{header|Objeck}}==

class VectorProduct {

function : Main(args : String[]) ~ Nil {

}

}

 

Output:

 

=={{header|OCaml}}==

let b = (4.0, 3.0, 5.0)

let c = (-5.0, -12.0, -13.0)

Printf.printf "a . (b x c) = %g\n" (scalar_triple a b c);

Printf.printf "a x (b x c) = %s\n" (string_of_vector (vector_triple a b c));

 

outputs:

=={{header|Octave}}==

Octave handles naturally vectors / matrices.

b = [4, 3, 5];

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

 

% -267 204 -3

 

=={{header|ooRexx}}==

a = .vector~new(3, 4, 5);

b = .vector~new(4, 3, 5);

expose x y z

return "<"||x", "y", "z">"

Output:

<pre>

 

=={{header|PARI/GP}}==

sum(i=1,#u,u[i]*v[i])

};

cross(a,b)

striple(a,b,c)

Output:

<pre>49

 

=={{header|Pascal}}==

 

type

writeln('a . (b x c): ', scalarTripleProduct(a,b,c):15:8);

write('a x (b x c): '); printVector(vectorTripleProduct(a,b,c));

Output:

<pre>a: 3.00000000 4.00000000 5.00000000

 

=={{header|Perl}}==

use List::Util 'sum';

use List::MoreUtils 'pairwise';

print "$a x $b = ", $a ^ $b, "\n";

print "$a . ($b x $c) = ", $a & ($b ^ $c), "\n";

 

Output: <pre>a = (3 4 5) b = (4 3 5) c = (-5 -12 -13)

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

( 3 4 5 ) var vectorA

 

def crossProduct /# x y -- z #/

enddef

 

"Cross Product = " print vectorA vectorB crossProduct ?

"Scalar Triple Product = " print vectorB vectorC crossProduct vectorA swap dotProduct ?

{{out}}

<pre>Dot Product = 49

 

=={{header|PHP}}==

 

class Vector

new Program();

?>

 

Output:

A × (B × C) =(-267.00, 204.00, -3.00)

</pre>

 

=={{header|PicoLisp}}==

(sum * A B) )

 

 

(de vectorTriple (A B C)

Test:

<pre>(setq

 

=={{header|PL/I}}==

 

test_products: procedure options (main);

end vector_triple_product;

 

Results:

<pre>

</pre>

 

 

/* dot product, cross product, etc. 6 June 2011 */

end vector_triple_product;

 

The output is:

<pre>

a . (b x c) = 6

a x (b x c) = -267 204 -3

</pre>

 

=={{header|PowerShell}}==

function dot-product($a,$b) {

$a[0]*$b[0] + $a[1]*$b[1] + $a[2]*$b[2]

"a.(bxc) = $(scalar-triple-product $a $b $c)"

"ax(bxc) = $(vector-triple-product $a $b $c)"

<b>Output:</b>

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog.

dot_product([A1, A2, A3], [B1, B2, B3], Ans) :-

Ans is A1 * B1 + A2 * B2 + A3 * B3.

cross_product(B, C, Temp),

cross_product(A, Temp, Ans).

Output:

<pre>

 

=={{header|PureBasic}}==

x.f

y.f

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>a = [3.00, 4.00, 5.00], b = [4.00, 3.00, 5.00], c = [-5.00, -12.00, -13.00]

=={{header|Python}}==

The solution is in the form of an [[Executable library]].

'''Cross product of two 3D vectors'''

assert len(a) == len(b) == 3, 'For 3D vectors only'

print("a x b = %r" % (crossp(a,b),))

print("a . (b x c) = %r" % scalartriplep(a, b, c))

 

{{out}}

;Note:

The popular [http://numpy.scipy.org/ numpy] package has functions for dot and cross products.

 

=={{header|R}}==

# Vector products

# R implementation

cat("a x b =", crossp(a, b))

cat("a . (b x c) =", scalartriplep(a, b, c))

 

{{out}}

=={{header|Racket}}==

 

#lang racket

 

(printf "A . B x C = ~s\n" (scalar-triple-product A B C))

(printf "A x B x C = ~s\n" (vector-triple-product A B C))

 

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2015-11-24}}

 

sub infix:<⨯>([$a1, $a2, $a3], [$b1, $b2, $b3]) {

say "a ⨯ b = <{ @a ⨯ @b }>";

say "a ⋅ (b ⨯ c) = { scalar-triple-product(@a, @b, @c) }";

{{out}}

<pre>("a" => ["3", "4", "5"], "b" => ["4", "3", "5"], "c" => ["-5", "-12", "-13"])

 

=={{header|REXX}}==

a= 3 4 5

b= 4 3 5 /*(positive numbers don't need quotes.)*/

call tellV 'vector B =', b /* " " B " " " */

call tellV 'vector C =', c /* " " C " " " */

call tellV ' dot product [A∙B] =', dot(a, b)

call tellV 'cross product [AxB] =', cross(a, b)

call tellV 'scalar triple product [A∙(BxC)] =', dot(a, cross(b, c) )

call tellV 'vector triple product [Ax(BxC)] =', cross(a, cross(b, c) )

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

vector A = 3 4 5

 

=={{header|Ring}}==

# Project : Vector products

 

cross(a,d,e)

see "a x (b x c) = (" + e[1] + ", " +e[2] + ", " + e[3] + ")"

Output:

<pre>

a . (b x c) = 6

a x (b x c) = (-267, 204, -3)

</pre>

 

=={{header|Ruby}}==

Dot product is also known as ''inner product''. The standard library already defines Vector#inner_product and Vector# cross_product, so this program only defines the other two methods.

 

class Vector

puts "a cross b = #{a.cross_product b}"

puts "a dot (b cross c) = #{a.scalar_triple_product b, c}"

Output: <pre>a dot b = 49

a cross b = Vector[5, 5, -7]

 

=={{header|Rust}}==

struct Vector {

x: f64,

println!("a . (b x c) = {}", a.scalar_triple_product(&b, &c));

println!("a x (b x c) = {:?}", a.vector_triple_product(&b, &c));

 

Output:<pre>a . b = 49

 

=={{header|Scala}}==

def dot(v:Vector3D):Double=x*v.x + y*v.y + z*v.z;

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

println("a x (b x c) : " + (a vectorTriple(b, c)))

}

{{out}}

<pre> a . b : 49.0

{{works with|Gauche}}

Using modified dot-product function from the [[Dot product]] task.

(apply + (map * (vector->list A) (vector->list B))))

 

(display "A x B = ")(display (cross-product A B))(newline)

(display "A . B x C = ")(display (scalar-triple-product A B C))(newline)

Output:<pre>A = #(3 4 5)

B = #(4 3 5)

The program below uses Seed7s capaibility to define operator symbols.

The operators ''dot'' and ''X'' are defined with with priority 6 and assiciativity left-to-right.

include "float.s7i";

 

writeln("a .(b x c) = " <& scalarTriple(a, b, c));

writeln("a x(b x c) = " <& vectorTriple(a, b, c));

 

{{output}}

 

=={{header|Sidef}}==

method ∙(vec) {

[self{:x,:y,:z}] »*« [vec{:x,:y,:z}] «+»

say "a ⨉ b = #{a ⨉ b}"

say "a ∙ (b ⨉ c) = #{a ∙ (b ⨉ c)}"

{{out}}

<pre>a=(3, 4, 5); b=(4, 3, 5); c=(-5, -12, -13);

=={{header|Simula}}==

{{Trans|C}}

CLASS VECTOR(I,J,K); REAL I,J,K;;

OUTIMAGE;

END;

{{out}}

<pre>A = (3.000000, 4.000000, 5.000000)

 

=={{header|Stata}}==

real scalar sprod(real colvector u, real colvector v) {

return(u[1]*v[1] + u[2]*v[2] + u[3]*v[3])

3 | -3 |

+--------+

 

=={{header|Swift}}==

 

 

infix operator • : MultiplicationPrecedence

print("a × b = \(a × b)")

print("a • (b × c) = \(a • (b × c))")

 

{{out}}

 

=={{header|Tcl}}==

lassign $A a1 a2 a3

lassign $B b1 b2 b3

proc vectorTriple {A B C} {

cross $A [cross $B $C]

Demonstrating:

set b {4 3 5}

set c {-5 -12 -13}

puts "a x b = [cross $a $b]"

puts "a • b x c = [scalarTriple $a $b $c]"

Output:<pre>a • b = 49

a x b = 5 5 -7

{{Trans|BBC BASIC}}

Since uBasic/4tH has only one single array, we use its variables to hold the offsets of the vectors. A similar problem arises when local vectors are required.

b = a + 3

c = b + 3

Proc _Cross (b@, c@, e@)

Proc _Cross (a@, e@, d@)

{{Out}}

<pre>a . b = 49

 

=={{header|VBA}}==

Function dot_product(a As Variant, b As Variant) As Variant

dot_product = WorksheetFunction.SumProduct(a, b)

Debug.Print "a . (b x c) = "; scalar_triple_product(a, b, c)

Debug.Print "a x (b x c) = "; "("; Join(vector_triple_product(a, b, c), ", "); ")"

<pre> a . b = 49

a x b = (5, 5, -7)

=={{header|Visual Basic .NET}}==

Class: Vector3D

Private _x, _y, _z As Double

 

Return String.Format("({0}, {1}, {2})", _x, _y, _z)

End Function

Module: Module1

 

Sub Main()

End Sub

 

Output:

<pre>v1: (3, 4, 5)

v1 . (v2 x v3) = 6

v1 x (v2 x v3) = (-267, 204, -3)</pre>

 

=={{header|Wortel}}==

dot &[a b] @sum @mapm ^* [a b]

cross &[a b] [[

@!vectorTripleProduct [a b c]

]]

Returns:

<pre>[49 [5 5 -7] 6 [-267 204 -3]]</pre>

=={{header|Wren}}==

{{trans|Kotlin}}

construct new(x, y, z) {

if (x.type != Num || y.type != Num || z.type != Num) Fiber.abort("Arguments must be numbers.")

System.print("a x b = %(a.cross(b))")

System.print("a . b x c = %(a.scalarTriple(b, c))")

 

{{out}}

a . b x c = 6

a x b x c = [-267, 204, -3]

</pre>

 

=={{header|XPL0}}==

 

func DotProd(A, B); \Return the dot product of two 3D vectors

IntOut(0, D(1)); ChOut(0, 9\tab\);

IntOut(0, D(2)); CrLf(0);

 

Output:

 

The [(a1,a2,a3)] parameter notation just means add a preamble to the function body to do list assignment: a1,a2,a3:=arglist[0]. Since we don't need the vector as such, don't bother to name it (in the parameter list)

fcn crossp([(a1,a2,a3)],[(b1,b2,b3)]) //2

dotp(a,b).println(); //5 --> 49

crossp(a,b).println(); //6 --> (5,5,-7)

dotp(a, crossp(b,c)).println(); //7 --> 6

{{out}}

<pre>

</pre>

Or, using the GNU Scientific Library:

a:=GSL.VectorFromData( 3, 4, 5);

b:=GSL.VectorFromData( 4, 3, 5);

(a*(b.copy().crossProduct(c))).println(); // 6 scalar triple product

(a.crossProduct(b.crossProduct(c))) // (-267,204,-3) vector triple product, in place

{{out}}

<pre>