Dot product: Difference between revisions

 

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

{{out}}<pre>3</pre>

 

=={{header|360 Assembly}}==

DOTPROD CSECT

USING DOTPROD,R15

PG DC CL80' ' buffer

YREGS

{{out}}

<pre>

 

=={{header|8th}}==

{{out}}<pre>3</pre>

 

=={{header|ABAP}}==

data: lv_n type i,

lv_sum type i,

lv_sum = lv_sum + ( <wa_a> * <wa_b> ).

enddo.

{{out}}<pre>3</pre>

 

=={{header|ACL2}}==

(if (or (endp v) (endp u))

0

(+ (* (first v) (first u))

 

<pre>&gt; (dotp '(1 3 -5) '(4 -2 -1))

3</pre>

 

=={{header|ActionScript}}==

{

if(v1.length != v2.length) return NaN;

return sum;

}

 

=={{header|Ada}}==

procedure dot_product is

type vect is array(Positive range <>) of Integer;

begin

put_line(Integer'Image(dotprod(v1,v2)));

{{out}}<pre>3</pre>

 

=={{header|Aime}}==

dp(list a, list b)

{

 

0;

{{out}}<pre>3</pre>

 

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

MODE DOTVEC = [1:0]DOTFIELD;

 

 

print(("a SSDOT b = ",fixed(a SSDOT b,0,real width), new line));

{{out}}<pre>a SSDOT b = 3.000000000000000

a * b = 3.000000000000000</pre>

 

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

% computes the dot product of two equal length integer vectors %

% (single dimension arrays ) the length of the vectors must be specified %

write( integerDotProduct( v1, v2, 3 ) )

end.

 

=={{header|APL}}==

<b>Output:</b>

<pre>3</pre>

=={{header|AppleScript}}==

{{trans|JavaScript}} ( functional version )

 

-- dotProduct :: [Number] -> [Number] -> Number

return lst

end tell

{{Out}}

 

=={{header|Arturo}}==

 

[ensure equal? size a size b]

 

result: 0

loop 0..(size a)-1 'i [

]

return result

 

print dotProduct @[1, 3, neg 5] @[4, neg 2, neg 1]

 

{{out}}

 

=={{header|AutoHotkey}}==

Vet2 := "4 , -2 , -1"

MsgBox % DotProduct( Vet1 , Vet2 )

Sum += ArrayA%A_Index% * ArrayB%A_Index%

Return Sum

 

=={{header|AWK}}==

# syntax: GAWK -f DOT_PRODUCT.AWK

BEGIN {

return(sum)

}

{{out}}<pre>3</pre>

 

==={{header|Applesoft BASIC}}===

Calculates the dot product of two random vectors of length N.

100 :

110 REM DOT PRODUCT

440 PRINT "] . [";: FOR I = 1 TO N: PRINT " ";V2(I);: NEXT I

450 PRINT "] = ";DP

{{out}}

<pre>]RUN

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

BBC BASIC has a built-in dot-product operator:

vec1() = 1, 3, -5

dot() = vec1() . vec2()

{{out}}<pre>Result is 3</pre>

 

=={{header|bc}}==

* arrays) of size n.

*/

b[1] = -2

b[2] = -1

 

{{Out}}

<pre>3</pre>

 

=={{header|Befunge 93}}==

v Space for variables

v Space for vector1

>00g1-10p>10g:01-` | "

> ^

{{out}}<pre>Length:

3

-1

3</pre>

 

=={{header|Bracmat}}==

= a A z Z

. !arg:(%?a ?z.%?A ?Z)

| 0

)

{{out}}<pre>3</pre>

 

=={{header|C}}==

#include <stdlib.h>

 

 

return sum;

{{out}}<pre>3</pre>

 

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

{

Console.WriteLine(DotProduct(new decimal[] { 1, 3, -5 }, new decimal[] { 4, -2, -1 }));

 

return tVal;

{{out}}<pre>3</pre>

 

===Alternative using Linq (C# 4)===

{{works with|C sharp|C#|4}}

return a.Zip(b, (x, y) => x * y).Sum();

 

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

#include <numeric>

 

 

return 0;

{{out}}<pre>3</pre>

 

===Alternative using std::valarray===

#include <valarray>

#include <iostream>

return 0;

{{out}}<pre>3</pre>

 

=== Alternative using std::inner_product ===

#include <iostream>

#include <vector>

std::cout << "dot.product of {1,3,-5} and {4,-2,-1}: " << dp << std::endl;

return 0;

{{out}}<pre>dot.product of {1,3,-5} and {4,-2,-1}: 3</pre>

 

{{works with|Clojure|1.1}}

Preconditions are new in 1.1. The actual code also works in older Clojure versions.

{:pre [(apply == (map count matrix))]}

(apply + (apply map * matrix)))

(println (dot-product2 [1 3 -5] [4 -2 -1]))

(println (dot-product3 [1 3 -5] [4 -2 -1]))

 

=={{header|CoffeeScript}}==

if ary1.length != ary2.length

throw "can't find dot product: arrays have different lengths"

console.log dot_product([ 1, 3, -5 ], [ 4, -2, -1, 0 ]) # exception

catch e

{{out}}<pre>> coffee foo.coffee

3

 

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

This works with any size vector, and (as usual for Common Lisp) all numeric types (rationals, bignums, complex numbers, etc.).

 

Maybe it is better to do it without coercing. Then we got a cleaner code.

 

=={{header|Component Pascal}}==

{{Works with|BlackBox Component Builder}}

MODULE DotProduct;

IMPORT StdLog;

 

END DotProduct.

Execute: ^Q DotProduct.Test

{{out}}

3

</pre>

 

=={{header|Crystal}}==

{{trans|Ruby}}

property x, y, z

end

 

 

{{out}}<pre>3

 

=={{header|D}}==

import std.stdio, std.numeric;

 

[1.0, 3.0, -5.0].dotProduct([4.0, -2.0, -1.0]).writeln;

{{out}}

<pre>3</pre>

Using an array operation:

import std.stdio, std.algorithm;

 

double[3] c = a[] * b[];

c[].sum.writeln;

 

=={{header|Dart}}==

if (A.length != B.length){

throw new Exception('Vectors must be of equal size');

var k = [4,-2,-1];

print(dot(l,k));

{{out}}

<pre>3</pre>

=={{header|Delphi}}==

{{works with|Lazarus}}

 

{$APPTYPE CONSOLE}

WriteLn(DotProduct(x,y));

ReadLn;

{{out}}<pre> 3.00000000000000E+0000</pre>

Note: Delphi does not like arrays being declared in procedure headings, so it is necessary to declare it beforehand. To use integers, modify doublearray to be an array of integer.

=={{header|DWScript}}==

For arbitrary length vectors, using a precondition to check vector length:

require

a.Length = b.Length;

end;

 

Using built-in 4D Vector type:

var b := Vector(4, -2, -1, 0);

 

Ouput in both cases:<pre>3</pre>

 

=={{header|Déjà Vu}}==

if /= len a len b:

Raise value-error "dot product needs two vectors with the same length"

+ * pop-from a pop-from b

 

{{out}}<pre>3</pre>

 

=={{header|EchoLisp}}==

(define a #(1 3 -5))

(define b #(4 -2 -1))

(lib 'math)

(dot-product a b) → 3

 

=={{header|Eiffel}}==

APPLICATION

 

end

end

 

Ouput:<pre>3</pre>

=={{header|Ela}}==

{{Trans|Haskell}}

 

dotp a b | length a == length b = sum (zipWith (*) a b)

| else = fail "Vector sizes must match."

 

{{out}}<pre>3</pre>

 

=={{header|Elena}}==

ELENA 5.0 :

import system'routines;

{

console.printLine(new int[]{1, 3, -5}.dotProduct(new int[]{4, -2, -1}))

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def dot_product(a,b) when length(a)==length(b), do: dot_product(a,b,0)

def dot_product(_,_) do

end

 

 

{{out}}

</pre>

 

 

</pre>

 

=={{header|Erlang}}==

dotProduct(_,_) -> erlang:error('Vectors must have the same length.').

 

dotProduct([],[],P) -> P.

 

{{out}}<pre>3</pre>

 

=={{header|Euphoria}}==

atom sum

a *= b

end function

 

{{out}}

<pre>3</pre>

-- using the standard Euphoria Version 4+ Math Library

include std/math.e

sequence a = {1,3,-5}, b = {4,-2,-1} -- Make them any length you want

{{out}}<pre>3</pre>

 

=={{header|F_Sharp|F#}}==

if Array.length a <> Array.length b then failwith "invalid argument: vectors must have the same lengths"

<pre>&gt; dot_product [| 1; 3; -5 |] [| 4; -2; -1 |] ;;

val it : int = 3</pre>

=={{header|Factor}}==

The built-in word <code>v.</code> is used to compute the dot product. It doesn't enforce that the vectors are of the same length, so here's a wrapper.

 

: dot-product ( u v -- w )

2dup [ length ] bi@ =

 

( scratchpad ) { 1 3 -5 } { 4 -2 -1 } dot-product .

 

=={{header|FALSE}}==

3d: {Vectors' length}

 

=={{header|Fantom}}==

Dot product of lists of Int:

{

static Int dotProduct (Int[] a, Int[] b)

echo ("Dot product of $x and $y is ${dotProduct(x, y)}")

}

 

=={{header|Forth}}==

: th cells + ;

 

-1 -2 4 b /vector vector!

 

 

=={{header|Fortran}}==

 

 

write (*, '(i0)') dot_product ([1, 3, -5], [4, -2, -1])

 

{{out}}<pre>3</pre>

 

 

=={{header|Frink}}==

{

if length[v1] != length[v2]

return sum[map[{|c1,c2| c1 * c2}, zip[v1, v2]]]

 

=={{header|FunL}}==

 

def dot( a, b )

| otherwise = error( "Vector sizes must match" )

 

{{out}}<pre>3</pre>

 

=={{header|FreeBASIC}}==

 

function dot( a() as double, b() as double ) as double

print " zero3d dot x = ", dot(zero3d(), x())

print " z dot z = ", dot(z(), z())

{{out}}

<pre>

z dot z = 1

y dot z = 0</pre>

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|GAP}}==

 

[1, 3, -5]*[4, -2, -1];

 

=={{header|GLSL}}==

The dot product is built-in:

float dot_product = dot(vec3(1, 3, -5), vec3(4, -2, -1));

 

=={{header|Go}}==

===Implementation===

 

import (

}

fmt.Println(d)

{{out}}

<pre>

</pre>

===Library gonum/floats===

 

import (

func main() {

fmt.Println(floats.Dot(v1, v2))

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

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

[x, y].transpose().collect{ xx, yy -> xx * yy }.sum()

Test:

{{out}}<pre>3</pre>

 

=={{header|Haskell}}==

 

dotp a b | length a == length b = sum (zipWith (*) a b)

| otherwise = error "Vector sizes must match"

 

Or, using the Maybe monad to avoid exceptions and keep things composable:

| otherwise = Nothing

 

 

 

=={{header|Hoon}}==

=| sum=@sd

|-

?: |(?=(~ a) ?=(~ b)) sum

 

=={{header|Hy}}==

(assert (= (len a) (len b)))

(sum (genexpr (* aterm bterm)

[(, aterm bterm) (zip a b)])))

 

 

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

The procedure below computes the dot product of two vectors of arbitrary length or generates a run time error if its arguments are the wrong type or shape.

write("a dot b := ",dotproduct([1, 3, -5],[4, -2, -1]))

end

every (dp := 0) +:= a[i := 1 to *a] * b[i]

return dp

 

=={{header|IDL}}==

a = [1, 3, -5]

b = [4, -2, -1]

c = a#TRANSPOSE(b)

c = TOTAL(a*b,/PRESERVE_TYPE)

 

=={{header|Idris}}==

 

import Data.Vect

main : IO ()

main = printLn $ dotProduct [1,2,3] [1,2,3]

 

=={{header|J}}==

3

dotp=: +/ . * NB. Or defined as a verb (function)

1 3 _5 dotp 4 _2 _1

Note also: The verbs built using the conjunction <code> .</code> generally apply to matricies and arrays of higher dimensions and can be built with verbs (functions) other than sum ( <code>+/</code> ) and product ( <code>*</code> ).

 

Spelling issue: The conjunction <code> .</code> needs to be preceded by a space. This is because J's spelling rules say that if the character '.' is preceded by any other character, it is included in the same parser token that included that other character. In other words, <code>1.23e4</code>, <code>'...'</code> and <code>/.</code> are each examples of "parser tokens".

 

=={{header|Java}}==

public static void main(String[] args) {

return sum;

}

{{out}}<pre>3.0</pre>

 

=={{header|JavaScript}}==

===ES5===

if (ary1.length != ary2.length)

throw "can't find dot product: arrays have different lengths";

 

print(dot_product([1,3,-5],[4,-2,-1])); // ==> 3

 

We could also use map and reduce in lieu of iteration,

 

function dotp_sum(a,b) { return a + b; }

function dotp_times(a,i) { return x[i] * y[i]; }

 

dotp([1,3,-5],[4,-2,-1]); // ==> 3

 

===ES6===

 

 

 

 

 

 

 

=={{header|jq}}==

The dot-product of two arrays, x and y, can be computed using dot(x;y) defined as follows:

def dot(x; y):

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

 

Suppose however that we are given an array of objects, each of which has an "x" field and a "y" field,

values in the "x" and "y" fields respectively.

 

Given the array of objects as input, the dot-product is then simply <code>SIGMA( .x * .y )</code>.

 

 

[ {"x": 1, "y": 4}, {"x": 3, "y": -2}, {"x": -5, "y": -1} ]

 

=={{header|Jsish}}==

From Javascript ES5 imperative entry.

function dot_product(ary1, ary2) {

if (ary1.length != ary2.length) throw "can't find dot product: arrays have different lengths";

PASS!: err = can't find dot product: arrays have different lengths

=!EXPECTEND!=

 

{{out}}

=={{header|Julia}}==

Dot products and many other linear-algebra functions are built-in functions in Julia (and are largely implemented by calling functions from [[wp:LAPACK|LAPACK]]).

y = [4, -2, -1]

z = dot(x, y)

 

=={{header|K}}==

3

 

1 3 -5 _dot 4 -2 -1

 

=={{header|Klingphix}}==

%c %i

( ) !c

pstack

 

 

=={{header|Kotlin}}==

{{works with|Kotlin|1.0+}}

v1.zip(v2).map { it.first * it.second }.reduce { a, b -> a + b }

 

fun main(args: Array<String>) {

dot(arrayOf(1.0, 3.0, -5.0), arrayOf(4.0, -2.0, -1.0)).let { println(it) }

{{out}}

<pre>3.0</pre>

 

=={{header|Lambdatalk}}==

{def dotp

{def dotp.r

{dotp {A.new 1 3 -5} {A.new 4 -2 -1}}

-> 3

 

=={{header|LFE}}==

(: lists foldl #'+/2 0

(: lists zipwith #'*/2 a b)))

 

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

vectorB$ = "4, -2, -1"

print "DotProduct of ";vectorA$;" and "; vectorB$;" is ";

i = i+1

wend

 

=={{header|LLVM}}==

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) #1

 

{{out}}

<pre>3</pre>

 

=={{header|Logo}}==

output apply "sum (map "product :a :b)

end

 

 

=={{header|Logtalk}}==

dot_product(A, B, 0, Sum).

 

dot_product([A| As], [B| Bs], Acc, Sum) :-

Acc2 is Acc + A*B,

 

=={{header|Lua}}==

local ret = 0

for i = 1, #a do

end

 

 

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

Module dot_product {

A=(1,3,-5)

if len(a)<>len(b) Then Error "not same length"

if len(a)=0 then Error "empty vectors"

While a1, b1 {sum+=array(a1)*array(b1)}

=sum

}

}

Module dot_product

 

=={{header|Maple}}==

Between Arrays, Vectors, or Matrices you can use the dot operator:

 

Between any of the above or lists, you can use the <code>LinearAlgebra[DotProduct]</code> function:

 

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

 

=={{header|MATLAB}}==

The dot product operation is a built-in function that operates on vectors of arbitrary length.

B = [4 -2 -1]

For the Octave implimentation:

C = sum( A.*B );

 

=={{header|Maxima}}==

 

=={{header|Mercury}}==

This will cause a software_error/1 exception if the lists are of different lengths.

:- interface.

 

 

dot_product(As, Bs) =

 

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

 

''Input'': В/О x₁ С/П x₂ С/П y₁ С/П y₂ С/П ...

 

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

FROM RealStr IMPORT RealToStr;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|MUMPS}}==

;Returns the dot product of two vectors. Vectors are assumed to be stored as caret-delimited strings of numbers.

;If the vectors are not of equal length, a null string is returned.

FOR I=1:1:$LENGTH(A,"^") SET SUM=SUM+($PIECE(A,"^",I)*$PIECE(B,"^",I))

KILL I

 

=={{header|Nemerle}}==

This will cause an exception if the arrays are different lengths.

using System.Console;

using Nemerle.Collections.NCollectionsExtensions;

WriteLine(DotProduct(arr1, arr2));

}

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

 

 

method dotProduct(vecs = double[,]) public constant returns double signals IllegalArgumentException

 

=={{header|newLISP}}==

(apply + (map * x y)))

 

 

=={{header|Nim}}==

# Runtime error when a and b are differently sized seqs

proc dotp[T](a,b: T): int =

 

echo dotp([1,3,-5], [4,-2,-1])

 

Another version which allows to mix arrays and sequences provided they have the same length. It works also with miscellaneous number types (integers, floats).

 

 

func dotProduct[T](a, b: openArray[T]): T =

echo dotProduct([1,3,-5], [4,-2,-1])

echo dotProduct(@[1,2,3],@[4,5,6])

 

=={{header|Oberon-2}}==

{{Works with|oo2c version 2}}

MODULE DotProduct;

IMPORT

Out.Int(DotProduct(x,y),0);Out.Ln

END DotProduct.

{{out}}

<pre>

 

=={{header|Objeck}}==

class DotProduct {

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

}

}

 

=={{header|Objective-C}}==

#import <stdint.h>

#import <stdlib.h>

}

return 0;

 

=={{header|OCaml}}==

With lists:

 

(*

# dot [1.0; 3.0; -5.0] [4.0; -2.0; -1.0];;

- : float = 3.

 

With arrays:

if Array.length v <> Array.length u

then invalid_arg "Different array lengths";

# dot [| 1.0; 3.0; -5.0 |] [| 4.0; -2.0; -1.0 |];;

- : float = 3.

 

=={{header|Octave}}==

See [[Dot product#MATLAB]] for an implementation. If we have a row-vector and a column-vector, we can use simply *.

b = [4, -2, -1] % or [4; -2; -1] and avoid transposition with '

 

=={{header|Oforth}}==

 

 

{{out}}

 

=={{header|Ol}}==

(define (dot-product a b)

(apply + (map * a b)))

(print (dot-product '(1 3 -5) '(4 -2 -1)))

; ==> 3

 

=={{header|Oz}}==

Vectors are represented as lists in this example.

fun {DotProduct Xs Ys}

{Length Xs} = {Length Ys} %% assert

end

in

 

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

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

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

{

my($vec_a, $vec_b) = @_;

my @vec_b = (4,-2,-1);

 

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

0 tolist var c

len for

sq_mul

sq_sum

 

=={{header|PHP}}==

function dot_product($v1, $v2) {

if (count($v1) != count($v2))

 

echo dot_product(array(1, 3, -5), array(4, -2, -1)), "\n";

 

=={{header|PicoLisp}}==

(sum * A B) )

 

{{out}}<pre>-> 3</pre>

 

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

begin;

declare (A(n), B(n)) float;

dot_product = sum(a*b);

put (dot_product);

 

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

Start up.

Make an example vector and another example vector.

Add 4 to the other example vector.

Add -2 to the other example vector.

{{out}}

<pre>

 

=={{header|PostScript}}==

/x exch def

/y exch def

-1 ==

}ifelse

 

=={{header|PowerShell}}==

function dotproduct( $a, $b) {

$a | foreach -Begin {$i = $res = 0} -Process { $res += $_*$b[$i++] } -End{$res}

dotproduct (1..2) (1..2)

dotproduct (1..10) (11..20)

<b>Output:</b>

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog.

maplist(mult, L1, L2, P),

sumlist(P, N).

 

mult(A,B,C) :-

Example :

<pre> ?- dot_product([1,3,-5], [4,-2,-1], N).

 

=={{header|PureBasic}}==

Protected i, sum, length = ArraySize(a())

 

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

CloseConsole()

 

=={{header|Python}}==

assert len(a) == len(b), 'Vector sizes must match'

return sum(aterm * bterm for aterm,bterm in zip(a, b))

if __name__ == '__main__':

a, b = [1, 3, -5], [4, -2, -1]

 

 

 

{{Works with|Python|3.7}}

 

from operator import (mul)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Dot product of other vectors with [1, 3, -5]:

[4, 2, -1] -> 15

[4, -2, -1] -> 3</pre>

 

=={{header|Quackery}}==

 

[ over i^ peek *

rot + swap ]

drop ] is .prod ( [ [ --> n )

 

 

{{Out}}

=={{header|R}}==

Here are several ways to do the task.

y <- c(4, -2, -1)

 

}

 

 

=={{header|Racket}}==

#lang racket

(define (dot-product l r) (for/sum ([x l] [y r]) (* x y)))

;; dot-product works on sequences such as vectors:

(dot-product #(1 2 3) #(4 5 6))

 

=={{header|Raku}}==

{{works with|Rakudo|2010.07}}

We use the square-bracket meta-operator to turn the infix operator <code>+</code> into a reducing list operator, and the guillemet meta-operator to vectorize the infix operator <code>*</code>. Length validation is automatic in this form.

 

=={{header|Rascal}}==

 

 

public int dotProduct(list[int] L, list[int] M){

throw "vector sizes must match";

}

 

===Alternative solution===

If a matrix is represented by a relation of <x-coordinate, y-coordinate, value>, then function below can be used to find the Dot product.

 

public real matrixDotproduct(rel[real x, real y, real v] column1, rel[real x, real y, real v] column2){

<1.0,0.0,-51.0>, <1.0,1.0,167.0>, <1.0,2.0,24.0>,

<2.0,0.0,4.0>, <2.0,1.0,-68.0>, <2.0,2.0,-41.0>

 

=={{header|REBOL}}==

 

 

a: [1 3 -5]

]

 

 

=={{header|REXX}}==

'''output''' &nbsp; using the default (internal) inputs:

<pre>

vector B = 4 -2 -1

 

 

=={{header|Ring}}==

aVector = [2, 3, 5]

bVector = [4, 2, 1]

next

return sum

 

=={{header|RLaB}}==

In its simplest form dot product is a composition of two functions: element-by-element

multiplication '.*' followed by sumation of an array. Consider an example:

y = rand(1,10);

Warning: element-by-element multiplication is matrix optimized. As the interpretation of the matrix

optimization is quite general, and unique to RLaB, any two matrices can be so multiplied irrespective

=={{header|RPL}}==

Being a language for a calculator, RPL makes this easy.

[ 1 3 -5 ]

[ 4 -2 -1 ]

DOT

 

=={{header|Ruby}}==

With the '''standard library''', require 'matrix' and call Vector#inner_product.

=> true

irb(main):002:0> Vector[1, 3, -5].inner_product Vector[4, -2, -1]

Or '''implement''' dot product.

def dot_product(other)

raise "not the same size!" if self.length != other.length

end

end

 

 

=={{header|Run BASIC}}==

v2$ = "4, -2, -1"

 

dotProduct = dotProduct + val(v1$) * val(v2$)

wend

 

=={{header|Rust}}==

Implemented as a simple function with check for equal length of vectors.

// but using slices is more general and rustic

fn dot_product(a: &[i32], b: &[i32]) -> Option<i32> {

 

println!("{}", dot_product(&v1, &v2).unwrap());

 

 

 

'''Uses an unstable feature.'''

use std::ops::{Add, Mul};

use std::num::Zero;

 

println!("{}", dot_product(&v1, &v2).unwrap());

 

=={{header|S-lang}}==

{{out}}

<pre>3.0</pre>

=={{header|Sather}}==

Built-in class VEC "implements" euclidean (geometric) vectors.

main is

x ::= #VEC(|1.0, 3.0, -5.0|);

#OUT + x.dot(y) + "\n";

end;

 

=={{header|Scala}}==

import n._ // import * operator

def dot(v2: Seq[T]) = {

val v2 = List(4, -2, -1)

println(v1 dot v2)

 

=={{header|Scheme}}==

{{Works with|Scheme|R<math>^5</math>RS}}

(apply + (map * a b)))

 

(display (dot-product '(1 3 -5) '(4 -2 -1)))

{{out}}<pre>3</pre>

 

=={{header|Scilab}}==

B = [4 -2 -1]

 

=={{header|Seed7}}==

 

$ syntax expr: .().dot.() is -> 6; # priority of dot operator

begin

writeln([](1, 3, -5) dot [](4, -2, -1));

 

=={{header|Sidef}}==

(a »*« b)«+»;

};

 

=={{header|Slate}}==

"Dot-product."

[

(0 below: (v size min: w size)) inject: 0 into:

[| :sum :index | sum + ((v at: index) * (w at: index))]

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

[

* anotherArray [

]

 

 

=={{header|SNOBOL4}}==

dotp i = 1; sum = 0

loop sum = sum + (a<i> * b<i>)

b = array(3); b<1> = 4; b<2> = -2; b<3> = -1;

output = dotp(a,b)

 

=={{header|SPARK}}==

 

The precondition enforces equality of the ranges of the two vectors.

--# inherit Spark_IO;

--# main_program;

Width => 6,

Base => 10);

{{out}}<pre> 3</pre>

 

 

Given two tables <code>A</code> and <code>B</code> where A has key columns <code>i</code> and <code>j</code> and B has key columns <code>j</code> and <code>k</code> and both have value columns <code>N</code>, the inner product of A and B would be:

from A inner join B on A.j=B.j

 

=={{header|Standard ML}}==

With lists:

 

(*

- dot ([1.0, 3.0, ~5.0], [4.0, ~2.0, ~1.0]);

val it = 3.0 : real

 

With vectors:

if Vector.length v <> Vector.length u then

raise ListPair.UnequalLengths

- dot (#[1.0, 3.0, ~5.0], #[4.0, ~2.0, ~1.0]);

val it = 3.0 : real

 

=={{header|Stata}}==

With row vectors:

 

matrix b=4,-2,-1

matrix c=a*b'

 

With column vectors:

 

matrix b=4\-2\-1

matrix c=a'*b

 

=== Mata ===

With row vectors:

 

b=4,-2,-1

 

With column vectors:

 

b=4\-2\-1

 

In both cases, one cas also write

 

 

=={{header|Swift}}==

{{works with|Swift|1.2+}}

return reduce(lazy(zip(v1, v2)).map(*), 0, +)

}

 

{{out}}

<pre>3.0</pre>

=={{header|Tcl}}==

{{tcllib|math::linearalgebra}}

 

set a {1 3 -5}

set dotp [::math::linearalgebra::dotproduct $a $b]

proc pp vec {return \[[join $vec ,]\]}

{{out}}<pre>[1,3,-5] ∙ [4,-2,-1] = 3.0</pre>

 

=={{header|TI-83 BASIC}}==

To perform a matrix dot product on TI-83, the trick is to use lists (and not to use matrices).

{{out}}

<pre>

3

</pre>

 

=={{header|Ursala}}==

A standard library function for dot products of floating point numbers exists, but a new one can be defined for integers as shown using the map operator (<code>*</code>) with the zip suffix (<code>p</code>) to construct a "zipwith" operator (<code>*p</code>), which operates on the integer <code>product</code> function. A catchable exception is thrown if the list lengths are unequal. This function is then composed (<code>+</code>) with a cumulative summation function, which is constructed from the binary <code>sum</code> function, and the reduction operator (<code>:-</code>) with <code>0</code> specified for the vacuous sum.

 

dot = sum:-0+ product*p

#cast %z

 

{{out}}<pre>3</pre>

 

=={{header|VBA}}==

dot_product = WorksheetFunction.SumProduct(x, y)

End Function

Public Sub main()

Debug.Print dot_product([{1,3,-5}], [{4,-2,-1}])

<pre> 3</pre>

 

=={{header|VBScript}}==

WScript.Echo DotProduct("1,3,-5","4,-2,-1")

 

Next

End Function

 

{{Out}}

=={{header|Visual Basic}}==

{{works with|Visual Basic|6}}

 

Function DotProduct(a() As Long, b() As Long) As Long

Debug.Assert Err.Description = "invalid input"

End Sub

 

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

{{trans|C#}}

 

Function DotProduct(a As Decimal(), b As Decimal()) As Decimal

End Sub

 

{{out}}

<pre>3</pre>

 

=={{header|Wart}}==

 

<code>+</code> is punned (overloaded) here; when applied to functions it denotes composition. Also, <code>(*)</code> is used to skip infix expansion.

 

=={{header|Wren}}==

construct new(a) {

if (a.type != List || a.count == 0 || !a.all { |i| i is Num }) {

var v2 = Vector.new([4, -2, -1])

 

 

{{out}}

<pre>

The dot product of [1, 3, -5] and [4, -2, -1] is 3.

</pre>

 

=={{header|X86 Assembly}}==

Using FASM. Targets x64 Microsoft Windows.

entry start

 

 

import msvcrt,\

Size mismatch; can't calculate.

 

=={{header|XPL0}}==

 

func DotProd(U, V, L);

[IntOut(0, DotProd([1, 3, -5], [4, -2, -1], 3));

CrLf(0);

{{out}}<pre>3</pre>

 

=={{header|Yabasic}}==

sub sq_mul(a(), b(), c())

local n, i

 

print sq_sum(c())

 

=={{header|zkl}}==

zipWith stops at the shortest of the lists

{{out}}<pre>dotp(T(1,3,-5),T(4,-2,-1,666)) //-->3</pre>

If exact length is a requirement

Utils.zipWith('*,a,b).sum()

 

=={{header|ZX Spectrum Basic}}==

20 DIM b(3): LET b(1)=4: LET b(2)=-2: LET b(3)=-1

30 LET sum=0

40 FOR i=1 TO 3: LET sum=sum+a(i)*b(i): NEXT i

[[Category:Geometry]]