Vector products: Difference between revisions
Content deleted Content added
Added solution for Action! |
|||
(19 intermediate revisions by 14 users not shown) | |||
Line 48:
=={{header|11l}}==
<
return dot(a, cross(b, c))
Line 62:
print(‘a x b = #.’.format(cross(a,b)))
print(‘a . (b x c) = #.’.format(scalartriplep(a, b, c)))
print(‘a x (b x c) = #.’.format(vectortriplep(a, b, c)))</
{{out}}
Line 74:
=={{header|Action!}}==
<
PROC CreateVector(INT vx,vy,vz Vector POINTER v)
Line 127:
CrossProduct(a,d,e)
Print("ax(bxc)=") PrintVector(e) PutE()
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Vector_products.png Screenshot from Atari 8-bit computer]
Line 147:
vector.adb:
<
procedure Vector is
Line 224:
Ada.Text_IO.Put ("A x (B x C) = "); Vector_Put (A * Float_Vector'(B * C));
Ada.Text_IO.New_Line;
end Vector;</
Output:
<pre>A: ( 3.0, 4.0, 5.0)
Line 240:
{{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)$;
Line 292:
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>
Line 309:
=={{header|ALGOL W}}==
<
% define the Vector record type %
record Vector( integer X, Y, Z );
Line 353:
write( "a x ( b x c ): " ); writeonVector( vectorTripleProduct( a, b, c ) )
end
end.</
{{out}}
<pre>
Line 367:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
cross ← 1⌽(⊣×1⌽⊢)-⊢×1⌽⊣</
{{out}}
<
b←4 3 5
c←¯5 ¯12 ¯13
Line 380:
6
a cross b cross c
¯267 204 ¯3</
=={{header|AppleScript}}==
<
-- dotProduct :: Num a => [a] -> [a] -> Either String a
Line 638:
return lst
end tell
end zipWith</
{{Out}}
<pre>a . b = 49
Line 649:
=={{header|Arturo}}==
<
dot: function [a b][
sum map
]
Line 680:
print ["a x b =", cross a b]
print ["a • (b x c) =", stp a b c]
print ["a x (b x c) =", vtp a b c]</
{{out}}
Line 691:
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
<
for key, val in V
Line 720:
VectorTripleProduct(v1, v2, v3) {
return, CrossProduct(v1, CrossProduct(v2, v3))
}</
'''Output:'''
<pre>a = (3, 4, 5)
Line 732:
=={{header|AWK}}==
<
BEGIN {
a[1] = 3; a[2]= 4; a[3] = 5;
Line 760:
function printVec(C) {
return "[ "C[1]" "C[2]" "C[3]" ]";
}</
Output:
<pre>a = [ 3 4 5 ]
Line 773:
=={{header|BASIC256}}==
{{works with|BASIC256 }}
<
a={3,4,5}:b={4,3,5}:c={-5,-12,-13}
Line 807:
end subroutine
</
Output:
<pre>
Line 818:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
a() = 3, 4, 5
b() = 4, 3, 5
Line 848:
PROCcross(B(),C(),D())
PROCcross(A(),D(),D())
ENDPROC</
Output:
<pre>
Line 856:
a x (b x c) = (-267, 204, -3)
</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.
<syntaxhighlight lang="bqn">Dot ← +´∘×
Cross ← 1⊸⌽⊸×{1⌽𝔽˜-𝔽}
Triple ← {𝕊a‿b‿c: a Dot b Cross c}
VTriple ← Cross´
a←3‿4‿5
b←4‿3‿5
c←¯5‿¯12‿¯13</syntaxhighlight>
Results:
<syntaxhighlight lang="bqn"> a Dot b
49
a Cross b
⟨ 5 5 ¯7 ⟩
Triple a‿b‿c
6
VTriple a‿b‿c
⟨ ¯267 204 ¯3 ⟩</syntaxhighlight>
=={{header|C}}==
<
typedef struct{
Line 904 ⟶ 928:
return 0;
}</
Output:
<pre>
Line 917 ⟶ 941:
=={{header|C sharp|C#}}==
<
using System.Windows.Media.Media3D;
Line 943 ⟶ 967:
Console.WriteLine(VectorTripleProduct(a, b, c));
}
}</
Output:
<pre>49
Line 951 ⟶ 975:
=={{header|C++}}==
<
template< class T >
Line 1,004 ⟶ 1,028:
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 )
Line 1,012 ⟶ 1,036:
=={{header|Ceylon}}==
<
alias Vector => Float[3];
Line 1,039 ⟶ 1,063:
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
Line 1,047 ⟶ 1,071:
=={{header|Clojure}}==
<
(defn dot
Line 1,071 ⟶ 1,095:
(dot a (cross b c))
(cross a (cross b c)))]
(println prod)))</
Output:<PRE>
49
Line 1,079 ⟶ 1,103:
=={{header|CLU}}==
<
equal, power, mul, unparse
where T has add: proctype (T,T) returns (T) signals (overflow),
Line 1,145 ⟶ 1,169:
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))
end start_up</
{{out}}
<pre> a = (3, 4, 5)
Line 1,159 ⟶ 1,183:
Using the Common Lisp Object System.
<
((x :type number :initarg :x)
(y :type number :initarg :y)
Line 1,203 ⟶ 1,227:
(cross-product a b)
(scalar-triple-product a b c)
(vector-triple-product a b c))))</
Output:
CL-USER> (vector-products-example)
Line 1,213 ⟶ 1,237:
Using vector type
<
(when (and (equal (length a) 3) (equal (length b) 3))
(vector
Line 1,235 ⟶ 1,259:
(scalar-triple a b c)
(vector-triple a b c)))
</syntaxhighlight>
Output:
Line 1,245 ⟶ 1,269:
=={{header|Cowgol}}==
<
record Vector is
Line 1,309 ⟶ 1,333:
print("a . b x c = "); print_signed(scalarTriple(&a, &b, &c)); print_nl();
print("a x b x c = "); vectorTriple(&a, &b, &c, &scratch);
print_vector(&scratch);</
{{out}}
<pre> a = (3, 4, 5)
Line 1,320 ⟶ 1,344:
=={{header|Crystal}}==
<
property x, y, z
Line 1,358 ⟶ 1,382:
puts "a cross b = #{a.cross_product(b).to_s}"
puts "a dot (b cross c) = #{a.scalar_triple_product b, c}"
puts "a cross (b cross c) = #{a.vector_triple_product(b, c).to_s}"</
{{out}}
<pre>a = (3, 4, 5)
Line 1,369 ⟶ 1,393:
=={{header|D}}==
<
struct V3 {
Line 1,412 ⟶ 1,436:
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]
Line 1,424 ⟶ 1,448:
=={{header|Delphi}}==
See [https://rosettacode.org/wiki/Vector_products#Pascal Pascal].
=={{header|EasyLang}}==
<syntaxhighlight lang=text>
func vdot a[] b[] .
for i to len a[]
r += a[i] * b[i]
.
return r
.
func[] vcross a[] b[] .
r[] &= a[2] * b[3] - a[3] * b[2]
r[] &= a[3] * b[1] - a[1] * b[3]
r[] &= a[1] * b[2] - a[2] * b[1]
return r[]
.
a[] = [ 3 4 5 ]
b[] = [ 4 3 5 ]
c[] = [ -5 -12 -13 ]
#
print vdot a[] b[]
print vcross a[] b[]
print vdot a[] vcross b[] c[]
print vcross a[] vcross b[] c[]
</syntaxhighlight>
{{out}}
<pre>
49
[ 5 5 -7 ]
6
[ -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)
Line 1,448 ⟶ 1,504:
(vector-triple-product a b c)
→ #( -267 204 -3)
</syntaxhighlight>
=={{header|Elixir}}==
<
def dot_product({a1,a2,a3}, {b1,b2,b3}), do: a1*b1 + a2*b2 + a3*b3
Line 1,471 ⟶ 1,527:
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}}
Line 1,485 ⟶ 1,541:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module(vector).
-export([main/0]).
Line 1,507 ⟶ 1,563:
dot_product(C,vector_product(A,B)),
io:fwrite("~p,~p,~p~n",vector_product(C,vector_product(A,B))).
</syntaxhighlight>
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM VECTORPRODUCT
Line 1,568 ⟶ 1,624:
PRINT("Ax(BxC)=";) PRINTVECTOR(FF.)
END PROGRAM
</syntaxhighlight>
=={{header|Euphoria}}==
<
function dot_product(sequence a, sequence b)
Line 1,606 ⟶ 1,662:
? scalar_triple( a, b, c )
puts(1,"a x (b x c) = ")
? vector_triple( a, b, c )</
Output:
<pre>a = {3,4,5}
Line 1,618 ⟶ 1,674:
=={{header|F#|F sharp}}==
<
ax * bx + ay * by + az * bz
Line 1,639 ⟶ 1,695:
printfn "%A" (scalTrip a b c)
printfn "%A" (vecTrip a b c)
0 // return an integer exit code</
{{out}}
<pre>49.0
Line 1,648 ⟶ 1,704:
=={{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 ;
Line 1,677 ⟶ 1,733:
"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>
Line 1,691 ⟶ 1,747:
=={{header|Fantom}}==
<
{
Int dot_product (Int[] a, Int[] b)
Line 1,724 ⟶ 1,780:
echo ("a x (b x c) = [" + vector_triple_product(a, b, c).join (", ") + "]")
}
}</
Output:
<pre>
Line 1,734 ⟶ 1,790:
=={{header|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! ;
Line 1,773 ⟶ 1,829:
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}}
<pre>
Line 1,781 ⟶ 1,837:
a x [b x c] = -267.000 204.000 -3.00000
</pre>
{{libheader|Forth Scientific Library}}<
S" fsl-util.fs" REQUIRED
: 3f! 3 SWAP }fput ;
Line 1,794 ⟶ 1,850:
: .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</
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
Specialized for 3-dimensional vectors.
<
real, dimension(3) :: a, b, c
Line 1,837 ⟶ 1,893:
end function v3_product
end program VectorProducts</
Output
<pre> 49.0000
Line 1,846 ⟶ 1,902:
=={{header|FreeBASIC}}==
<
Type V3
As double x,y,z
Line 1,877 ⟶ 1,933:
Show(a . b X c,a dot b cross c)
Show(a X (b X c),a cross (b cross c))
sleep</
{{out}}
<pre>a (3,4,5)
Line 1,889 ⟶ 1,945:
=={{header|FunL}}==
<
B = (4, 3, 5)
C = (-5, -12, -13)
Line 1,901 ⟶ 1,957:
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}}
Line 1,913 ⟶ 1,969:
=={{header|GAP}}==
<
return u*v;
end;
Line 1,950 ⟶ 2,006:
VectorTripleProduct(a, b, c);
# [ -267, 204, -3 ]</
=={{header|GLSL}}==
{{trans|C}}
<
vec3 a = vec3(3, 4, 5),b = vec3(4, 3, 5),c = vec3(-5, -12, -13);
Line 1,978 ⟶ 2,034:
return crossProduct(a,crossProduct(b,c));
}
</syntaxhighlight>
=={{header|Go}}==
<
import "fmt"
Line 2,016 ⟶ 2,072:
fmt.Println(s3(a, b, c))
fmt.Println(v3(a, b, c))
}</
Output:
<pre>
Line 2,027 ⟶ 2,083:
=={{header|Groovy}}==
Dot Product Solution:
<
assert x && y && x.size() == y.size()
[x, y].transpose().collect(binaryOp)
Line 2,037 ⟶ 2,093:
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]
Line 2,059 ⟶ 2,115:
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 ->
Line 2,083 ⟶ 2,139:
test(crossProductS)
test(crossProductV)</
Output:
<pre> a . b = 49
Line 2,096 ⟶ 2,152:
=={{header|Haskell}}==
<
type Vector a = [a]
Line 2,148 ⟶ 2,204:
, "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]
Line 2,159 ⟶ 2,215:
Or using '''Either''' and '''(>>=)''', rather than '''error''', to pass on intelligible messages:
<
:: Num a
=> [a] -> [a] -> Either String a
Line 2,214 ⟶ 2,270:
:: Show a
=> Either String a -> String
sh = either (" => " ++) ((" = " ++) . show)</
{{Out}}
<pre>a . b = 49
Line 2,224 ⟶ 2,280:
=={{header|Icon}} and {{header|Unicon}}==
<
record Vector3D(x, y, z)
Line 2,265 ⟶ 2,321:
writes ("Ax(BxC) : " || toString(a) || "x(" || toString(b) || "x" || toString(c) || ") = ")
write (toString(vectorTriple (a, b, c)))
end</
Output:
<pre>
Line 2,277 ⟶ 2,333:
Perhaps the most straightforward definition for cross product in J uses rotate multiply and subtract:
<
or
<syntaxhighlight lang="j">cross=: {{ ((1|.x)*2|.y) - (2|.x)*1|.y }}</syntaxhighlight>
However, there are other valid approaches. For example, a "generalized approach" based on [[j:Essays/Complete Tensor]]:
<
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. (For example, we could implement cross product using complex numbers in a Cayley Dickson implementation of quaternion 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:
<
or
<syntaxhighlight lang="j">cross=: {{ >-L:0/ .(*L:0) (<"1=i.3), x,:&:(<"0) y}}</syntaxhighlight>
With an implementation of cross product and inner product, the rest of the task becomes trivial:
<
b=: 4 3 5
c=: -5 12 13
Line 2,302 ⟶ 2,363:
crossP=: A cross B
scTriP=: A ip B cross C
veTriP=: A cross B cross C</
Required example:
<
49
crossP a;b
Line 2,311 ⟶ 2,372:
6
veTriP a;b;c
_267 204 _3</
=={{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;
Line 2,363 ⟶ 2,424:
System.out.println(a.vecTrip(b, c));
}
}</
Output:
<pre>49.0
Line 2,371 ⟶ 2,432:
{{works with|Java|1.8+}}
This solution uses Java SE new Stream API
<
import java.util.stream.IntStream;
Line 2,432 ⟶ 2,493:
}
}</
result is the same as above , fortunately
<pre>dot product =:49
Line 2,443 ⟶ 2,504:
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;
Line 2,512 ⟶ 2,573:
'A x (B x C): ' + vectorTripleProduct(a, b, c)
);
}());</
{{Out}}
<pre>A . B: 49
Line 2,520 ⟶ 2,581:
===ES6===
<
'use strict';
Line 2,659 ⟶ 2,720:
// MAIN ---
return main();
})();</
{{Out}}
<pre>a . b = 49
Line 2,669 ⟶ 2,730:
=={{header|jq}}==
The <code>dot_product()</code> 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.<
reduce range(0;a|length) as $i (0; . + (a[$i] * b[$i]) );
Line 2,689 ⟶ 2,750:
"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 x b = [5, 5, -7]"
"a . (b x c) = 6 )"
"a x (b x c) = [-267, 204, -3]"</
=={{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]
Line 2,711 ⟶ 2,772:
@show a × b
@show a ⋅ (b × c)
@show a × (b × c)</
{{out}}
Line 2,728 ⟶ 2,789:
=={{header|Kotlin}}==
<
class Vector3D(val x: Double, val y: Double, val z: Double) {
Line 2,755 ⟶ 2,816:
println("a . b x c = ${a.scalarTriple(b, c)}")
println("a x b x c = ${a.vectorTriple(b, c)}")
}</
{{out}}
Line 2,768 ⟶ 2,829:
a x b x c = (-267.0, 204.0, -3.0)
</pre>
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">
#!/bin/ksh
# Vector products
# # dot product (a scalar quantity) A • B = a1b1 + a2b2 + a3b3 + ...
# # cross product (a vector quantity) A x B = (a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1)
# # scalar triple product (a scalar quantity) A • (B x C)
# # vector triple product (a vector quantity) A x (B x C)
# # Variables:
#
typeset -a A=( 3 4 5 )
typeset -a B=( 4 3 5 )
typeset -a C=( -5 -12 -13 )
# # Functions:
#
# # Function _dotprod(vec1, vec2) - Return the (scalar) dot product of 2 vectors
#
function _dotprod {
typeset _vec1 ; nameref _vec1="$1" # Input vector 1
typeset _vec2 ; nameref _vec2="$2" # Input vector 2
typeset _i ; typeset -si _i
typeset _dotp ; integer _dotp=0
for ((_i=0; _i<${#_vec1[*]}; _i++)); do
(( _dotp+=(_vec1[_i] * _vec2[_i]) ))
done
echo ${_dotp}
}
# # Function _crossprod(vec1, vec2, vec) - Return the (vector) cross product of 2 vectors
#
function _crossprod {
typeset _vec1 ; nameref _vec1="$1" # Input vector 1
typeset _vec2 ; nameref _vec2="$2" # Input vector 2
typeset _vec3 ; nameref _vec3="$3" # Output vector
_vec3+=( $(( _vec1[1]*_vec2[2] - _vec1[2]*_vec2[1] )) )
_vec3+=( $(( _vec1[2]*_vec2[0] - _vec1[0]*_vec2[2] )) )
_vec3+=( $(( _vec1[0]*_vec2[1] - _vec1[1]*_vec2[0] )) )
}
# # Function _scal3prod(vec1, vec2, vec3) - Return the (scalar) scalar triple product of 3 vectors
#
function _scal3prod {
typeset _vec1 ; nameref _vec1="$1" # Input vector 1
typeset _vec2 ; nameref _vec2="$2" # Input vector 2
typeset _vec3 ; nameref _vec3="$3" # Input vector 3
typeset _vect ; typeset -a _vect # temp vector
_crossprod _vec2 _vec3 _vect # (B x C)
echo $(_dotprod _vec1 _vect) # A • (B x C)
}
# # Function _vect3prod(vec1, vec2, vec3, vec) - Return the (vector) vector triple product of 3 vectors
#
function _vect3prod {
typeset _vec1 ; nameref _vec1="$1" # Input vector 1
typeset _vec2 ; nameref _vec2="$2" # Input vector 2
typeset _vec3 ; nameref _vec3="$3" # Input vector 3
typeset _vec4 ; nameref _vec4="$4" # Output vector
typeset _vect ; typeset -a _vect # temp vector
_crossprod _vec2 _vec3 _vect # (B x C)
_crossprod _vec1 _vect _vec4 # A x (B x C)
}
######
# main #
######
print "The dot product A • B = $(_dotprod A B)"
typeset -a arr
_crossprod A B arr
print "The cross product A x B = ( ${arr[@]} )"
print "The scalar triple product A • (B x C) = $(_scal3prod A B C)"
typeset -m crossprod=arr ; typeset -a arr
_vect3prod A B C arr
print "The vector triple product A x (B x C) = ( ${arr[@]} )"
</syntaxhighlight>
{{out}}<pre>
The dot product A • B = 49
The cross product A x B = ( 5 5 -7 )
The scalar triple product A • (B x C) = 6
The vector triple product A x (B x C) = ( -267 204 -3 )</pre>
=={{header|Lambdatalk}}==
<
{def dotProduct
{lambda {:a :b}
Line 2,796 ⟶ 2,950:
A.(BxC) : {dotProduct {A} {crossProduct {B} {C}}} -> 6
Ax(BxC) : {crossProduct {A} {crossProduct {B} {C}}} -> [-267,204,-3]
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<
print "Dot product of 3,4,5 and 4,3,5 is "
Line 2,843 ⟶ 2,997:
VectorTripleProduct$ =CrossProduct$( i$, CrossProduct$( j$, k$))
end function
END SUB</
=={{header|Lingo}}==
Lingo has a built-in vector data type that supports calculation of both dot and cross products:
<
b = vector(4,5,6)
Line 2,857 ⟶ 3,011:
put a.cross(b)
-- vector( -3.0000, 6.0000, -3.0000 )</
=={{header|Lua}}==
<
function Vector.new( _x, _y, _z )
return { x=_x, y=_y, z=_z }
Line 2,896 ⟶ 3,050:
r = Vector.vector_triple( A, B, C )
print( r.x, r.y, r.z )</
<pre>49
5 5 -7
Line 2,903 ⟶ 3,057:
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module checkit {
class Vector {
Line 2,973 ⟶ 3,127:
}
Checkit
</syntaxhighlight>
{{out}}
<pre >
Line 2,987 ⟶ 3,141:
=={{header|Maple}}==
<
A := Vector([3,4,5]):
B := Vector([4,3,5]):
Line 2,998 ⟶ 3,152:
6
>>>CrossProduct(A,CrossProduct(B,C));
Vector([-267, 204, -3])</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
b={4,3,5};
c={-5,-12,-13};
Line 3,007 ⟶ 3,161:
Cross[a,b]
a.Cross[b,c]
Cross[a,Cross[b,c]]</
{{out}}
<pre>49
Line 3,016 ⟶ 3,170:
=={{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.
Line 3,031 ⟶ 3,185:
dot(a,cross(b,c))
% Compute and display: a x b x c, the vector triple product.
cross(a,cross(b,c))</
Code for testing:
Line 3,063 ⟶ 3,217:
=={{header|Mercury}}==
<syntaxhighlight lang="text">:- module vector_product.
:- interface.
Line 3,104 ⟶ 3,258:
to_string(vector3d(X, Y, Z)) =
string.format("(%d, %d, %d)", [i(X), i(Y), i(Z)]).</
=={{header|MiniScript}}==
<
vectorB = [4, 3, 5]
vectorC = [-5, -12, -13]
Line 3,123 ⟶ 3,277:
print "Scalar Triple Product = " + dotProduct(vectorA, crossProduct(vectorB,vectorC))
print "Vector Triple Product = " + crossProduct(vectorA, crossProduct(vectorB,vectorC))
</syntaxhighlight>
{{out}}
<pre>
Line 3,133 ⟶ 3,287:
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">ПП 54 С/П ПП 66 С/П
ИП0 ИП3 ИП6 П3 -> П0 -> П6
ИП1 ИП4 ИП7 П4 -> П1 -> П7
Line 3,144 ⟶ 3,298:
ИП1 ИП5 * ИП2 ИП4 * - П9
ИП2 ИП3 * ИП0 ИП5 * - ПA
ИП0 ИП4 * ИП1 ИП3 * - ПB В/О</
''Instruction'': Р0 - a<sub>1</sub>, Р1 - a<sub>2</sub>, Р2 - a<sub>3</sub>, Р3 - b<sub>1</sub>, Р4 - b<sub>2</sub>, Р5 - b<sub>3</sub>, Р6 - c<sub>1</sub>, Р7 - c<sub>2</sub>, Р8 - c<sub>3</sub>; В/О С/П.
=={{header|Modula-2}}==
<
FROM RealStr IMPORT RealToStr;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
Line 3,231 ⟶ 3,385:
ReadChar
END VectorProducts.</
=={{header|Nemerle}}==
<
module VectorProducts3d
Line 3,269 ⟶ 3,423:
WriteLine(VectorTriple(a, b, c));
}
}</
Outputs
<pre>49
Line 3,277 ⟶ 3,431:
=={{header|Never}}==
<
prints("[" + a[0] + ", " + a[1] + ", " + a[2] + "]\n");
0
Line 3,312 ⟶ 3,466:
0
}
</syntaxhighlight>
Output:
<pre>
Line 3,325 ⟶ 3,479:
=={{header|Nim}}==
<
type Vector3 = array[1..3, float]
Line 3,355 ⟶ 3,509:
echo &"a . b = {a.dot(b)}"
echo &"a . (b ⨯ c) = {scalarTriple(a, b, c)}"
echo &"a ⨯ (b ⨯ c) = {vectorTriple(a, b, c)}"</
{{out}}
Line 3,364 ⟶ 3,518:
=={{header|Objeck}}==
<
class VectorProduct {
function : Main(args : String[]) ~ Nil {
Line 3,427 ⟶ 3,581:
}
}
</syntaxhighlight>
Output:
Line 3,436 ⟶ 3,590:
=={{header|OCaml}}==
<
let b = (4.0, 3.0, 5.0)
let c = (-5.0, -12.0, -13.0)
Line 3,465 ⟶ 3,619:
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:
Line 3,479 ⟶ 3,633:
=={{header|Octave}}==
Octave handles naturally vectors / matrices.
<
b = [4, 3, 5];
c = [-5, -12, -13];
Line 3,503 ⟶ 3,657:
% -267 204 -3
v3prod(a, b, c)</
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">
a = .vector~new(3, 4, 5);
b = .vector~new(4, 3, 5);
Line 3,556 ⟶ 3,710:
expose x y z
return "<"||x", "y", "z">"
</syntaxhighlight>
Output:
<pre>
Line 3,566 ⟶ 3,720:
=={{header|PARI/GP}}==
<
sum(i=1,#u,u[i]*v[i])
};
Line 3,583 ⟶ 3,737:
cross(a,b)
striple(a,b,c)
vtriple(a,b,c)</
Output:
<pre>49
Line 3,591 ⟶ 3,745:
=={{header|Pascal}}==
<
type
Line 3,638 ⟶ 3,792:
writeln('a . (b x c): ', scalarTripleProduct(a,b,c):15:8);
write('a x (b x c): '); printVector(vectorTripleProduct(a,b,c));
end.</
Output:
<pre>a: 3.00000000 4.00000000 5.00000000
Line 3,648 ⟶ 3,802:
a x (b x c): -267.00000000 204.00000000 -3.00000000
</pre>
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
uses System.Numerics;
function DotProduct(v1,v2: Vector3): real
:= v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
function CrossProduct(v1,v2: Vector3): Vector3
:= new Vector3(v1.y * v2.z - v1.z * v2.y,
v1.z * v2.x - v1.x * v2.z,
v1.x * v2.y - v1.y * v2.x);
function ScalarTripleProduct(a,b,c: Vector3): real
:= DotProduct(a, CrossProduct(b, c));
function VectorTripleProduct(a,b,c: Vector3): Vector3
:= CrossProduct(a, CrossProduct(b, c));
begin
var a := new Vector3(3,4,5);
var b := new Vector3(4,3,5);
var c := new Vector3(-5,-12,-13);
Writeln(DotProduct(a, b));
Writeln(CrossProduct(a, b));
Writeln(ScalarTripleProduct(a, b, c));
Writeln(VectorTripleProduct(a, b, c));
end.
</syntaxhighlight>
{{out}}
<pre>
49
<5. 5. -7>
6
<-267. 204. -3>
</pre>
=={{header|Perl}}==
<
use List::Util 'sum';
use List::MoreUtils 'pairwise';
Line 3,677 ⟶ 3,869:
print "$a x $b = ", $a ^ $b, "\n";
print "$a . ($b x $c) = ", $a & ($b ^ $c), "\n";
print "$a x ($b x $c) = ", $a ^ ($b ^ $c), "\n";</
Output: <pre>a = (3 4 5) b = (4 3 5) c = (-5 -12 -13)
Line 3,687 ⟶ 3,879:
=={{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>
Line 3,711 ⟶ 3,903:
<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>
Line 3,721 ⟶ 3,913:
=={{header|Phixmonti}}==
<
( 3 4 5 ) var vectorA
Line 3,749 ⟶ 3,941:
"Cross Product = " print vectorA vectorB crossProduct ?
"Scalar Triple Product = " print vectorB vectorC crossProduct vectorA swap dotProduct ?
"Vector Triple Product = " print vectorB vectorC crossProduct vectorA swap crossProduct ?</
{{out}}
<pre>Dot Product = 49
Line 3,759 ⟶ 3,951:
=={{header|PHP}}==
<
class Vector
Line 3,863 ⟶ 4,055:
new Program();
?>
</syntaxhighlight>
Output:
Line 3,877 ⟶ 4,069:
A × (B × C) =(-267.00, 204.00, -3.00)
</pre>
=={{header|Picat}}==
<syntaxhighlight lang="picat">go =>
A = [3, 4, 5],
B = [4, 3, 5],
C = [-5, -12, -13],
println(a=A),
println(b=B),
println(c=C),
println("A . B"=dot(A,B)),
println("A x B"=cross(A,B)),
println("A . (B x C)"=scalar_triple(A,B,C)),
println("A X (B X C)"=vector_triple(A,B,C)),
nl.
dot(A,B) = sum([ AA*BB : {AA,BB} in zip(A,B)]).
cross(A,B) = [A[2]*B[3]-A[3]*B[2], A[3]*B[1]-A[1]*B[3], A[1]*B[2]-A[2]*B[1]].
scalar_triple(A,B,C) = dot(A,cross(B,C)).
vector_triple(A,B,C) = cross(A,cross(B,C)).</syntaxhighlight>
{{out}}
<pre>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]</pre>
=={{header|PicoLisp}}==
<
(sum * A B) )
Line 3,892 ⟶ 4,115:
(de vectorTriple (A B C)
(crossProduct A (crossProduct B C)) )</
Test:
<pre>(setq
Line 3,912 ⟶ 4,135:
=={{header|PL/I}}==
<
test_products: procedure options (main);
Line 3,953 ⟶ 4,176:
end vector_triple_product;
end test_products;</
Results:
<pre>
Line 3,962 ⟶ 4,185:
</pre>
<
/* dot product, cross product, etc. 6 June 2011 */
Line 4,009 ⟶ 4,232:
end vector_triple_product;
end test_products;</
The output is:
<pre>
Line 4,019 ⟶ 4,242:
=={{header|Plain English}}==
<
Start up.
Make a vector from 3 and 4 and 5.
Line 4,086 ⟶ 4,309:
Compute a cross product of the other vector and the third vector.
Compute another cross product of the vector and the cross product.
Put the other cross product into the vector triple product.</
{{out}}
<pre>
Line 4,100 ⟶ 4,323:
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function dot-product($a,$b) {
$a[0]*$b[0] + $a[1]*$b[1] + $a[2]*$b[2]
Line 4,128 ⟶ 4,351:
"a.(bxc) = $(scalar-triple-product $a $b $c)"
"ax(bxc) = $(vector-triple-product $a $b $c)"
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 4,139 ⟶ 4,362:
=={{header|Prolog}}==
Works with SWI-Prolog.
<
dot_product([A1, A2, A3], [B1, B2, B3], Ans) :-
Ans is A1 * B1 + A2 * B2 + A3 * B3.
Line 4,156 ⟶ 4,379:
cross_product(B, C, Temp),
cross_product(A, Temp, Ans).
</syntaxhighlight>
Output:
<pre>
Line 4,173 ⟶ 4,396:
=={{header|PureBasic}}==
<
x.f
y.f
Line 4,222 ⟶ 4,445:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
Sample output:
<pre>a = [3.00, 4.00, 5.00], b = [4.00, 3.00, 5.00], c = [-5.00, -12.00, -13.00]
Line 4,232 ⟶ 4,455:
=={{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'
Line 4,258 ⟶ 4,481:
print("a x b = %r" % (crossp(a,b),))
print("a . (b x c) = %r" % scalartriplep(a, b, c))
print("a x (b x c) = %r" % (vectortriplep(a, b, c),))</
{{out}}
Line 4,269 ⟶ 4,492:
;Note:
The popular [http://numpy.scipy.org/ numpy] package has functions for dot and cross products.
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ 0 unrot witheach
[ over i^ peek *
rot + swap ]
drop ] is dotproduct ( [ [ --> n )
[ join
dup 1 peek over 5 peek *
swap
dup 2 peek over 4 peek *
swap dip -
dup 2 peek over 3 peek *
swap
dup 0 peek over 5 peek *
swap dip -
dup 0 peek over 4 peek *
swap
dup 1 peek swap 3 peek *
- join join ] is crossproduct ( [ [ --> [ )
[ crossproduct dotproduct ] is scalartriple ( [ [ [ --> n )
[ crossproduct crossproduct ] is vectortriple ( [ [ [ --> [ )
[ ' [ 3 4 5 ] ] is a ( --> [ )
[ ' [ 4 3 5 ] ] is b ( --> [ )
[ ' [ -5 -12 -13 ] ] is c ( --> [ )
a b dotproduct echo cr
a b crossproduct echo cr
a b c scalartriple echo cr
a b c vectortriple echo cr</syntaxhighlight>
{{out}}
<pre>49
[ 5 5 -7 ]
6
[ -267 204 -3 ]
</pre>
=={{header|R}}==
<
# Vector products
# R implementation
Line 4,327 ⟶ 4,592:
cat("a x b =", crossp(a, b))
cat("a . (b x c) =", scalartriplep(a, b, c))
cat("a x (b x c) =", vectortriplep(a, b, c))</
{{out}}
Line 4,339 ⟶ 4,604:
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 4,370 ⟶ 4,635:
(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))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|rakudo|2015-11-24}}
<syntaxhighlight lang="raku"
sub infix:<⨯>([$a1, $a2, $a3], [$b1, $b2, $b3]) {
Line 4,394 ⟶ 4,659:
say "a ⨯ b = <{ @a ⨯ @b }>";
say "a ⋅ (b ⨯ c) = { scalar-triple-product(@a, @b, @c) }";
say "a ⨯ (b ⨯ c) = <{ vector-triple-product(@a, @b, @c) }>";</
{{out}}
<pre>("a" => ["3", "4", "5"], "b" => ["4", "3", "5"], "c" => ["-5", "-12", "-13"])
Line 4,403 ⟶ 4,668:
=={{header|REXX}}==
<
b= 4 3 5
Say ''
/*---------------------------------------------------------------------------*/
cross: Procedure
Arg a b c, u v w
Return b*w-c*v c*u-a*w a*v-b*u
dot: Procedure
Arg a b c, u v w
Return a*u + b*v + c*w
/*---------------------------------------------------------------------------*/
tellV: Procedure
Parse Arg name,x y z
w=max(4,length(x),length(y),length(z)) /*max width */
Say right(name,33) right(x,w) right(y,w) right(z,w) /*show vector. */
Return</syntaxhighlight>
{{out|output|text= when using the default internal inputs:}}
<pre>
=={{header|Ring}}==
<
# Project : Vector products
Line 4,468 ⟶ 4,739:
cross(a,d,e)
see "a x (b x c) = (" + e[1] + ", " +e[2] + ", " + e[3] + ")"
</syntaxhighlight>
Output:
<pre>
Line 4,475 ⟶ 4,746:
a . (b x c) = 6
a x (b x c) = (-267, 204, -3)
</pre>
=={{header|RPL}}==
Dot and cross products are built-in functions in RPL.
{{works with|Halcyon Calc|4.2.7}}
≪ → a b c
≪ a b DOT
a b CROSS
a b c CROSS DOT
a b c CROSS CROSS
≫ ≫
‘VPROD’ STO
[3 4 5] [4 3 5] [-5 -12 -13] VPROD
{{out}}
<pre>
4: 49
3: [ 5 5 -7 ]
2: 6
1: [ -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
Line 4,498 ⟶ 4,789:
puts "a cross b = #{a.cross_product b}"
puts "a dot (b cross c) = #{a.scalar_triple_product b, c}"
puts "a cross (b cross c) = #{a.vector_triple_product b, c}"</
Output: <pre>a dot b = 49
a cross b = Vector[5, 5, -7]
Line 4,505 ⟶ 4,796:
=={{header|Rust}}==
<
struct Vector {
x: f64,
Line 4,549 ⟶ 4,840:
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
Line 4,557 ⟶ 4,848:
=={{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)
Line 4,575 ⟶ 4,866:
println("a x (b x c) : " + (a vectorTriple(b, c)))
}
}</
{{out}}
<pre> a . b : 49.0
Line 4,586 ⟶ 4,877:
{{works with|Gauche}}
Using modified dot-product function from the [[Dot product]] task.
<
(apply + (map * (vector->list A) (vector->list B))))
Line 4,620 ⟶ 4,911:
(display "A x B = ")(display (cross-product A B))(newline)
(display "A . B x C = ")(display (scalar-triple-product A B C))(newline)
(display "A x B x C = ") (display (vector-triple-product A B C))(newline)</
Output:<pre>A = #(3 4 5)
B = #(4 3 5)
Line 4,633 ⟶ 4,924:
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";
Line 4,683 ⟶ 4,974:
writeln("a .(b x c) = " <& scalarTriple(a, b, c));
writeln("a x(b x c) = " <& vectorTriple(a, b, c));
end func;</
{{output}}
Line 4,695 ⟶ 4,986:
=={{header|Sidef}}==
<
method ∙(vec) {
[self{:x,:y,:z}] »*« [vec{:x,:y,:z}] «+»
Line 4,719 ⟶ 5,010:
say "a ⨉ b = #{a ⨉ b}"
say "a ∙ (b ⨉ c) = #{a ∙ (b ⨉ c)}"
say "a ⨉ (b ⨉ c) = #{a ⨉ (b ⨉ c)}"</
{{out}}
<pre>a=(3, 4, 5); b=(4, 3, 5); c=(-5, -12, -13);
Line 4,728 ⟶ 5,019:
=={{header|Simula}}==
{{Trans|C}}
<
CLASS VECTOR(I,J,K); REAL I,J,K;;
Line 4,778 ⟶ 5,069:
OUTIMAGE;
END;
END;</
{{out}}
<pre>A = (3.000000, 4.000000, 5.000000)
Line 4,790 ⟶ 5,081:
=={{header|Stata}}==
<
real scalar sprod(real colvector u, real colvector v) {
return(u[1]*v[1] + u[2]*v[2] + u[3]*v[3])
Line 4,832 ⟶ 5,123:
3 | -3 |
+--------+
end</
=={{header|Swift}}==
<
infix operator • : MultiplicationPrecedence
Line 4,874 ⟶ 5,165:
print("a × b = \(a × b)")
print("a • (b × c) = \(a • (b × c))")
print("a × (b × c) = \(a × (b × c))")</
{{out}}
Line 4,888 ⟶ 5,179:
=={{header|Tcl}}==
<
lassign $A a1 a2 a3
lassign $B b1 b2 b3
Line 4,905 ⟶ 5,196:
proc vectorTriple {A B C} {
cross $A [cross $B $C]
}</
Demonstrating:
<
set b {4 3 5}
set c {-5 -12 -13}
Line 4,913 ⟶ 5,204:
puts "a x b = [cross $a $b]"
puts "a • b x c = [scalarTriple $a $b $c]"
puts "a x b x c = [vectorTriple $a $b $c]"</
Output:<pre>a • b = 49
a x b = 5 5 -7
Line 4,923 ⟶ 5,214:
{{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.
<syntaxhighlight lang="text">a = 0 ' use variables for vector addresses
b = a + 3
c = b + 3
Line 4,966 ⟶ 5,257:
Proc _Cross (b@, c@, e@)
Proc _Cross (a@, e@, d@)
Return</
{{Out}}
<pre>a . b = 49
Line 4,976 ⟶ 5,267:
=={{header|VBA}}==
{{trans|Phix}}<
Function dot_product(a As Variant, b As Variant) As Variant
dot_product = WorksheetFunction.SumProduct(a, b)
Line 5,001 ⟶ 5,292:
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), ", "); ")"
End Sub</
<pre> a . b = 49
a x b = (5, 5, -7)
Line 5,009 ⟶ 5,300:
=={{header|Visual Basic .NET}}==
Class: Vector3D
<
Private _x, _y, _z As Double
Line 5,066 ⟶ 5,357:
Return String.Format("({0}, {1}, {2})", _x, _y, _z)
End Function
End Class</
Module: Module1
<
Sub Main()
Line 5,086 ⟶ 5,377:
End Sub
End Module</
Output:
<pre>v1: (3, 4, 5)
Line 5,096 ⟶ 5,387:
v1 . (v2 x v3) = 6
v1 x (v2 x v3) = (-267, 204, -3)</pre>
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">struct Vector {
x f64
y f64
z f64
}
const (
a = Vector{3, 4, 5}
b = Vector{4, 3, 5}
c = Vector{-5, -12, -13}
)
fn dot(a Vector, b Vector) f64 {
return a.x*b.x + a.y*b.y + a.z*b.z
}
fn cross(a Vector, 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}
}
fn s3(a Vector, b Vector, c Vector) f64 {
return dot(a, cross(b, c))
}
fn v3(a Vector, b Vector, c Vector) Vector {
return cross(a, cross(b, c))
}
fn main() {
println(dot(a, b))
println(cross(a, b))
println(s3(a, b, c))
println(v3(a, b, c))
}</syntaxhighlight>
{{out}}
<pre>
49.
Vector{
x: 5
y: 5
z: -7
}
6.
Vector{
x: -267
y: 204
z: -3
}
</pre>
=={{header|Wortel}}==
<
dot &[a b] @sum @mapm ^* [a b]
cross &[a b] [[
Line 5,118 ⟶ 5,462:
@!vectorTripleProduct [a b c]
]]
}</
Returns:
<pre>[49 [5 5 -7] 6 [-267 204 -3]]</pre>
Line 5,124 ⟶ 5,468:
=={{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.")
Line 5,169 ⟶ 5,513:
System.print("a x b = %(a.cross(b))")
System.print("a . b x c = %(a.scalarTriple(b, c))")
System.print("a x b x c = %(a.vectorTriple(b, c))")</
{{out}}
Line 5,182 ⟶ 5,526:
a x b x c = [-267, 204, -3]
</pre>
{{libheader|Wren-vector}}
Alternatively, using the above module to produce exactly the same output as before:
<syntaxhighlight lang="wren">import "./vector" for Vector3
var a = Vector3.new(3, 4, 5)
var b = Vector3.new(4, 3, 5)
var c = Vector3.new(-5, -12, -13)
System.print("a = %(a)")
System.print("b = %(b)")
System.print("c = %(c)")
System.print()
System.print("a . b = %(a.dot(b))")
System.print("a x b = %(a.cross(b))")
System.print("a . b x c = %(a.scalarTripleProd(b, c))")
System.print("a x b x c = %(a.vectorTripleProd(b, c))")</syntaxhighlight>
=={{header|XBS}}==
<
class Vector3 {
construct=func(self,x,y,z){
Line 5,271 ⟶ 5,631:
log("Cross: ",a::Cross(b)::ToString());
log("Scalar Triple: ",a::Dot(b::Cross(c)));
log("Vector Triple: ",a::Cross(b::Cross(c))::ToString());</
{{out}}
<pre>
Line 5,281 ⟶ 5,641:
=={{header|XPL0}}==
<
func DotProd(A, B); \Return the dot product of two 3D vectors
Line 5,325 ⟶ 5,685:
IntOut(0, D(1)); ChOut(0, 9\tab\);
IntOut(0, D(2)); CrLf(0);
]</
Output:
Line 5,339 ⟶ 5,699:
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
{ return(a2*b3 - a3*b2, a3*b1 - a1*b3, a1*b2 - a2*b1) }</
<
dotp(a,b).println(); //5 --> 49
crossp(a,b).println(); //6 --> (5,5,-7)
dotp(a, crossp(b,c)).println(); //7 --> 6
crossp(a, crossp(b,c)).println(); //8 --> (-267,204,-3)</
{{out}}
<pre>
Line 5,355 ⟶ 5,715:
</pre>
Or, using the GNU Scientific Library:
<
a:=GSL.VectorFromData( 3, 4, 5);
b:=GSL.VectorFromData( 4, 3, 5);
Line 5,365 ⟶ 5,725:
(a*(b.copy().crossProduct(c))).println(); // 6 scalar triple product
(a.crossProduct(b.crossProduct(c))) // (-267,204,-3) vector triple product, in place
.format().println();</
{{out}}
<pre>
|