Vector products: Difference between revisions

 

=={{header|11l}}==

return dot(a, cross(b, c))

print(‘a x b = #.’.format(cross(a,b)))

print(‘a . (b x c) = #.’.format(scalartriplep(a, b, c)))

 

{{out}}

 

=={{header|Action!}}==

 

PROC CreateVector(INT vx,vy,vz Vector POINTER v)

CrossProduct(a,d,e)

Print("ax(bxc)=") PrintVector(e) PutE()

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Vector_products.png Screenshot from Atari 8-bit computer]

 

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>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

b←4 3 5

c←¯5 ¯12 ¯13

6

a cross b cross c

 

=={{header|AppleScript}}==

 

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

return lst

end tell

{{Out}}

<pre>a . b = 49

=={{header|Arturo}}==

 

dot: function [a b][

]

 

print ["a x b =", cross a b]

print ["a • (b x c) =", stp a b c]

 

{{out}}

=={{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>

=={{header|BQN}}==

The cross product function here multiplies each vector pointwise by the other rotated by one. To align this result with the third index (the one not involved), it's rotated once more at the end. The APL solution <code>1⌽(⊣×1⌽⊢)-⊢×1⌽⊣</code> uses the same idea and works in BQN without modification.

Cross ← 1⊸⌽⊸×{1⌽𝔽˜-𝔽}

Triple ← {𝕊a‿b‿c: a Dot b Cross c}

a←3‿4‿5

b←4‿3‿5

 

Results:

49

 

 

VTriple a‿b‿c

 

=={{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

 

=={{header|CLU}}==

equal, power, mul, unparse

where T has add: proctype (T,T) returns (T) signals (overflow),

stream$putl(po, "a . (b x c) = " || int$unparse(a * b ** c))

stream$putl(po, "a x (b x c) = " || vi$unparse(a ** b ** c))

{{out}}

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

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:

 

=={{header|Cowgol}}==

 

record Vector is

print("a . b x c = "); print_signed(scalarTriple(&a, &b, &c)); print_nl();

print("a x b x c = "); vectorTriple(&a, &b, &c, &scratch);

{{out}}

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

 

=={{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]

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Vector_products#Pascal Pascal].

 

=={{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]

@show a × b

@show a ⋅ (b × c)

 

{{out}}

 

=={{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}}

 

=={{header|Ksh}}==

#!/bin/ksh

 

_vect3prod A B C arr

print "The vector triple product A x (B x C) = ( ${arr[@]} )"

{{out}}<pre>

The dot product A • B = 49

 

=={{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));

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

b={4,3,5};

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

Cross[a,b]

a.Cross[b,c]

{{out}}

<pre>49

=={{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]

echo &"a . b = {a.dot(b)}"

echo &"a . (b ⨯ c) = {scalarTriple(a, b, c)}"

 

{{out}}

 

=={{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}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">function</span> <span style="color: #000000;">dot_product</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">))</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"a . (b x c) = %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">scalar_triple_product</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c</span><span style="color: #0000FF;">)})</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"a x (b x c) = %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">vector_triple_product</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c</span><span style="color: #0000FF;">)})</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

( 3 4 5 ) var vectorA

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

 

=={{header|Plain English}}==

Start up.

Make a vector from 3 and 4 and 5.

Compute a cross product of the other vector and the third vector.

Compute another cross product of the vector and the cross product.

{{out}}

<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.)*/

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

tellV: procedure; parse arg name,x y z; w=max(4,length(x),length(y),length(z)) /*max W*/

{{out|output|text=&nbsp; when using the default internal inputs:}}

<pre>

 

=={{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 x b x c = [-267, 204, -3]

</pre>

 

=={{header|XBS}}==

class Vector3 {

construct=func(self,x,y,z){

log("Cross: ",a::Cross(b)::ToString());

log("Scalar Triple: ",a::Dot(b::Cross(c)));

{{out}}

<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>