Sum of squares: Difference between revisions
No edit summary |
Initial FB submission for Sum of squares |
||
(345 intermediate revisions by more than 100 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Arithmetic operations}} |
{{task|Arithmetic operations}} |
||
Write a program to find the sum of squares of a numeric vector. The program should work on a zero-length vector (with an answer of 0). |
|||
;Task: |
|||
Write a program to find the sum of squares of a numeric vector. |
|||
The program should work on a zero-length vector (with an answer of '''0'''). |
|||
;Related task: |
|||
* [[Mean]] |
|||
<br><br> |
|||
=={{header|0815}}== |
|||
<syntaxhighlight lang="0815"> |
|||
{x{*%<:d:~$<:1:~>><:2:~>><:3:~>><:4:~>><:5:~>><:6:~>><:7: |
|||
~>><:8:~>><:9:~>><:a:~>><:b:~>><:c:~>><:ffffffffffffffff: |
|||
~>{x{*>}:8f:{x{*&{=+>{~>&=x<:ffffffffffffffff:/#:8f:{{~% |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 |
|||
28A |
|||
</pre> |
|||
=={{header|11l}}== |
|||
<syntaxhighlight lang="11l">print(sum([1, 2, 3, 4, 5].map(x -> x^2)))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
55 |
|||
</pre> |
|||
=={{header|360 Assembly}}== |
|||
<syntaxhighlight lang="360asm">* Sum of squares 27/08/2015 |
|||
SUMOFSQR CSECT |
|||
USING SUMOFSQR,R12 |
|||
LR R12,R15 |
|||
LA R7,A a(1) |
|||
SR R6,R6 sum=0 |
|||
LA R3,1 i=1 |
|||
LOOPI CH R3,N do i=1 to hbound(a) |
|||
BH ELOOPI |
|||
L R5,0(R7) a(i) |
|||
M R4,0(R7) a(i)*a(i) |
|||
AR R6,R5 sum=sum+a(i)**2 |
|||
LA R7,4(R7) next a |
|||
LA R3,1(R3) i=i+1 |
|||
B LOOPI end i |
|||
ELOOPI XDECO R6,PG+23 edit sum |
|||
XPRNT PG,80 |
|||
XR R15,R15 |
|||
BR R14 |
|||
A DC F'1',F'2',F'3',F'4',F'5',F'6',F'7',F'8',F'9',F'10' |
|||
PG DC CL80'The sum of squares is: ' |
|||
N DC AL2((PG-A)/4) |
|||
YREGS |
|||
END SUMOFSQR</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
The sum of squares is: 385 |
|||
</pre> |
|||
=={{header|8086 Assembly}}== |
|||
<syntaxhighlight lang="asm"> ;;; Sum of squares |
|||
cpu 8086 |
|||
bits 16 |
|||
section .text |
|||
org 100h |
|||
jmp demo |
|||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|||
;;; Calculate the sum of the squares of the array in SI. |
|||
;;; The array should contain 16-bit unsigned integers. |
|||
;;; The output will be 32-bit. |
|||
;;; Input: (DS:)SI = array, CX = array length |
|||
;;; Output: DX:AX = sum of squares |
|||
;;; Registers used: AX,BX,CX,DX,SI,DI |
|||
sumsqr: xor bx,bx ; Keep accumulator in BX:DI. |
|||
xor di,di ; (So zero it out first) |
|||
and cx,cx ; Counter register 0? "Program should work |
|||
jz .done ; on a zero-length vector" |
|||
.loop: mov ax,[si] ; Grab value from array |
|||
mul ax ; Calculate square of value (into DX:AX) |
|||
add di,ax ; Add low 16 bits to accumulator |
|||
adc bx,dx ; Add high 16 bits, plus carry |
|||
inc si ; Point to next value |
|||
inc si |
|||
loop .loop ; Next value in array |
|||
.done: mov ax,di ; Return the value in DX:AX as is tradition |
|||
mov dx,bx |
|||
ret |
|||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|||
;;; Demo: use the subroutine to calculate the sum of squares |
|||
;;; in the included array, and show the result |
|||
demo: mov si,array |
|||
mov cx,arrlen |
|||
call sumsqr |
|||
;;; Print the return value in DX:AX as a decimal number |
|||
;;; (Note: max supported value 655359 - this is a limitation |
|||
;;; of this rudimentary output code, not of the sum of squares |
|||
;;; routine.) |
|||
mov di,outstr_end |
|||
mov cx,10 |
|||
.decloop: div cx |
|||
dec di |
|||
add dl,'0' |
|||
mov [di],dl |
|||
xor dx,dx |
|||
and ax,ax |
|||
jnz .decloop |
|||
mov dx,di |
|||
mov ah,9 |
|||
int 21h |
|||
ret |
|||
section .data |
|||
outstr: db '######' ; Placeholder for decimal output |
|||
outstr_end: db '$' |
|||
array: dw 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 |
|||
arrlen: equ ($-array)/2 ; length is in words</syntaxhighlight> |
|||
=={{header|ACL2}}== |
|||
<syntaxhighlight lang="lisp">(defun sum-of-squares (xs) |
|||
(if (endp xs) |
|||
0 |
|||
(+ (* (first xs) (first xs)) |
|||
(sum-of-squares (rest xs)))))</syntaxhighlight> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">CARD FUNC SumOfSqr(BYTE ARRAY a BYTE count) |
|||
BYTE i |
|||
CARD res |
|||
IF count=0 THEN |
|||
RETURN (0) |
|||
FI |
|||
res=0 |
|||
FOR i=0 TO count-1 |
|||
DO |
|||
res==+a(i)*a(i) |
|||
OD |
|||
RETURN (res) |
|||
PROC Test(BYTE ARRAY a BYTE count) |
|||
BYTE i |
|||
CARD res |
|||
res=SumOfSqr(a,count) |
|||
Print("[") |
|||
IF count>0 THEN |
|||
FOR i=0 to count-1 |
|||
DO |
|||
PrintB(a(i)) |
|||
IF i<count-1 THEN |
|||
Put(' ) |
|||
FI |
|||
OD |
|||
FI |
|||
PrintF("]->%U%E%E",res) |
|||
RETURN |
|||
PROC Main() |
|||
BYTE ARRAY a=[1 2 3 4 5] |
|||
BYTE ARRAY b=[10 20 30 40 50 60 70 80 90] |
|||
BYTE ARRAY c=[11] |
|||
Test(a,5) |
|||
Test(b,9) |
|||
Test(c,1) |
|||
Test(c,0) |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_squares.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
[1 2 3 4 5]->55 |
|||
[10 20 30 40 50 60 70 80 90]->28500 |
|||
[11]->121 |
|||
[]->0 |
|||
</pre> |
|||
=={{header|ActionScript}}== |
|||
<syntaxhighlight lang="actionscript">function sumOfSquares(vector:Vector.<Number>):Number |
|||
{ |
|||
var sum:Number = 0; |
|||
for(var i:uint = 0; i < vector.length; i++) |
|||
sum += vector[i]*vector[i]; |
|||
return sum; |
|||
}</syntaxhighlight> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO; |
||
procedure Test_Sum_Of_Squares is |
procedure Test_Sum_Of_Squares is |
||
Line 19: | Line 209: | ||
Put_Line (Float'Image (Sum_Of_Squares ((1..0 => 1.0)))); -- Empty array |
Put_Line (Float'Image (Sum_Of_Squares ((1..0 => 1.0)))); -- Empty array |
||
Put_Line (Float'Image (Sum_Of_Squares ((3.0, 1.0, 4.0, 1.0, 5.0, 9.0)))); |
Put_Line (Float'Image (Sum_Of_Squares ((3.0, 1.0, 4.0, 1.0, 5.0, 9.0)))); |
||
end Test_Sum_Of_Squares;</ |
end Test_Sum_Of_Squares;</syntaxhighlight> |
||
{{out}} |
|||
Sample output: |
|||
<pre> |
<pre> |
||
0.00000E+00 |
0.00000E+00 |
||
1.33000E+02 |
1.33000E+02 |
||
</pre> |
</pre> |
||
=={{header|Aime}}== |
|||
<syntaxhighlight lang="aime">real |
|||
squaredsum(list l) |
|||
{ |
|||
integer i; |
|||
real s; |
|||
s = 0; |
|||
i = -~l; |
|||
while (i) { |
|||
s += sq(l[i += 1]); |
|||
} |
|||
s; |
|||
} |
|||
integer |
|||
main(void) |
|||
{ |
|||
list l; |
|||
l = list(0, 1, 2, 3); |
|||
o_form("~\n", squaredsum(l)); |
|||
o_form("~\n", squaredsum(list())); |
|||
o_form("~\n", squaredsum(list(.5, -.5, 2))); |
|||
0; |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>14 |
|||
0 |
|||
4.5</pre> |
|||
=={{header|ALGOL 60}}== |
|||
{{works with|GNU Marst|Any - tested with release 2.7}} |
|||
Using [[Jensen's Device]]. |
|||
<syntaxhighlight lang="algol60"> |
|||
begin |
|||
integer i; |
|||
integer array A[ 1 : 5 ]; |
|||
real procedure sum (i, lo, hi, term); |
|||
value lo, hi; |
|||
integer i, lo, hi; |
|||
real term; |
|||
comment term is passed by-name, and so is i; |
|||
begin |
|||
real temp; |
|||
temp := 0; |
|||
for i := lo step 1 until hi do |
|||
temp := temp + term; |
|||
sum := temp |
|||
end; |
|||
comment initialie A; |
|||
for i := 1 step 1 until 5 do A[i] := i; |
|||
comment note the correspondence between the mathematical notation and the call to sum; |
|||
outreal(1, sum (i, 1, 5, A[i] * A[i])) |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
{{works with|ALGOL 68|Revision 1 - no extensions to language used}} |
|||
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}} |
|||
{{works 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]}} |
|||
The computation can be written as a loop. |
The computation can be written as a loop. |
||
<syntaxhighlight lang="algol68">PROC sum of squares = ([]REAL argv)REAL:( |
|||
main1:( |
|||
REAL sum := 0; |
|||
FOR i FROM LWB argv TO UPB argv DO |
|||
sum +:= argv[i]**2 |
|||
FOR i FROM LWB argv TO UPB argv DO |
|||
OD; |
|||
sum +:= argv[i]**2 |
|||
sum |
|||
); |
|||
sum |
|||
test:( |
|||
); |
|||
printf(($g(0)l$,sum of squares([]REAL(3, 1, 4, 1, 5, 9)))); |
|||
)</syntaxhighlight> |
|||
printf(($xg(0)l$,sum of squares([]REAL(3, 1, 4, 1, 5, 9)))); |
|||
{{out}} |
|||
) |
|||
<pre> |
|||
Output: |
|||
133 |
|||
</pre> |
|||
Another implementation could define a procedure (PROC) or operator (OP) called map. |
|||
Another implementation could define a procedure ('''proc''') or operator ('''op''') called '''map'''. |
|||
main2:( |
|||
[]REAL data = (3, 1, 4, 1, 5, 9); |
|||
{{trans|python}} |
|||
<syntaxhighlight lang="algol68">[]REAL data = (3, 1, 4, 1, 5, 9); |
|||
PROC map = ( PROC(REAL)REAL func, []REAL argv)REAL: |
|||
( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out); |
|||
PROC map = ( PROC(REAL)REAL func, []REAL argv)REAL: |
|||
( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out); |
|||
REAL sum := 0; |
|||
printf(($xg(0)l$, map ( ((REAL argv)REAL: sum +:= argv ** 2), data) )); |
|||
test:( |
|||
REAL sum := 0; |
|||
PRIO MAP = 5; # the same priority as the operators <, =<, >=, & > maybe... # |
|||
printf(($xg(0)l$, map ( ((REAL argv)REAL: sum +:= argv ** 2), data) )); |
|||
( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out); |
|||
PRIO MAP = 5; # the same priority as the operators <, =<, >=, & > maybe... # |
|||
OP MAP = ( PROC(REAL)REAL func, []REAL argv)REAL: |
|||
sum := 0; |
|||
( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out); |
|||
) |
|||
sum := 0; |
|||
Output: |
|||
printf(($g(0)l$, ((REAL argv)REAL: sum +:= argv ** 2) MAP data )) |
|||
133 |
|||
)</syntaxhighlight> |
|||
133 |
|||
{{out}} |
|||
<pre> |
|||
133 |
|||
133 |
|||
</pre> |
|||
{{works with|ALGOL 68|Revision 1 - requires the Currying extension}} |
|||
{{works with|ALGOL 68G|Any - tested with release a68g-2.8.3}} |
|||
{{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]}} |
|||
The computation can be written as a generator. |
|||
<syntaxhighlight lang="algol68">#!/usr/bin/a68g --script # |
|||
# -*- coding: utf-8 -*- # |
|||
MODE YIELDREAL = PROC(REAL)VOID; |
|||
MODE GENREAL = PROC(YIELDREAL)VOID; |
|||
PROC gen real of vector = ([]REAL data, YIELDREAL yield)VOID: |
|||
FOR i FROM LWB data TO UPB data DO yield(data[i]) OD; |
|||
PROC real sum sq of gen = (GENREAL gen real)REAL: ( |
|||
REAL sum:=0; |
|||
# FOR REAL value IN # gen real(#) DO (# |
|||
(REAL value)VOID:( |
|||
sum+:=value**2 |
|||
# OD #)); |
|||
sum |
|||
); |
|||
PROC real sum map of gen = (PROC(REAL)REAL func, GENREAL gen real)REAL: ( |
|||
REAL sum:=0; |
|||
# FOR REAL value IN # gen real(#) DO (# |
|||
(REAL value)VOID:( |
|||
sum+:=func(value) |
|||
# OD #)); |
|||
sum |
|||
); |
|||
OP GEN = ([]REAL array)GENREAL:gen real of vector(array,); |
|||
OP (GENREAL #gen real#)REAL SUMSQ = real sum sq of gen; |
|||
PRIO SUMMAP = 5; |
|||
OP (PROC(REAL)REAL #func#, GENREAL #gen real#)REAL SUMMAP = real sum map of gen; |
|||
test:( |
|||
[]REAL data = (3, 1, 4, 1, 5, 9); |
|||
# Permutations of the above routines # |
|||
printf(($"real sum sq GEN: "g(0)l$, real sum sq of gen(GEN data))); |
|||
printf(($"real sum sq real gen: "g(0)l$, real sum sq of gen(gen real of vector(data,)))); |
|||
printf(($"real sum map real gen: "g(0)l$, real sum map of gen(((REAL x)REAL: x*x),gen real of vector(data,)))); |
|||
printf(($"SUMSQ real gen: "g(0)l$, SUMSQ gen real of vector(data,))); |
|||
printf(($"SUMSQ GEN: "g(0)l$, SUMSQ GEN data)); |
|||
printf(($"sq SUMMAP GEN: "g(0)l$, ((REAL x)REAL: x*x)SUMMAP GEN data)) |
|||
)</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
real sum sq GEN: 133 |
|||
real sum sq real gen: 133 |
|||
real sum map real gen: 133 |
|||
SUMSQ real gen: 133 |
|||
SUMSQ GEN: 133 |
|||
sq SUMMAP GEN: 133 |
|||
</pre> |
|||
=={{header|ALGOL W}}== |
|||
===Using a dedicated "sum of squares" procedure=== |
|||
<syntaxhighlight lang="algolw">begin |
|||
% procedure to sum the squares of the elements of a vector. % |
|||
% the bounds of the vector must be passed in lb and ub % |
|||
real procedure sumSquares ( real array vector ( * ) |
|||
; integer value lb |
|||
; integer value ub |
|||
) ; |
|||
begin |
|||
real sum; |
|||
sum := 0; |
|||
for i := lb until ub do sum := sum + ( vector( i ) * vector( i ) ); |
|||
sum |
|||
end sumOfSquares ; |
|||
% test the sumSquares procedure % |
|||
real array numbers ( 1 :: 5 ); |
|||
for i := 1 until 5 do numbers( i ) := i; |
|||
r_format := "A"; r_w := 10; r_d := 1; % set fixed point output % |
|||
write( sumSquares( numbers, 1, 5 ) ); |
|||
end.</syntaxhighlight> |
|||
===Using Jensen's device=== |
|||
{{Trans|ALGOL60}} |
|||
Using the classic [[Jensen's Device]] (first introduced in Algol 60) we can use a generic summation procedure, as in this sample: |
|||
<syntaxhighlight lang="algolw"> |
|||
begin % sum the squares of the elements of a vector, using Jensen's Device % |
|||
integer i; |
|||
real procedure sum ( integer %name% i; integer value lo, hi; real procedure term ); |
|||
% i is passed by-name, term is passed as a procedure which makes it effectively passed by-name % |
|||
begin |
|||
real temp; |
|||
temp := 0; |
|||
i := lo; |
|||
while i <= hi do begin % The Algol W "for" loop (as in Algol 68) creates a distinct % |
|||
temp := temp + term; % variable which would not be shared with the passed "i" % |
|||
i := i + 1 % Here the actual passed "i" is incremented. % |
|||
end while_i_le_temp; |
|||
temp |
|||
end; |
|||
real array A ( 1 :: 5 ); |
|||
for i := 1 until 5 do A( i ) := i; |
|||
r_format := "A"; r_w := 10; r_d := 1; % set fixed point output % |
|||
write( sum( i, 1, 5, A( i ) * A( i ) ) ); |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|Alore}}== |
|||
<syntaxhighlight lang="alore">def sum_squares(a) |
|||
var sum = 0 |
|||
for i in a |
|||
sum = sum + i**2 |
|||
end |
|||
return sum |
|||
end |
|||
WriteLn(sum_squares([3,1,4,1,5,9])) |
|||
end</syntaxhighlight> |
|||
=={{header|APL}}== |
|||
<syntaxhighlight lang="apl"> square_sum←{+/⍵*2} |
|||
square_sum 1 2 3 4 5 |
|||
55 |
|||
square_sum ⍬ ⍝The empty vector |
|||
0</syntaxhighlight> |
|||
=={{header|AppleScript}}== |
|||
Two ways of composing a sumOfSquares function: |
|||
<syntaxhighlight lang="applescript">------ TWO APPROACHES – SUM OVER MAP, AND DIRECT FOLD ---- |
|||
-- sumOfSquares :: Num a => [a] -> a |
|||
on sumOfSquares(xs) |
|||
script squared |
|||
on |λ|(x) |
|||
x ^ 2 |
|||
end |λ| |
|||
end script |
|||
sum(map(squared, xs)) |
|||
end sumOfSquares |
|||
-- sumOfSquares2 :: Num a => [a] -> a |
|||
on sumOfSquares2(xs) |
|||
script plusSquare |
|||
on |λ|(a, x) |
|||
a + x ^ 2 |
|||
end |λ| |
|||
end script |
|||
foldl(plusSquare, 0, xs) |
|||
end sumOfSquares2 |
|||
--------------------------- TEST ------------------------- |
|||
on run |
|||
set xs to [3, 1, 4, 1, 5, 9] |
|||
{sumOfSquares(xs), sumOfSquares2(xs)} |
|||
-- {133.0, 133.0} |
|||
end run |
|||
-------------------- GENERIC FUNCTIONS ------------------- |
|||
-- foldl :: (a -> b -> a) -> a -> [b] -> a |
|||
on foldl(f, startValue, xs) |
|||
tell mReturn(f) |
|||
set v to startValue |
|||
set lng to length of xs |
|||
repeat with i from 1 to lng |
|||
set v to |λ|(v, item i of xs, i, xs) |
|||
end repeat |
|||
return v |
|||
end tell |
|||
end foldl |
|||
-- map :: (a -> b) -> [a] -> [b] |
|||
on map(f, xs) |
|||
tell mReturn(f) |
|||
set lng to length of xs |
|||
set lst to {} |
|||
repeat with i from 1 to lng |
|||
set end of lst to |λ|(item i of xs, i, xs) |
|||
end repeat |
|||
return lst |
|||
end tell |
|||
end map |
|||
-- Lift 2nd class handler function into 1st class script wrapper |
|||
-- mReturn :: Handler -> Script |
|||
on mReturn(f) |
|||
if class of f is script then |
|||
f |
|||
else |
|||
script |
|||
property |λ| : f |
|||
end script |
|||
end if |
|||
end mReturn |
|||
-- sum :: Num a => [a] -> a |
|||
on sum(xs) |
|||
script add |
|||
on |λ|(a, b) |
|||
a + b |
|||
end |λ| |
|||
end script |
|||
foldl(add, 0, xs) |
|||
end sum</syntaxhighlight> |
|||
{{Out}} |
|||
<syntaxhighlight lang="applescript">{133.0, 133.0}</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">arr: 1..10 |
|||
print sum map arr [x][x^2]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>385</pre> |
|||
=={{header|Astro}}== |
|||
<syntaxhighlight lang="python">sum([1, 2, 3, 4]²)</syntaxhighlight> |
|||
=={{header|Asymptote}}== |
|||
<syntaxhighlight lang="asymptote">int suma; |
|||
int[] a={1, 2, 3, 4, 5, 6}; |
|||
for(var i : a) |
|||
suma = suma + a[i] ^ 2; |
|||
write("The sum of squares is: ", suma);</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
|||
<syntaxhighlight lang="autohotkey">list = 3 1 4 1 5 9 |
|||
Loop, Parse, list, %A_Space% |
|||
sum += A_LoopField**2 |
|||
MsgBox,% sum</syntaxhighlight> |
|||
=={{header|AWK}}== |
|||
Vectors are read, space-separated, from stdin; sum of squares goes to stdout. The empty line produces 0. |
|||
<syntaxhighlight lang="awk">$ awk '{s=0;for(i=1;i<=NF;i++)s+=$i*$i;print s}' |
|||
3 1 4 1 5 9 |
|||
133 |
|||
0</syntaxhighlight> |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
{{works with| |
{{works with|QBasic}} |
||
Assume the numbers are in |
Assume the numbers are in an array called <code>a</code>. |
||
<syntaxhighlight lang="qbasic">sum = 0 |
|||
sum = 0 |
|||
FOR I = LBOUND(a) TO UBOUND(a) |
|||
sum = sum + a(I) ^ 2 |
|||
NEXT I |
|||
PRINT "The sum of squares is: " + sum</syntaxhighlight> |
|||
==={{header|BaCon}}=== |
|||
<syntaxhighlight lang="freebasic">' Sum of squares |
|||
FUNCTION ss(int arr[], NUMBER elem) |
|||
sum = 0 |
|||
FOR i = 0 TO elem - 1 |
|||
sum = sum + POW(arr[i], 2) |
|||
NEXT |
|||
RETURN sum |
|||
END FUNCTION |
|||
' 1 to 10 in the test vector, or 1 to -s n |
|||
option = CMDLINE("s:") |
|||
IF option = ASC("s") THEN |
|||
elem = VAL(ARGUMENT$) |
|||
ELSE |
|||
elem = 10 |
|||
END IF |
|||
DECLARE vector TYPE int ARRAY elem |
|||
FOR i = 0 TO elem - 1 |
|||
vector[i] = i + 1 |
|||
NEXT |
|||
PRINT ss(vector, elem)</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ ./sumsquares |
|||
385 |
|||
prompt$ ./sumsquares -s 1000 |
|||
333833500</pre> |
|||
==={{header|BASIC256}}=== |
|||
<syntaxhighlight lang="basic256">arraybase 1 |
|||
dim a(6) |
|||
a[1] = 1.0 |
|||
a[2] = 2.0 |
|||
a[3] = 3.0 |
|||
a[4] = -1.0 |
|||
a[5] = -2.0 |
|||
a[6] = -3.0 |
|||
sum = 0 |
|||
for i = 1 to a[?] |
|||
sum += a[i] ^ 2 |
|||
next i |
|||
print "The sum of squares is: "; sum |
|||
end</syntaxhighlight> |
|||
==={{header|BBC BASIC}}=== |
|||
BBC BASIC cannot have a zero-length array. |
|||
<syntaxhighlight lang="bbcbasic"> DIM vector(5) |
|||
vector() = 1, 2, 3, 4, 5, 6 |
|||
PRINT "Sum of squares = " ; MOD(vector()) ^ 2</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Sum of squares = 91</pre> |
|||
==={{header|IS-BASIC}}=== |
|||
<syntaxhighlight lang="is-basic">100 INPUT PROMPT "Number of elements: ":N |
|||
110 NUMERIC A(1 TO N) |
|||
120 FOR I=1 TO N |
|||
130 PRINT I;:INPUT PROMPT ". = ":A(I) |
|||
140 NEXT |
|||
150 PRINT "The sum of squares is:";SQ(A) |
|||
160 DEF SQ(REF T) |
|||
170 LET S=0 |
|||
180 FOR I=LBOUND(T) TO UBOUND(T) |
|||
190 LET S=S+T(I)^2 |
|||
200 NEXT |
|||
210 LET SQ=S |
|||
220 END DEF</syntaxhighlight> |
|||
==={{header|Yabasic}}=== |
|||
<syntaxhighlight lang="yabasic">data 1.0, 2.0, 3.0, -1.0, -2.0, -3.0 |
|||
dim a(5) |
|||
sum = 0 |
|||
for i = 0 to arraysize(a(), 1) |
|||
read a(i) |
|||
sum = sum + a(i) ^ 2 |
|||
next i |
|||
print "The sum of squares is: ", sum |
|||
end</syntaxhighlight> |
|||
=={{header|bc}}== |
|||
<syntaxhighlight lang="bc">define s(a[], n) { |
|||
auto i, s |
|||
for (i = 0; i < n; i++) { |
|||
s += a[i] * a[i] |
|||
} |
|||
return(s) |
|||
}</syntaxhighlight> |
|||
=={{header|BCPL}}== |
|||
<syntaxhighlight lang="bcpl">get "libhdr" |
|||
let sumsquares(v, len) = |
|||
len=0 -> 0, |
|||
!v * !v + sumsquares(v+1, len-1) |
|||
let start() be |
|||
$( let vector = table 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 |
|||
writef("%N*N", sumsquares(vector, 10)) |
|||
$)</syntaxhighlight> |
|||
{{out}} |
|||
<pre>385</pre> |
|||
=={{header|BQN}}== |
|||
Similar to the BQN entry in [[Sum of a series]]. |
|||
<syntaxhighlight lang="bqn">SSq ← +´√⁼ |
|||
•Show SSq 1‿2‿3‿4‿5 |
|||
•Show SSq ⟨⟩</syntaxhighlight> |
|||
<syntaxhighlight lang="text">55 |
|||
0</syntaxhighlight> |
|||
=={{header|Bracmat}}== |
|||
<syntaxhighlight lang="bracmat">( ( sumOfSquares |
|||
= sum component |
|||
. 0:?sum |
|||
& whl |
|||
' ( !arg:%?component ?arg |
|||
& !component^2+!sum:?sum |
|||
) |
|||
& !sum |
|||
) |
|||
& out$(sumOfSquares$(3 4)) |
|||
& out$(sumOfSquares$(3 4 i*5)) |
|||
& out$(sumOfSquares$(a b c)) |
|||
);</syntaxhighlight> |
|||
{{out}} |
|||
<pre>25 |
|||
0 |
|||
a^2+b^2+c^2</pre> |
|||
=={{header|Brat}}== |
|||
<syntaxhighlight lang="brat">p 1.to(10).reduce 0 { res, n | res = res + n ^ 2 } #Prints 385</syntaxhighlight> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
<c>#include <stdio.h> |
<syntaxhighlight lang="c">#include <stdio.h> |
||
double squaredsum(double *l, int e) |
double squaredsum(double *l, int e) |
||
Line 89: | Line 749: | ||
printf("%lf\n", squaredsum(NULL, 0)); |
printf("%lf\n", squaredsum(NULL, 0)); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C sharp|C#}}== |
|||
<syntaxhighlight lang="csharp">using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
class Program |
|||
{ |
|||
static int SumOfSquares(IEnumerable<int> list) |
|||
{ |
|||
return list.Sum(x => x * x); |
|||
} |
|||
static void Main(string[] args) |
|||
{ |
|||
Console.WriteLine(SumOfSquares(new int[] { 4, 8, 15, 16, 23, 42 })); // 2854 |
|||
Console.WriteLine(SumOfSquares(new int[] { 1, 2, 3, 4, 5 })); // 55 |
|||
Console.WriteLine(SumOfSquares(new int[] { })); // 0 |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|C++}}== |
=={{header|C++}}== |
||
===Using accumulate=== |
|||
<cpp>#include <iostream> |
|||
#include < |
<syntaxhighlight lang="cpp">#include <iostream> |
||
#include <numeric> |
|||
#include <vector> |
#include <vector> |
||
Line 117: | Line 798: | ||
std::cout << vec_add_squares(v) << std::endl; |
std::cout << vec_add_squares(v) << std::endl; |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
===Using inner_product=== |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
#include <numeric> |
|||
#include <vector> |
|||
int main() |
|||
{ |
|||
// first, show that for empty vectors we indeed get 0 |
|||
std::vector<double> v; // empty |
|||
std::cout << std::inner_product(begin(v), end(v), begin(v), 0.0) << std::endl; |
|||
// now, use some values |
|||
double data[] = { 0, 1, 3, 1.5, 42, 0.1, -4 }; |
|||
v.assign(data, data+7); |
|||
std::cout << std::inner_product(begin(v), end(v), begin(v), 0.0) << std::endl; |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
===Using Boost.Lambda=== |
|||
{{libheader|Boost.Lambda}} |
|||
<syntaxhighlight lang="cpp">#include <numeric> |
|||
#include <vector> |
|||
#include "boost/lambda/lambda.hpp" |
|||
double vec_add_squares(std::vector<double>& v) |
|||
{ |
|||
using namespace boost::lambda; |
|||
return std::accumulate(v.begin(), v.end(), 0.0, _1 + _2 * _2); |
|||
}</syntaxhighlight> |
|||
=={{header|Chef}}== |
|||
<syntaxhighlight lang="chef">Sum of squares. |
|||
First input is length of vector, then rest of input is vector. |
|||
Ingredients. |
|||
1 g eggs |
|||
0 g bacon |
|||
Method. |
|||
Put bacon into the 1st mixing bowl. |
|||
Take eggs from refrigerator. |
|||
Square the eggs. |
|||
Take bacon from refrigerator. |
|||
Put bacon into 2nd mixing bowl. |
|||
Combine bacon into 2nd mixing bowl. |
|||
Fold bacon into 2nd mixing bowl. |
|||
Add the bacon into the 1st mixing bowl. |
|||
Ask the eggs until squared. |
|||
Pour contents of the 1st mixing bowl into the 1st baking dish. |
|||
Serves 1. |
|||
</syntaxhighlight> |
|||
=={{header|Clojure}}== |
|||
<syntaxhighlight lang="clojure">(defn sum-of-squares [v] |
|||
(reduce #(+ %1 (* %2 %2)) 0 v))</syntaxhighlight> |
|||
=={{header|CLU}}== |
|||
<syntaxhighlight lang="clu">sum_squares = proc (ns: sequence[int]) returns (int) |
|||
sum: int := 0 |
|||
for n: int in sequence[int]$elements(ns) do |
|||
sum := sum + n ** 2 |
|||
end |
|||
return(sum) |
|||
end sum_squares |
|||
start_up = proc () |
|||
po: stream := stream$primary_output() |
|||
stream$putl(po, int$unparse(sum_squares(sequence[int]$[]))) |
|||
stream$putl(po, int$unparse(sum_squares(sequence[int]$[1,2,3,4,5]))) |
|||
stream$putl(po, int$unparse(sum_squares(sequence[int]$[42]))) |
|||
end start_up</syntaxhighlight> |
|||
{{out}} |
|||
<pre>0 |
|||
55 |
|||
1764</pre> |
|||
=={{header|CoffeeScript}}== |
|||
<syntaxhighlight lang="coffeescript"> |
|||
sumOfSquares = ( list ) -> |
|||
list.reduce (( sum, x ) -> sum + ( x * x )), 0 |
|||
</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
<syntaxhighlight lang="lisp">(defun sum-of-squares (vector) |
|||
(loop for x across vector sum (expt x 2)))</syntaxhighlight> |
|||
Or in a functional way: |
|||
<syntaxhighlight lang="lisp">(defun sum-of-squares (vec) |
|||
(reduce #'+ (map 'vector (lambda (x) (* x x)) vec)))</syntaxhighlight> |
|||
=={{header|Cowgol}}== |
|||
<syntaxhighlight lang="cowgol">include "cowgol.coh"; |
|||
include "argv.coh"; |
|||
# Sum of squares |
|||
sub sumsquare(vec: [int32], len: intptr): (out: uint32) is |
|||
out := 0; |
|||
while len > 0 loop |
|||
var cur := [vec]; |
|||
# make positive first so we can use extra range of uint32 |
|||
if cur < 0 then cur := -cur; end if; |
|||
out := out + cur as uint32 * cur as uint32; |
|||
vec := @next vec; |
|||
len := len - 1; |
|||
end loop; |
|||
end sub; |
|||
# Read array from command line, allowing empty line (giving 0) |
|||
var nums: int32[128]; |
|||
var len: @indexof nums := 0; |
|||
ArgvInit(); |
|||
loop |
|||
var argmt := ArgvNext(); # read number |
|||
if argmt == (0 as [uint8]) then |
|||
break; # stop when no more numbers |
|||
end if; |
|||
var dummy: [uint8]; |
|||
(nums[len], dummy) := AToI(argmt); |
|||
len := len + 1; |
|||
end loop; |
|||
# Print sum of squares of numbers |
|||
print_i32(sumsquare(&nums[0], len as intptr)); |
|||
print_nl();</syntaxhighlight> |
|||
{{out}} |
|||
<pre>$ ./sumsq.386 |
|||
0 |
|||
$ ./sumsq.386 {1..30} |
|||
9455 |
|||
$ ./sumsq.386 512 |
|||
262144</pre> |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight lang="ruby"> |
|||
def sum_squares(a) |
|||
a.map{|e| e*e}.sum() |
|||
end |
|||
puts sum_squares([1, 2, 3]) |
|||
# => 14 |
|||
</syntaxhighlight> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
===Iterative Version=== |
|||
<d>module sumsquare ; |
|||
<syntaxhighlight lang="d">T sumSquares(T)(T[] a) pure nothrow @safe @nogc { |
|||
import std.stdio ; |
|||
T sum = 0; |
|||
foreach (e; a) |
|||
sum += e ^^ 2; |
|||
return sum; |
|||
} |
|||
void main() { |
|||
import std.stdio: writeln; |
|||
foreach(e ; a) |
|||
[3.1, 1.0, 4.0, 1.0, 5.0, 9.0].sumSquares.writeln; |
|||
sum += e*e ; |
|||
}</syntaxhighlight> |
|||
return sum ; |
|||
{{out}} |
|||
<pre>133.61</pre> |
|||
===Polymorphic Functional Style=== |
|||
<syntaxhighlight lang="d">import std.stdio, std.algorithm, std.traits, std.range; |
|||
auto sumSquares(Range)(Range data) pure nothrow @safe @nogc { |
|||
return reduce!q{a + b ^^ 2}(ForeachType!Range(0), data); |
|||
} |
} |
||
void main() { |
void main() { |
||
immutable items = [3.1, 1.0, 4.0, 1.0, 5.0, 9.0]; |
|||
items.sumSquares.writeln; |
|||
writefln(arr) ; |
|||
10.iota.sumSquares.writeln; |
|||
writefln(arr.sumsq()) ; |
|||
}</ |
}</syntaxhighlight> |
||
{{out}} |
|||
<strong style="font-size:135%;">Functional style</strong><br> |
|||
<pre>133.61 |
|||
{{works with|D|2.011}} |
|||
285</pre> |
|||
See [http://www.digitalmars.com/d/2.0/phobos/std_algorithm.html std.algorithm] |
|||
<d>import std.algorithm ; |
|||
=={{header|Dart}}== |
|||
T sumsq(T)(inout T[] a) { |
|||
===Iterative Version=== |
|||
return reduce!("a+b")(cast(T)0, map!("a*a")(a)) ; |
|||
<syntaxhighlight lang="d">sumOfSquares(list) { |
|||
}</d> |
|||
var sum=0; |
|||
list.forEach((var n) { sum+=(n*n); }); |
|||
return sum; |
|||
} |
|||
main() { |
|||
print(sumOfSquares([])); |
|||
print(sumOfSquares([1,2,3])); |
|||
print(sumOfSquares([10])); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>0 |
|||
14 |
|||
100</pre> |
|||
===Functional Style Version=== |
|||
<syntaxhighlight lang="d">num sumOfSquares(List<num> l) => l.map((num x)=>x*x) |
|||
.fold(0, (num p,num n)=> p + n); |
|||
void main(){ |
|||
print(sumOfSquares([])); |
|||
print(sumOfSquares([1,2,3])); |
|||
print(sumOfSquares([10])); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>0 |
|||
14 |
|||
100</pre> |
|||
=={{header|Delphi}}== |
|||
Delphi has standard SumOfSquares function in Math unit: |
|||
<syntaxhighlight lang="delphi">program SumOfSq; |
|||
{$APPTYPE CONSOLE} |
|||
uses Math; |
|||
type |
|||
TDblArray = array of Double; |
|||
var |
|||
A: TDblArray; |
|||
begin |
|||
Writeln(SumOfSquares([]):6:2); // 0.00 |
|||
Writeln(SumOfSquares([1, 2, 3, 4]):6:2); // 30.00 |
|||
A:= nil; |
|||
Writeln(SumOfSquares(A):6:2); // 0.00 |
|||
A:= TDblArray.Create(1, 2, 3, 4); |
|||
Writeln(SumOfSquares(A):6:2); // 30.00 |
|||
Readln; |
|||
end.</syntaxhighlight> |
|||
=={{header|Draco}}== |
|||
<syntaxhighlight lang="draco">proc nonrec sum_squares([*] int arr) ulong: |
|||
ulong sum, item; |
|||
word i, len; |
|||
sum := 0; |
|||
len := dim(arr,1); |
|||
if len>0 then |
|||
for i from 0 upto len-1 do |
|||
item := |arr[i]; |
|||
sum := sum + item * item |
|||
od |
|||
fi; |
|||
sum |
|||
corp |
|||
proc nonrec main() void: |
|||
type A0 = [0] int, |
|||
A1 = [1] int, |
|||
A5 = [5] int; |
|||
writeln(sum_squares(A0())); |
|||
writeln(sum_squares(A1(42))); |
|||
writeln(sum_squares(A5(1,2,3,4,5))) |
|||
corp</syntaxhighlight> |
|||
{{out}} |
|||
<pre>0 |
|||
1764 |
|||
55</pre> |
|||
=={{header|E}}== |
|||
<syntaxhighlight lang="e">def sumOfSquares(numbers) { |
|||
var sum := 0 |
|||
for x in numbers { |
|||
sum += x**2 |
|||
} |
|||
return sum |
|||
}</syntaxhighlight> |
|||
=={{header|EasyLang}}== |
|||
<syntaxhighlight lang="easylang"> |
|||
nums[] = [ 1 2 3 4 5 ] |
|||
for v in nums[] |
|||
sum += v * v |
|||
. |
|||
print sum |
|||
</syntaxhighlight> |
|||
=={{header|Eiffel}}== |
|||
<syntaxhighlight lang="eiffel"> |
|||
class |
|||
APPLICATION |
|||
create |
|||
make |
|||
feature -- Initialization |
|||
make |
|||
local |
|||
a: ARRAY [INTEGER] |
|||
do |
|||
a := <<1, -2, 3>> |
|||
print ("%NSquare sum of <<1, 2, 3>>: " + sum_of_square (a).out) |
|||
a := <<>> |
|||
print ("%NSquare sum of <<>>: " + sum_of_square (a).out) |
|||
end |
|||
feature -- Access |
|||
sum_of_square (a: ITERABLE [INTEGER]): NATURAL |
|||
-- sum of square of each items |
|||
do |
|||
Result := 0 |
|||
across a as it loop |
|||
Result := Result + (it.item * it.item).as_natural_32 |
|||
end |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Elena}}== |
|||
ELENA 6.x : |
|||
<syntaxhighlight lang="elena">import system'routines; |
|||
import extensions; |
|||
SumOfSquares(list) |
|||
= list.selectBy::(x => x * x).summarize(new Integer()); |
|||
public program() |
|||
{ |
|||
console |
|||
.printLine(SumOfSquares(new int[]{4, 8, 15, 16, 23, 42})) |
|||
.printLine(SumOfSquares(new int[]{1, 2, 3, 4, 5})) |
|||
.printLine(SumOfSquares(Array.MinValue)) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2854 |
|||
55 |
|||
0 |
|||
</pre> |
|||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">iex(1)> Enum.reduce([3,1,4,1,5,9], 0, fn x,sum -> sum + x*x end) |
|||
133</syntaxhighlight> |
|||
=={{header|Emacs Lisp}}== |
|||
<syntaxhighlight lang="lisp">(defun sum-of-squares (numbers) |
|||
(apply #'+ (mapcar (lambda (k) (* k k)) numbers))) |
|||
(sum-of-squares (number-sequence 0 3)) ;=> 14</syntaxhighlight> |
|||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
<syntaxhighlight lang="erlang">lists:foldl(fun(X, Sum) -> X*X + Sum end, 0, [3,1,4,1,5,9]).</syntaxhighlight> |
|||
=={{header| |
=={{header|Euler}}== |
||
Using [[Jensen's Device]] |
|||
: fsum**2 ( addr n -- f ) |
|||
'''begin''' |
|||
0e |
|||
'''new''' i; '''new''' A; '''new''' sum; |
|||
dup 0= if 2drop exit then |
|||
sum <- ` '''formal''' i; '''formal''' lo; '''formal''' hi; '''formal''' term; |
|||
floats bounds do |
|||
'''begin''' |
|||
'''new''' temp; '''label''' loop; |
|||
1 floats +loop ; |
|||
temp <- 0; |
|||
i <- lo; |
|||
loop: '''begin''' |
|||
temp <- temp + term; |
|||
'''if''' [ i <- i + 1 ] <= hi '''then''' '''goto''' loop '''else''' 0 |
|||
'''end'''; |
|||
temp |
|||
'''end''' |
|||
'; |
|||
A <- ( 1, 2, 3, 4, 5 ); |
|||
'''out''' sum( @i, 1, '''length''' A, `A[i]*A[i]' ) |
|||
test 6 fsum**2 f. \ 133. |
|||
'''end''' $ |
|||
=={{header|Euphoria}}== |
|||
<syntaxhighlight lang="euphoria">function SumOfSquares(sequence v) |
|||
atom sum |
|||
sum = 0 |
|||
for i = 1 to length(v) do |
|||
sum += v[i]*v[i] |
|||
end for |
|||
return sum |
|||
end function</syntaxhighlight> |
|||
=={{header|Excel}}== |
|||
To find the sum of squares of values from A1 to A10, type in any other cell : |
|||
<syntaxhighlight lang="excel"> |
|||
=SUMSQ(A1:A10) |
|||
</syntaxhighlight> |
|||
The above expression will return zero if there are no values in any cell. |
|||
<syntaxhighlight lang="text"> |
|||
12 3 5 23 13 67 15 9 4 2 |
|||
5691 |
|||
</syntaxhighlight> |
|||
=={{header|F_Sharp|F#}}== |
|||
<syntaxhighlight lang="fsharp">[1 .. 10] |> List.fold (fun a x -> a + x * x) 0 |
|||
[|1 .. 10|] |> Array.fold (fun a x -> a + x * x) 0</syntaxhighlight> |
|||
=={{header|Factor}}== |
|||
<syntaxhighlight lang="factor">USE: math sequences ; |
|||
: sum-of-squares ( seq -- n ) [ sq ] map-sum ; |
|||
{ 1.0 2.0 4.0 8.0 16.0 } sum-of-squares</syntaxhighlight> |
|||
=={{header|FALSE}}== |
|||
<syntaxhighlight lang="false"> |
|||
0 3 1 4 1 5 9$*\ [$0=~][$*+\]#%. |
|||
</syntaxhighlight> |
|||
=={{header|Fantom}}== |
|||
<syntaxhighlight lang="fantom"> |
|||
class SumSquares |
|||
{ |
|||
static Int sumSquares (Int[] numbers) |
|||
{ |
|||
Int sum := 0 |
|||
numbers.each |n| { sum += n * n } |
|||
return sum |
|||
} |
|||
public static Void main () |
|||
{ |
|||
Int[] n := [,] |
|||
echo ("Sum of squares of $n = ${sumSquares(n)}") |
|||
n = [1,2,3,4,5] |
|||
echo ("Sum of squares of $n = ${sumSquares(n)}") |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Fish}}== |
|||
<syntaxhighlight lang="fish">v |
|||
\0& |
|||
>l?!v:*&+& |
|||
>&n;</syntaxhighlight> |
|||
=={{header|Forth}}== |
|||
<syntaxhighlight lang="forth">: fsum**2 ( addr n -- f ) |
|||
0e |
|||
dup 0= if 2drop exit then |
|||
floats bounds do |
|||
i f@ fdup f* f+ |
|||
1 floats +loop ; |
|||
create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f, |
|||
test 6 fsum**2 f. \ 133.</syntaxhighlight> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
In ISO Fortran 90 orlater, use SUM intrinsic and implicit element-wise array arithmetic: |
In ISO Fortran 90 orlater, use SUM intrinsic and implicit element-wise array arithmetic: |
||
<syntaxhighlight lang="fortran">real, dimension(1000) :: a = (/ (i, i=1, 1000) /) |
|||
real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array |
|||
real :: result, zresult |
|||
result = sum(a*a) ! Multiply array by itself to get squares |
|||
result = sum(a**2) ! Use exponentiation operator to get squares |
|||
zresult = sum(p*p) ! P is zero-length; P*P is valid zero-length array expression; SUM(P*P) == 0.0 as expected</syntaxhighlight> |
|||
=={{header|FreeBASIC}}== |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
Function SumSquares(a() As Double) As Double |
|||
Dim As Integer length = UBound(a) - LBound(a) + 1 |
|||
If length = 0 Then Return 0.0 |
|||
Dim As Double sum = 0.0 |
|||
For i As Integer = LBound(a) To UBound(a) |
|||
sum += a(i) * a(i) |
|||
Next |
|||
Return sum |
|||
End Function |
|||
Dim a(5) As Double = {1.0, 2.0, 3.0, -1.0, -2.0, -3.0} |
|||
Dim sum As Double = SumSquares(a()) |
|||
Print "The sum of the squares is"; sum |
|||
Print |
|||
Print "Press any key to quit" |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
The sum of the squares is 28 |
|||
</pre> |
|||
=={{header|Frink}}== |
|||
<syntaxhighlight lang="frink"> |
|||
f = {|x| x^2} // Anonymous function which squares its argument |
|||
a = [1,2,3,5,7] |
|||
println[sum[map[f,a], 0]] |
|||
</syntaxhighlight> |
|||
=={{header|FutureBasic}}== |
|||
<syntaxhighlight lang="futurebasic"> |
|||
void local fn DoIt |
|||
NSUinteger i, sum = 0 |
|||
CFArrayRef array = @[@3, @1, @4, @1, @5, @9] |
|||
for i = 0 to len(array) -1 |
|||
zresult = sum(p*p) ! P is zero-length; P*P is valid zero-length array expression; SUM(P*P) == 0.0 as expected |
|||
sum = sum + intVal( array[i] ) ^ 2 |
|||
next |
|||
print "The sum of squares is: ", sum |
|||
end fn |
|||
fn DoIt |
|||
HandleEvents |
|||
</syntaxhighlight> |
|||
{{output}} |
|||
<pre> |
|||
The sum of squares is: 133 |
|||
</pre> |
|||
=={{header|Fōrmulæ}}== |
|||
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sum_of_squares}} |
|||
'''Solution''' |
|||
[[File:Fōrmulæ - Sum of squares 01.png]] |
|||
'''Test cases''' |
|||
[[File:Fōrmulæ - Sum of squares 02.png]] |
|||
[[File:Fōrmulæ - Sum of squares 03.png]] |
|||
[[File:Fōrmulæ - Sum of squares 04.png]] |
|||
[[File:Fōrmulæ - Sum of squares 05.png]] |
|||
[[File:Fōrmulæ - Sum of squares 06.png]] |
|||
[[File:Fōrmulæ - Sum of squares 07.png]] |
|||
=={{header|GAP}}== |
|||
<syntaxhighlight lang="gap"># Just multiplying a vector by itself yields the sum of squares (it's an inner product) |
|||
# It's necessary to check for the empty vector though |
|||
SumSq := function(v) |
|||
if Size(v) = 0 then |
|||
return 0; |
|||
else |
|||
return v*v; |
|||
fi; |
|||
end;</syntaxhighlight> |
|||
=={{header|GEORGE}}== |
|||
<syntaxhighlight lang="george">read (n) print ; |
|||
0 |
|||
1, n rep (i) |
|||
read print dup mult + |
|||
] |
|||
print</syntaxhighlight> |
|||
data |
|||
<pre> |
|||
11 |
|||
8 |
|||
12 |
|||
15 |
|||
6 |
|||
25 |
|||
19 |
|||
33 |
|||
27 |
|||
3 |
|||
37 |
|||
4 |
|||
</pre> |
|||
results: |
|||
<pre> |
|||
1.100000000000000E+0001 << number of values (11) |
|||
8.000000000000000 << 11 data |
|||
1.200000000000000E+0001 |
|||
1.500000000000000E+0001 |
|||
6.000000000000000 |
|||
2.500000000000000E+0001 |
|||
1.900000000000000E+0001 |
|||
3.300000000000000E+0001 |
|||
2.700000000000000E+0001 |
|||
3.000000000000000 |
|||
3.700000000000000E+0001 |
|||
4.000000000000000 |
|||
4.667000000000000E+0003 << sum of squares |
|||
</pre> |
|||
=={{header|Go}}== |
|||
;Implementation |
|||
<syntaxhighlight lang="go">package main |
|||
import "fmt" |
|||
var v = []float32{1, 2, .5} |
|||
func main() { |
|||
var sum float32 |
|||
for _, x := range v { |
|||
sum += x * x |
|||
} |
|||
fmt.Println(sum) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
5.25 |
|||
</pre> |
|||
;Library |
|||
<syntaxhighlight lang="go">package main |
|||
import ( |
|||
"fmt" |
|||
"github.com/gonum/floats" |
|||
) |
|||
var v = []float64{1, 2, .5} |
|||
func main() { |
|||
fmt.Println(floats.Dot(v, v)) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
5.25 |
|||
</pre> |
|||
=={{header|Golfscript}}== |
|||
<syntaxhighlight lang="golfscript">{0\{.*+}%}:sqsum; |
|||
# usage example |
|||
[1 2 3]sqsum puts</syntaxhighlight> |
|||
=={{header|Groovy}}== |
|||
<syntaxhighlight lang="groovy">def array = 1..3 |
|||
// square via multiplication |
|||
def sumSq = array.collect { it * it }.sum() |
|||
println sumSq |
|||
// square via exponentiation |
|||
sumSq = array.collect { it ** 2 }.sum() |
|||
println sumSq</syntaxhighlight> |
|||
{{out}} |
|||
<pre>14 |
|||
14</pre> |
|||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
Three approaches: |
|||
sumOfSquares = sum . map (^ 2) |
|||
<syntaxhighlight lang="haskell">versions :: [[Int] -> Int] |
|||
versions = |
|||
[ sum . fmap (^ 2) -- ver 1 |
|||
, sum . ((^ 2) <$>) -- ver 2 |
|||
, foldr ((+) . (^ 2)) 0 -- ver 3 |
|||
] |
|||
main :: IO () |
|||
> sumOfSquares [3,1,4,1,5,9] |
|||
main = |
|||
133 |
|||
mapM_ print ((`fmap` [[3, 1, 4, 1, 5, 9], [1 .. 6], [], [1]]) <$> versions)</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>[133,91,0,1] |
|||
[133,91,0,1] |
|||
[133,91,0,1]</pre> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
|||
<syntaxhighlight lang="icon">procedure main() |
|||
local lst |
|||
lst := [] |
|||
#Construct a simple list and pass it to getsum |
|||
every put(lst,seq()\2) |
|||
write(getsum(lst)) |
|||
end |
|||
procedure getsum(lst) |
|||
local total |
|||
total := 0 |
|||
every total +:= !lst ^ 2 |
|||
return total |
|||
end</syntaxhighlight> |
|||
=={{header|IDL}}== |
=={{header|IDL}}== |
||
<syntaxhighlight lang="idl">print,total(array^2)</syntaxhighlight> |
|||
=={{header| |
=={{header|Inform 7}}== |
||
<syntaxhighlight lang="inform7">Sum Of Squares is a room. |
|||
To decide which number is the sum of (N - number) and (M - number) (this is summing): |
|||
procedure main() |
|||
decide on N + M. |
|||
local lst |
|||
lst := [] |
|||
To decide which number is (N - number) squared (this is squaring): |
|||
#Construct a simple list and pass it to getsum |
|||
decide on N * N. |
|||
every put(lst,seq()\2) |
|||
write(getsum(lst)) |
|||
To decide which number is the sum of squares of (L - list of numbers): |
|||
end |
|||
decide on the summing reduction of squaring applied to L. |
|||
procedure getsum(lst) |
|||
When play begins: |
|||
local total |
|||
say the sum of squares of {}; |
|||
total := 0 |
|||
say line break; |
|||
every total +:= !lst ^ 2 |
|||
say the sum of squares of {1, 2, 3}; |
|||
return total |
|||
end the story.</syntaxhighlight> |
|||
end |
|||
=={{header|Io}}== |
=={{header|Io}}== |
||
<syntaxhighlight lang="io">list(3,1,4,1,5,9) map(squared) sum</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
<syntaxhighlight lang="j">ss=: +/ @: *:</syntaxhighlight> |
|||
That is, sum composed with square. The verb also works on higher-ranked arrays. For example: |
That is, sum composed with square. The verb also works on higher-ranked arrays. For example: |
||
ss 3 1 4 1 5 9 |
<syntaxhighlight lang="j"> ss 3 1 4 1 5 9 |
||
133 |
|||
ss $0 NB. $0 is a zero-length vector |
|||
0 |
|||
x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers |
|||
ss x |
|||
9.09516 5.19512 5.84173 6.6916</syntaxhighlight> |
|||
The computation can also be written as a loop. It is shown here for comparison only and |
The computation can also be written as a loop. It is shown here for comparison only and |
||
is highly non-preferred compared to the version above. |
is highly non-preferred compared to the version above. |
||
<syntaxhighlight lang="j">ss1=: 3 : 0 |
|||
z=. 0 |
|||
for_i. i.#y do. z=. z+*:i{y end. |
|||
) |
|||
ss1 3 1 4 1 5 9 |
|||
133 |
|||
ss1 $0 |
|||
0 |
|||
ss1 x |
|||
9.09516 5.19512 5.84173 6.6916</syntaxhighlight> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
{{works with|Java|1.5+}} |
|||
Assume the numbers are in a double array called "nums". |
|||
<syntaxhighlight lang="java5">public class SumSquares |
|||
{ |
|||
public static void main(final String[] args) |
|||
{ |
|||
double sum = 0; |
|||
int[] nums = {1,2,3,4,5}; |
|||
for (int i : nums) |
|||
sum += i * i; |
|||
System.out.println("The sum of the squares is: " + sum); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|JavaScript}}== |
|||
===ES5=== |
|||
<syntaxhighlight lang="javascript">function sumsq(array) { |
|||
var sum = 0; |
|||
var i, iLen; |
|||
for (i = 0, iLen = array.length; i < iLen; i++) { |
|||
<java>... |
|||
sum += array[i] * array[i]; |
|||
} |
|||
for(double a : nums){ |
|||
sum |
return sum; |
||
} |
} |
||
System.out.println("The sum of the squares is: " + sum); |
|||
...</java> |
|||
alert(sumsq([1,2,3,4,5])); // 55</syntaxhighlight> |
|||
=={{header|JavaScript}}== |
|||
<javascript>function sumsq(array) { |
|||
var sum = 0; |
|||
for(var i in array) |
|||
sum += array[i] * array[i]; |
|||
return sum; |
|||
} |
|||
alert( sumsq( [1,2,3,4,5] ) ); // 55</javascript> |
|||
An alternative using a while loop and Math.pow |
|||
{{libheader|Functional}} |
|||
<javascript>Functional.reduce("x+y*y", 0, [1,2,3,4,5]) // 55</javascript> |
|||
<syntaxhighlight lang="javascript">function sumsq(array) { |
|||
var sum = 0, |
|||
i = array.length; |
|||
while (i--) sum += Math.pow(array[i], 2); |
|||
return sum; |
|||
} |
|||
alert(sumsq([1,2,3,4,5])); // 55</syntaxhighlight> |
|||
{{libheader|Functional}}<syntaxhighlight lang="javascript">Functional.reduce("x+y*y", 0, [1,2,3,4,5])</syntaxhighlight> |
|||
map (JS 1.6) and reduce (JS 1.8) |
|||
<syntaxhighlight lang="javascript">[3,1,4,1,5,9].map(function (n) { return Math.pow(n,2); }).reduce(function (sum,n) { return sum+n; });</syntaxhighlight> |
|||
===ES6=== |
|||
Two ways of composing a sumOfSquares function |
|||
<syntaxhighlight lang="javascript">(() => { |
|||
'use strict'; |
|||
// sumOfSquares :: Num a => [a] -> a |
|||
const sumOfSquares = xs => |
|||
sum(xs.map(squared)); |
|||
// sumOfSquares2 :: Num a => [a] -> a |
|||
const sumOfSquares2 = xs => |
|||
xs.reduce((a, x) => a + squared(x), 0); |
|||
// ---------------------- TEST ----------------------- |
|||
const main = () => [ |
|||
sumOfSquares, |
|||
sumOfSquares2 |
|||
].map( |
|||
f => f([3, 1, 4, 1, 5, 9]) |
|||
).join('\n'); |
|||
// --------------------- GENERIC --------------------- |
|||
// squared :: Num a => a -> a |
|||
const squared = x => |
|||
Math.pow(x, 2); |
|||
// sum :: [Num] -> Num |
|||
const sum = xs => |
|||
// The numeric sum of all values in xs. |
|||
xs.reduce((a, x) => a + x, 0); |
|||
// MAIN --- |
|||
return main(); |
|||
})();</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>133 |
|||
133</pre> |
|||
=={{header|Joy}}== |
|||
<syntaxhighlight lang="joy">[1 2 3 4 5] 0 [dup * +] fold.</syntaxhighlight> |
|||
=={{header|jq}}== |
|||
jq supports both arrays and streams, and so we illustrate how to handle both. |
|||
<syntaxhighlight lang="jq"># ss for an input array: |
|||
def ss: map(.*.) | add; |
|||
# ss for a stream, S, without creating an intermediate array: |
|||
def ss(S): reduce S as $x (0; . + ($x * $x) );</syntaxhighlight>We can also use a generic "SIGMA" filter that behaves like the mathematical SIGMA:<syntaxhighlight lang="jq"> |
|||
# SIGMA(exp) computes the sum of exp over the input array: |
|||
def SIGMA(exp): map(exp) | add; |
|||
# SIGMA(exp; S) computes the sum of exp over elements of the stream, S, |
|||
# without creating an intermediate array: |
|||
def SIGMA(exp; S): reduce (S|exp) as $x (0; . + $x);</syntaxhighlight> |
|||
Finally, a "mapreduce" filter:<syntaxhighlight lang="jq"> |
|||
def mapreduce(mapper; reducer; zero): |
|||
if length == 0 then zero |
|||
else map(mapper) | reducer |
|||
end; |
|||
</syntaxhighlight> |
|||
Demonstration:<syntaxhighlight lang="jq">def demo(n): |
|||
"ss: \( [range(0;n)] | ss )", |
|||
"ss(S): \( ss( range(0;n) ) )", |
|||
"SIGMA(.*.): \( [range(0;n)] | SIGMA(.*.) )", |
|||
"SIGMA(.*.;S): \( SIGMA( .*.; range(0;n) ) )", |
|||
"mapreduce(.*.; add; 0): \( [range(0;n)] | mapreduce(.*.; add; 0) )" |
|||
; |
|||
demo(3) # 0^2 + 1^2 + 2^2</syntaxhighlight> |
|||
{{out}} |
|||
<syntaxhighlight lang="jq">"ss: 5" |
|||
"ss(S): 5" |
|||
"SIGMA(.*.): 5" |
|||
"SIGMA(.*.;S): 5" |
|||
"mapreduce(.*.; add; 0): 5"</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
There are several easy ways to do this in Julia: |
|||
<syntaxhighlight lang="julia">julia> sum([1,2,3,4,5].^2) |
|||
55 |
|||
julia> sum([x^2 for x in [1,2,3,4,5]]) |
|||
55 |
|||
julia> mapreduce(x->x^2,+,[1:5]) |
|||
55 |
|||
julia> sum([x^2 for x in []]) |
|||
0</syntaxhighlight> |
|||
=={{header|K}}== |
|||
<syntaxhighlight lang="k"> |
|||
ss: {+/x*x} |
|||
ss 1 2 3 4 5 |
|||
55 |
|||
ss@!0 |
|||
0 |
|||
</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
Kotlin functional capabilities make this easy. <code>map</code> can be used to transform the elements of any array, collection, iterable or sequence, and then <code>sum</code> can be used to compute the sum. So <code>.map {it * it}.sum()</code>. |
|||
However, when the input is a collection, <code>map</code> will also output a collection. This can be wasteful not only in terms of ''computation'', but also in terms of ''memory''. Piping a <code>.asSequence()</code> first will make the operation lazy, making it faster, and less memory intensive. A Kotlin <code>Sequence</code> is the spiritual equivalent of Java’s <code>Stream</code> |
|||
Still, Sequences are not free either. Kotlin also offers <code>reduce</code> and <code>fold</code> to do the above in a single operation. This is actually much faster than the above 2 approaches. |
|||
Finally, a classic for-loop can also be used. Note that because <code>forEach</code> and <code>fold</code> are inline functions, these are actually exactly as efficient as the had-written for-loop. |
|||
<syntaxhighlight lang="kotlin">import kotlin.random.Random |
|||
import kotlin.system.measureTimeMillis |
|||
import kotlin.time.milliseconds |
|||
enum class Summer { |
|||
MAPPING { |
|||
override fun sum(values: DoubleArray) = values.map {it * it}.sum() |
|||
}, |
|||
SEQUENCING { |
|||
override fun sum(values: DoubleArray) = values.asSequence().map {it * it}.sum() |
|||
}, |
|||
FOLDING { |
|||
override fun sum(values: DoubleArray) = values.fold(0.0) {acc, it -> acc + it * it} |
|||
}, |
|||
FOR_LOOP { |
|||
override fun sum(values: DoubleArray): Double { |
|||
var sum = 0.0 |
|||
values.forEach { sum += it * it } |
|||
return sum |
|||
} |
|||
}, |
|||
; |
|||
abstract fun sum(values: DoubleArray): Double |
|||
} |
|||
fun main() { |
|||
run { |
|||
val testArrays = listOf( |
|||
doubleArrayOf(), |
|||
doubleArrayOf(Random.nextInt(100) / 10.0), |
|||
DoubleArray(6) { Random.nextInt(100) / 10.0 }, |
|||
) |
|||
for (impl in Summer.values()) { |
|||
println("Test with ${impl.name}:") |
|||
for (v in testArrays) println(" ${v.contentToString()} -> ${impl.sum(v)}") |
|||
} |
|||
} |
|||
run { |
|||
val elements = 100_000 |
|||
val longArray = DoubleArray(elements) { Random.nextDouble(10.0) } |
|||
for (impl in Summer.values()) { |
|||
val time = measureTimeMillis { |
|||
impl.sum(longArray) |
|||
}.milliseconds |
|||
println("Summing $elements with ${impl.name} takes: $time") |
|||
} |
|||
var acc = 0.0 |
|||
for (v in longArray) acc += v |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Test with MAPPING: |
|||
[] -> 0.0 |
|||
[3.5] -> 12.25 |
|||
[9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 |
|||
Test with SEQUENCING: |
|||
[] -> 0.0 |
|||
[3.5] -> 12.25 |
|||
[9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 |
|||
Test with FOLDING: |
|||
[] -> 0.0 |
|||
[3.5] -> 12.25 |
|||
[9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 |
|||
Test with FOR_LOOP: |
|||
[] -> 0.0 |
|||
[3.5] -> 12.25 |
|||
[9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 |
|||
Summing 100000 elements with MAPPING takes: 31.0ms |
|||
Summing 100000 elements with SEQUENCING takes: 13.0ms |
|||
Summing 100000 elements with FOLDING takes: 2.00ms |
|||
Summing 100000 elements with FOR_LOOP takes: 2.00ms |
|||
</pre> |
|||
=={{header|Lambdatalk}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
{def sumsq |
|||
{lambda {:s} |
|||
{+ {S.map {lambda {:i} {* :i :i}} :s}}}} |
|||
-> sumsq |
|||
{sumsq 1 2 3 4 5} |
|||
-> 55 |
|||
{sumsq 0} |
|||
-> 0 |
|||
</syntaxhighlight> |
|||
=={{header|Lang5}}== |
|||
<syntaxhighlight lang="lang5">[1 2 3 4 5] 2 ** '+ reduce .</syntaxhighlight> |
|||
=={{header|Lasso}}== |
|||
<syntaxhighlight lang="lasso">define sumofsquares(values::array) => { |
|||
local(sum = 0) |
|||
with value in #values do { |
|||
#sum += #value * #value |
|||
} |
|||
return #sum |
|||
} |
|||
sumofsquares(array(1,2,3,4,5))</syntaxhighlight> |
|||
{{out}} |
|||
<pre>55</pre> |
|||
=={{header|LFE}}== |
|||
<syntaxhighlight lang="lisp"> |
|||
(defun sum-sq (nums) |
|||
(lists:foldl |
|||
(lambda (x acc) |
|||
(+ acc (* x x))) |
|||
0 nums)) |
|||
</syntaxhighlight> |
|||
Usage: |
|||
<syntaxhighlight lang="lisp"> |
|||
> (sum-sq '(3 1 4 1 5 9)) |
|||
133 |
|||
</syntaxhighlight> |
|||
=={{header|Liberty BASIC}}== |
|||
<syntaxhighlight lang="lb">' [RC] Sum of Squares |
|||
SourceList$ ="3 1 4 1 5 9" |
|||
'SourceList$ ="" |
|||
' If saved as an array we'd have to have a flag for last data. |
|||
' LB has the very useful word$() to read from delimited strings. |
|||
' The default delimiter is a space character, " ". |
|||
SumOfSquares =0 |
|||
n =0 |
|||
data$ ="666" ' temporary dummy to enter the loop. |
|||
while data$ <>"" ' we loop until no data left. |
|||
data$ =word$( SourceList$, n +1) ' first data, as a string |
|||
NewVal =val( data$) ' convert string to number |
|||
SumOfSquares =SumOfSquares +NewVal^2 ' add to existing sum of squares |
|||
n =n +1 ' increment number of data items found |
|||
wend |
|||
n =n -1 |
|||
print "Supplied data was "; SourceList$ |
|||
print "This contained "; n; " numbers." |
|||
print "Sum of squares is "; SumOfSquares |
|||
end</syntaxhighlight> |
|||
=={{header|LiveCode}}== |
|||
<syntaxhighlight lang="livecode">put "1,2,3,4,5" into nums |
|||
repeat for each item n in nums |
|||
add (n * n) to m |
|||
end repeat |
|||
put m // 55</syntaxhighlight> |
|||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
<syntaxhighlight lang="logo">print apply "sum map [? * ?] [1 2 3 4 5] ; 55</syntaxhighlight> |
|||
=={{header|Logtalk}}== |
|||
<syntaxhighlight lang="logtalk">sum(List, Sum) :- |
|||
sum(List, 0, Sum). |
|||
sum([], Sum, Sum). |
|||
sum([X| Xs], Acc, Sum) :- |
|||
Acc2 is Acc + X, |
|||
sum(Xs, Acc2, Sum).</syntaxhighlight> |
|||
=={{header|Lua}}== |
|||
<syntaxhighlight lang="lua">function squaresum(a, ...) return a and a^2 + squaresum(...) or 0 end |
|||
function squaresumt(t) return squaresum(unpack(t)) end |
|||
print(squaresumt{3, 5, 4, 1, 7})</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
M2000 use two concepts for arrays: standard array like A() and pointer to array as A. Pointer arithmetic not allowed here. Standard arrays are values types, and pointers are reference types. So we can handle an array both with pointer and without. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Dim A() 'make an array with zero items |
|||
A=(,) 'make a pointer to array with zero items |
|||
A=(1,) 'make a pointer to array with one item |
|||
A()=A 'make a copy of array pointed by A to A() |
|||
A=A() 'make A a pointer for A() |
|||
Dim A(10)=1 'redim A() and pass 1 to each item |
|||
k=lambda m=1->{=m:m++} ' a lambda function with a closure m |
|||
Dim B(10)<<k() 'fill B() from 1 to 10 |
|||
A()=B() ' copy B() to A(), A() object stay as is, but new items loaded, so pointer A points to A. |
|||
A+=100 ' add 100 to each element of A() |
|||
A(0)+=100 ' add 100 to first element |
|||
A()=Cons(A,A) |
|||
Now A and A() prints a 20 item array (Cons() add a list of arrays) |
|||
Print A ' or Print A() print the same |
|||
</syntaxhighlight> |
|||
And this is the task, using a lambda function (we can use a standard function, just use Function Square { code here }) |
|||
Because M2000 modules and functions use stack for passing values, we use read statement to read a value. Functions in expressions has no return to stack because they have own stack, so passing values are filled in a fresh stack in every call. This not hold if we call function using Call (as a module), so stack is passed from parent (caller). |
|||
When we pass an array in stack, a pointer to array (to one of two interfaces) and depends the name type of a read to make this a copy or a pointer to array. So here we use: read a as a pointer to array (so it is a by reference pass). We can use Read a() and then a=a() (and remove Link a to a()), so we use by value pass, and that is a decision from callee, not the caller (this happen for objects) |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module Checkit { |
|||
A=(1,2,3,4,5) |
|||
Square=lambda -> { |
|||
read a |
|||
if len(a)=0 then =0: exit |
|||
link a to a() |
|||
\\ make sum same type as a(0) |
|||
sum=a(0)-a(0) |
|||
for i=0 to len(a)-1 {sum+=a(i)*a(i)} |
|||
=sum |
|||
} |
|||
Print Square(a)=55 |
|||
Print Square((,))=0 ' empty array |
|||
Dim k(10)=2, L() |
|||
Print Square(K())=40 |
|||
Print Square(L())=0 |
|||
A=(1@,2@,3@,4@,5@) |
|||
X=Square(A) |
|||
Print Type$(X)="Decimal", X=55@ |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
<syntaxhighlight lang="maple"> |
|||
F := V -> add(v^2, v in V): |
|||
F(<1,2,3,4,5>); |
|||
</syntaxhighlight> |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
As a function 1: |
|||
<syntaxhighlight lang="mathematica">SumOfSquares[x_]:=Total[x^2] |
|||
SumOfSquares[{1,2,3,4,5}]</syntaxhighlight> |
|||
As a function 2: |
|||
<syntaxhighlight lang="mathematica">SumOfSquares[x_]:=x.x |
|||
SumOfSquares[{1,2,3,4,5}]</syntaxhighlight> |
|||
Pure function 1: (postfix operator in the following examples) |
|||
<syntaxhighlight lang="mathematica">{1,2,3,4,5} // Total[#^2] &</syntaxhighlight> |
|||
Pure function 2: |
|||
<syntaxhighlight lang="mathematica">{1, 2, 3, 4, 5} // #^2 & // Total</syntaxhighlight> |
|||
Pure function 3: |
|||
<syntaxhighlight lang="mathematica">{1, 2, 3, 4, 5} // #.#&</syntaxhighlight> |
|||
=={{header|MATLAB}}== |
|||
<syntaxhighlight lang="matlab">function [squaredSum] = sumofsquares(inputVector) |
|||
squaredSum = sum( inputVector.^2 );</syntaxhighlight> |
|||
=={{header|Maxima}}== |
=={{header|Maxima}}== |
||
<syntaxhighlight lang="maxima">nums : [3,1,4,1,5,9]; |
|||
sum(nums[i]^2,i,1,length(nums));</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="maxima">nums : [3,1,4,1,5,9]; |
|||
lsum(el^2, el, nums);</syntaxhighlight> |
|||
=={{header|Mercury}}== |
|||
<syntaxhighlight lang="text"> |
|||
:- module sum_of_squares. |
|||
:- interface. |
|||
:- import_module io. |
|||
:- pred main(io::di, io::uo) is det. |
|||
:- implementation. |
|||
:- import_module int, list. |
|||
main(!IO) :- |
|||
io.write_int(sum_of_squares([3, 1, 4, 1, 5, 9]), !IO), |
|||
io.nl(!IO). |
|||
:- func sum_of_squares(list(int)) = int. |
|||
sum_of_squares(Ns) = list.foldl((func(N, Acc) = Acc + N * N), Ns, 0). |
|||
</syntaxhighlight> |
|||
=={{header|min}}== |
|||
{{works with|min|0.19.3}} |
|||
<syntaxhighlight lang="min">((bool) ((dup *) (+) map-reduce) (pop 0) if) :sq-sum |
|||
(1 2 3 4 5) sq-sum puts |
|||
() sq-sum puts</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
55 |
|||
0 |
|||
</pre> |
|||
=={{header|MiniScript}}== |
|||
<syntaxhighlight lang="miniscript">sumOfSquares = function(seq) |
|||
sum = 0 |
|||
for item in seq |
|||
sum = sum + item*item |
|||
end for |
|||
return sum |
|||
end function |
|||
print sumOfSquares([4, 8, 15, 16, 23, 42]) |
|||
print sumOfSquares([1, 2, 3, 4, 5]) |
|||
print sumOfSquares([])</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2854 |
|||
55 |
|||
0</pre> |
|||
=={{header|МК-61/52}}== |
|||
<syntaxhighlight lang="text">x^2 + С/П БП 00</syntaxhighlight> |
|||
=={{header|Modula-3}}== |
|||
<syntaxhighlight lang="modula3">MODULE SumSquares EXPORTS Main; |
|||
IMPORT IO, Fmt; |
|||
TYPE RealArray = ARRAY OF REAL; |
|||
PROCEDURE SumOfSquares(x: RealArray): REAL = |
|||
VAR sum := 0.0; |
|||
BEGIN |
|||
FOR i := FIRST(x) TO LAST(x) DO |
|||
sum := sum + x[i] * x[i]; |
|||
END; |
|||
RETURN sum; |
|||
END SumOfSquares; |
|||
BEGIN |
|||
IO.Put(Fmt.Real(SumOfSquares(RealArray{3.0, 1.0, 4.0, 1.0, 5.0, 9.0}))); |
|||
IO.Put("\n"); |
|||
END SumSquares.</syntaxhighlight> |
|||
=={{header|MOO}}== |
|||
<syntaxhighlight lang="moo">@verb #100:sum_squares this none this rd |
|||
@program #100:sum_squares |
|||
sum = 0; |
|||
list = args[1]; |
|||
for i in (list) |
|||
sum = sum + (i^2); |
|||
endfor |
|||
player:tell(toliteral(list), " => ", sum); |
|||
. |
|||
{{out}} |
|||
;#100:sum_squares({3,1,4,1,5,9}) |
|||
{3, 1, 4, 1, 5, 9} => 133 |
|||
;#100:sum_squares({}) |
|||
{} => 0 |
|||
</syntaxhighlight> |
|||
=={{header|MUMPS}}== |
|||
<syntaxhighlight lang="mumps">SUMSQUARE(X) |
|||
;X is assumed to be a list of numbers separated by "^" |
|||
NEW RESULT,I |
|||
SET RESULT=0,I=1 |
|||
FOR QUIT:(I>$LENGTH(X,"^")) SET RESULT=($PIECE(X,"^",I)*$PIECE(X,"^",I))+RESULT,I=I+1 |
|||
QUIT RESULT</syntaxhighlight> |
|||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="nanoquery">def sum_squares(vector) |
|||
if len(vector) = 0 |
|||
return 0 |
|||
end |
|||
sum = 0 |
|||
for n in vector |
|||
sum += n ^ 2 |
|||
end |
|||
return sum |
|||
end |
|||
println sum_squares({}) |
|||
println sum_squares({1, 2, 3, 4, 5}) |
|||
println sum_squares({10, 3456, 2, 6})</syntaxhighlight> |
|||
{{out}} |
|||
<pre>0 |
|||
55 |
|||
11944076</pre> |
|||
=={{header|Nemerle}}== |
|||
<syntaxhighlight lang="nemerle">SS(x : list[double]) : double |
|||
{ |
|||
|[] => 0.0 |
|||
|_ => x.Map(fun (x) {x*x}).FoldLeft(0.0, _+_) |
|||
}</syntaxhighlight> |
|||
=={{header|NetRexx}}== |
|||
<syntaxhighlight lang="netrexx">/*NetRexx ************************************************************* |
|||
* program to sum the squares of a vector of fifteen numbers. |
|||
* translated from REXX |
|||
* 14.05.2013 Walter Pachl |
|||
**********************************************************************/ |
|||
numeric digits 50 /*allow 50-digit # (default is 9)*/ |
|||
v='-100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12' /* vector with some #s. */ |
|||
n=v.words() |
|||
x='' |
|||
sum=0 /*initialize SUM to zero. */ |
|||
/*if vector is empty, sum = zero.*/ |
|||
loop Until x='' /*loop until list is exhausted */ |
|||
Parse v x v /* pick next number */ |
|||
If x>'' Then /* there is a number */ |
|||
sum=sum + x**2 /*add its square to the sum. */ |
|||
end |
|||
say "The sum of" n "elements for the V vector is:" sum</syntaxhighlight> |
|||
{{out}} |
|||
<pre>The sum of 15 elements for the V vector is: 10650.25</pre> |
|||
=={{header|NewLISP}}== |
|||
<syntaxhighlight lang="newlisp">(apply + (map (fn(x) (* x x)) '(3 1 4 1 5 9))) |
|||
-> 133 |
|||
(apply + (map (fn(x) (* x x)) '())) |
|||
-> 0</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
<syntaxhighlight lang="nim">import math, sequtils |
|||
proc sumSquares[T: SomeNumber](a: openArray[T]): T = |
|||
sum(a.mapIt(it * it)) |
|||
let a1 = [1, 2, 3, 4, 5] |
|||
echo a1, " → ", sumSquares(a1) |
|||
let a2: seq[float] = @[] |
|||
echo a2, " → ", sumSquares(a2)</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[1, 2, 3, 4, 5] → 55 |
|||
@[] → 0.0</pre> |
|||
=={{header|Nu}}== |
|||
<syntaxhighlight lang="nu">def sqsum []: { |
|||
reduce -f 0 {|x res| $x * $x + $res } |
|||
}</syntaxhighlight> |
|||
=={{header|Oberon-2}}== |
|||
{{trans|Modula-3}} |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE SumSquares; |
|||
IMPORT Out; |
|||
VAR |
|||
A1:ARRAY 6 OF REAL; |
|||
PROCEDURE Init; |
|||
BEGIN |
|||
A1[0] := 3.0; A1[1] := 1.0; A1[2] := 4.0; A1[3] := 5.0; A1[4] := 9.0; |
|||
END Init; |
|||
PROCEDURE SumOfSquares(VAR arr:ARRAY OF REAL):REAL; |
|||
VAR |
|||
i:LONGINT; |
|||
sum:REAL; |
|||
BEGIN |
|||
sum := 0.0; |
|||
FOR i := 0 TO LEN(arr)-1 DO |
|||
sum := sum + arr[i] * arr[i] |
|||
END; |
|||
RETURN sum |
|||
END SumOfSquares; |
|||
BEGIN |
|||
Init; |
|||
Out.Real(SumOfSquares(A1),0); |
|||
Out.Ln |
|||
END SumSquares. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1.32E+02 |
|||
</pre> |
|||
=={{header|Objeck}}== |
|||
<syntaxhighlight lang="objeck"> |
|||
bundle Default { |
|||
class Sum { |
|||
function : native : SquaredSum(values : Float[]) ~ Float { |
|||
sum := 0.0; |
|||
for(i := 0 ; i < values->Size() ; i += 1;) { |
|||
sum += (values[i] * values[i]); |
|||
}; |
|||
return sum; |
|||
} |
|||
function : Main(args : String[]) ~ Nil { |
|||
SquaredSum([3.0, 1.0, 4.0, 1.0, 5.0, 9.0])->PrintLine(); |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
<ocaml>List.fold_left (fun sum a -> sum + a * a) 0 ints</ |
<syntaxhighlight lang="ocaml">List.fold_left (fun sum a -> sum + a * a) 0 ints</syntaxhighlight> |
||
<syntaxhighlight lang="ocaml">List.fold_left (fun sum a -> sum +. a *. a) 0. floats</syntaxhighlight> |
|||
=={{header|Octave}}== |
|||
<syntaxhighlight lang="octave">a = [1:10]; |
|||
sumsq = sum(a .^ 2);</syntaxhighlight> |
|||
=={{header|Oforth}}== |
|||
<syntaxhighlight lang="oforth">#sq [1, 1.2, 3, 4.5 ] map sum</syntaxhighlight> |
|||
=={{header|Ol}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
(define (sum-of-squares l) |
|||
(fold + 0 (map * l l))) |
|||
(print (sum-of-squares '(1 2 3 4 5 6 7 8 9 10))) |
|||
; ==> 385 |
|||
</syntaxhighlight> |
|||
=={{header|Order}}== |
|||
<syntaxhighlight lang="c">#include <order/interpreter.h> |
|||
ORDER_PP(8to_lit( |
|||
8seq_fold(8plus, 0, |
|||
8seq_map(8fn(8X, 8times(8X, 8X)), 8seq(3, 1, 4, 1, 5, 9))) |
|||
))</syntaxhighlight> |
|||
=={{header|Oz}}== |
|||
<syntaxhighlight lang="oz">declare |
|||
fun {SumOfSquares Xs} |
|||
for X in Xs sum:S do |
|||
{S X*X} |
|||
end |
|||
end |
|||
in |
|||
{Show {SumOfSquares [3 1 4 1 5 9]}}</syntaxhighlight> |
|||
=={{header|PARI/GP}}== |
|||
===Generic=== |
|||
It is possible to apply a function, in this case ^2 to each element of an iterable and sum the result: |
|||
<syntaxhighlight lang="parigp">ss(v)={ |
|||
sum(i=1,#v,v[i]^2) |
|||
};</syntaxhighlight> |
|||
===Specific=== |
|||
For this particular task the product of a row matrix and its transpose is the sum of squares: |
|||
<syntaxhighlight lang="parigp"> |
|||
n=[2,5,23] |
|||
print(n*n~) |
|||
n=[] |
|||
print(n*n~) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
558 |
|||
0 |
|||
</pre> |
|||
=={{header|Pascal}}== |
|||
{{works with|Free_Pascal}} |
|||
{{libheader|Math}} |
|||
Example from the documenation of the run time library: |
|||
<syntaxhighlight lang="pascal">Program Example45; |
|||
{ Program to demonstrate the SumOfSquares function. } |
|||
Uses math; |
|||
Var |
|||
I : 1..100; |
|||
ExArray : Array[1..100] of Float; |
|||
begin |
|||
Randomize; |
|||
for I:=low(ExArray) to high(ExArray) do |
|||
ExArray[i]:=(Random-Random)*100; |
|||
Writeln('Max : ',MaxValue(ExArray):8:4); |
|||
Writeln('Min : ',MinValue(ExArray):8:4); |
|||
Writeln('Sum squares : ',SumOfSquares(ExArray):8:4); |
|||
Writeln('Sum squares (b) : ',SumOfSquares(@ExArray[1],100):8:4); |
|||
end.</syntaxhighlight> |
|||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
## |
|||
var vector := Arr(1,2,3,4,5,6,7); |
|||
vector.Sum(x -> x * x).Println |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
140 |
|||
</pre> |
|||
<ocaml>List.fold_left (fun sum a -> sum +. a *. a) 0. floats</ocaml> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
<perl>sub sum_of_squares { |
<syntaxhighlight lang="perl">sub sum_of_squares { |
||
my $sum = 0; |
my $sum = 0; |
||
$sum += $_**2 foreach @_; |
$sum += $_**2 foreach @_; |
||
Line 277: | Line 2,316: | ||
} |
} |
||
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</ |
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</syntaxhighlight> |
||
or |
or |
||
<perl>use List::Util qw(reduce); |
<syntaxhighlight lang="perl">use List::Util qw(reduce); |
||
sub sum_of_squares { |
sub sum_of_squares { |
||
reduce { $a + $b **2 } 0, @_; |
reduce { $a + $b **2 } 0, @_; |
||
} |
} |
||
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</ |
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</syntaxhighlight> |
||
=={{header| |
=={{header|Phix}}== |
||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
<span style="color: #008080;">function</span> <span style="color: #000000;">sum_of_squares</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</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_power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span> |
|||
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">({{},{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)},</span><span style="color: #000000;">sum_of_squares</span><span style="color: #0000FF;">)</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
{0,133,385} |
|||
</pre> |
|||
=={{header|Phixmonti}}== |
|||
<syntaxhighlight lang="phixmonti">0 tolist |
|||
10 for 0 put endfor |
|||
0 swap len for |
|||
get |
|||
2 power rot + swap |
|||
endfor |
|||
drop print /# 385 #/</syntaxhighlight> |
|||
=={{header|PHP}}== |
|||
<syntaxhighlight lang="php"> |
|||
function sum_squares(array $args) { |
|||
return array_reduce( |
|||
$args, create_function('$x, $y', 'return $x+$y*$y;'), 0 |
|||
); |
|||
} |
|||
</syntaxhighlight> |
|||
In PHP5.3 support for anonymous functions was reworked. While the above code would still work, it is suggested to use |
|||
<syntaxhighlight lang="php"> |
|||
function sum_squares(array $args) { |
|||
return array_reduce($args, function($x, $y) { |
|||
return $x+$y*$y; |
|||
}, 0); |
|||
} |
|||
</syntaxhighlight> |
|||
Usage for both examples: <code>sum_squares(array(1,2,3,4,5)); // 55</code> |
|||
=={{header|Picat}}== |
|||
<syntaxhighlight lang="picat">go => |
|||
List = 1..666, |
|||
println(sum_squares(List)), |
|||
println(sum_squares([])), |
|||
nl. |
|||
sum_squares([]) = 0. |
|||
sum_squares(List) = sum([I*I : I in List]).</syntaxhighlight> |
|||
{{out}} |
|||
<pre>98691321 |
|||
0</pre> |
|||
=={{header|PicoLisp}}== |
|||
<syntaxhighlight lang="picolisp">: (sum '((N) (* N N)) (3 1 4 1 5 9)) |
|||
-> 133 |
|||
: (sum '((N) (* N N)) ()) |
|||
-> 0</syntaxhighlight> |
|||
=={{header|PL/0}}== |
|||
PL/0 has no arrays but they can be simulated. |
|||
<syntaxhighlight lang="pascal"> |
|||
const maxlist = 5; |
|||
var sub, v, l1, l2, l3, l4, l5, sum; |
|||
procedure getelement; |
|||
begin |
|||
if sub = 1 then v := l1; |
|||
if sub = 2 then v := l2; |
|||
if sub = 3 then v := l3; |
|||
if sub = 4 then v := l4; |
|||
if sub = 5 then v := l5; |
|||
end; |
|||
procedure setelement; |
|||
begin |
|||
if sub = 1 then l1 := v; |
|||
if sub = 2 then l2 := v; |
|||
if sub = 3 then l3 := v; |
|||
if sub = 4 then l4 := v; |
|||
if sub = 5 then l5 := v; |
|||
end; |
|||
procedure sumofsquares; |
|||
begin |
|||
sub := 0; |
|||
sum := 0; |
|||
while sub < maxlist do begin |
|||
sub := sub + 1; |
|||
call getelement; |
|||
sum := sum + v * v |
|||
end; |
|||
end; |
|||
begin |
|||
sub := 0; |
|||
while sub < maxlist do begin |
|||
sub := sub + 1; |
|||
v := sub; |
|||
call setelement; |
|||
end; |
|||
call sumofsquares; |
|||
! sum; |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
<pre> |
||
55 |
|||
define sum_squares(v); |
|||
</pre> |
|||
=={{header|PL/I}}== |
|||
<syntaxhighlight lang="pl/i"> |
|||
declare A(10) float initial (10, 9, 8, 7, 6, 5, 4, 3, 2, 1); |
|||
put (sum(A**2)); |
|||
</syntaxhighlight> |
|||
=={{header|PL/M}}== |
|||
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator) |
|||
<syntaxhighlight lang="plm"> |
|||
100H: /* CALCULATE THE SUM OF THE SQUARES OF THE ELEMENTS OF AN ARRAY */ |
|||
/* CP/M BDOS SYSTEM CALL AND I/O ROUTINES */ |
|||
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END; |
|||
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END; |
|||
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END; |
|||
PR$NL: PROCEDURE; CALL PR$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END; |
|||
PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH */ |
|||
DECLARE N ADDRESS; |
|||
DECLARE V ADDRESS, N$STR ( 6 )BYTE, W BYTE; |
|||
V = N; |
|||
W = LAST( N$STR ); |
|||
N$STR( W ) = '$'; |
|||
N$STR( W := W - 1 ) = '0' + ( V MOD 10 ); |
|||
DO WHILE( ( V := V / 10 ) > 0 ); |
|||
N$STR( W := W - 1 ) = '0' + ( V MOD 10 ); |
|||
END; |
|||
CALL PR$STRING( .N$STR( W ) ); |
|||
END PR$NUMBER; |
|||
/* TASK */ |
|||
/* RETURNS THE SUM OF THE SQUARES OF THE ARRAY AT A$PTR, UB MUST BE THE */ |
|||
/* UB MUST BE THE UPPER-BOUND OF THE ARRAY */ |
|||
SUM$OF$SQUARES: PROCEDURE( A$PTR, UB )ADDRESS; |
|||
DECLARE ( A$PTR, UB ) ADDRESS; |
|||
DECLARE ( I, SUM ) ADDRESS; |
|||
DECLARE A BASED A$PTR ( 0 )ADDRESS; |
|||
SUM = 0; |
|||
DO I = 0 TO UB; |
|||
SUM = SUM + ( A( I ) * A( I ) ); |
|||
END; |
|||
RETURN SUM; |
|||
END SUM$OF$SQUARES; |
|||
DECLARE VALUES ( 5 )ADDRESS INITIAL( 1, 2, 3, 4, 5 ); |
|||
CALL PR$NUMBER( SUM$OF$SQUARES( .VALUES, LAST( VALUES ) ) ); |
|||
EOF |
|||
</syntaxhighlight> |
|||
=={{header|Plain English}}== |
|||
<syntaxhighlight lang="plainenglish">To run: |
|||
Start up. |
|||
Create a list. |
|||
Sum the squares of the list giving a ratio. |
|||
Destroy the list. |
|||
Write "Sum of squares: " then the ratio on the console. |
|||
Wait for the escape key. |
|||
Shut down. |
|||
An element is a thing with a ratio. |
|||
A list is some elements. |
|||
To add a ratio to a list: |
|||
Allocate memory for an element. |
|||
Put the ratio into the element's ratio. |
|||
Append the element to the list. |
|||
To create a list: |
|||
Add 3-1/10 to the list. |
|||
Add 1/1 to the list. |
|||
Add 4/1 to the list. |
|||
Add 1/1 to the list. |
|||
Add 5/1 to the list. |
|||
Add 9/1 to the list. |
|||
To sum the squares of a list giving a ratio: |
|||
Put 0 into the ratio. |
|||
Get an element from the list. |
|||
Loop. |
|||
If the element is nil, exit. |
|||
Add the element's ratio times the element's ratio to the ratio. |
|||
Put the element's next into the element. |
|||
Repeat.</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Sum of squares: 133-61/100 |
|||
</pre> |
|||
=={{header|Pop11}}== |
|||
<syntaxhighlight lang="pop11">define sum_squares(v); |
|||
lvars s = 0, j; |
lvars s = 0, j; |
||
for j from 1 to length(v) do |
for j from 1 to length(v) do |
||
Line 297: | Line 2,535: | ||
enddefine; |
enddefine; |
||
sum_squares({1 2 3 4 5}) => |
sum_squares({1 2 3 4 5}) =></syntaxhighlight> |
||
</pre> |
|||
=={{header|PostScript}}== |
|||
<syntaxhighlight lang="text"> |
|||
/sqrsum{ |
|||
/x exch def |
|||
/sum 0 def |
|||
/i 0 def |
|||
x length 0 eq |
|||
{} |
|||
{ |
|||
x length{ |
|||
/sum sum x i get 2 exp add def |
|||
/i i 1 add def |
|||
}repeat |
|||
}ifelse |
|||
sum == |
|||
}def |
|||
</syntaxhighlight> |
|||
{{libheader|initlib}} |
|||
<syntaxhighlight lang="postscript"> |
|||
[3 1 4 1 5 9] 0 {dup * +} fold |
|||
</syntaxhighlight> |
|||
=={{header|PowerShell}}== |
|||
<syntaxhighlight lang="powershell">function Get-SquareSum ($a) { |
|||
if ($a.Length -eq 0) { |
|||
return 0 |
|||
} else { |
|||
$x = $a ` |
|||
| ForEach-Object { $_ * $_ } ` |
|||
| Measure-Object -Sum |
|||
return $x.Sum |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Prolog}}== |
|||
sum([],0). |
|||
sum([H|T],S) :- sum(T, S1), S is S1 + (H * H). |
|||
=={{header|PureBasic}}== |
|||
<syntaxhighlight lang="purebasic">Procedure SumOfSquares(List base()) |
|||
ForEach base() |
|||
Sum + base()*base() |
|||
Next |
|||
ProcedureReturn Sum |
|||
EndProcedure</syntaxhighlight> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
'''Using generator expression''' |
|||
<python>sum([x*x for x in [1, 2, 3, 4, 5]])</python> |
|||
<syntaxhighlight lang="python">sum(x * x for x in [1, 2, 3, 4, 5]) |
|||
# or |
|||
sum(x ** 2 for x in [1, 2, 3, 4, 5]) |
|||
# or |
|||
sum(pow(x, 2) for x in [1, 2, 3, 4, 5])</syntaxhighlight> |
|||
'''Functional versions:''' |
|||
<syntaxhighlight lang="python"># using lambda and map: |
|||
sum(map(lambda x: x * x, [1, 2, 3, 4, 5])) |
|||
# or |
|||
sum(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) |
|||
# or |
|||
sum(map(lambda x: pow(x, 2), [1, 2, 3, 4, 5])) |
|||
# using pow and repeat |
|||
from itertools import repeat |
|||
sum(map(pow, [1, 2, 3, 4, 5], repeat(2))) |
|||
# using starmap and mul |
|||
from itertools import starmap |
|||
from operator import mul |
|||
a = [1, 2, 3, 4, 5] |
|||
sum(starmap(mul, zip(a, a))) |
|||
# using reduce |
|||
from functools import reduce |
|||
powers_of_two = (x * x for x in [1, 2, 3, 4, 5]) |
|||
reduce(lambda x, y : x + y, powers_of_two) |
|||
# or |
|||
from operator import add |
|||
powers_of_two = (x * x for x in [1, 2, 3, 4, 5]) |
|||
reduce(add, powers_of_two) |
|||
# or using a bit more complex lambda |
|||
reduce(lambda a, x: a + x*x, [1, 2, 3, 4, 5])</syntaxhighlight> |
|||
'''Using NumPy:''' |
|||
<syntaxhighlight lang="python">import numpy as np |
|||
a = np.array([1, 2, 3, 4, 5]) |
|||
np.sum(a ** 2)</syntaxhighlight> |
|||
=={{header|Q}}== |
|||
<syntaxhighlight lang="q">ssq:{sum x*x}</syntaxhighlight> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery"> [ 0 swap witheach [ 2 ** + ] ] is sumofsquares ( [ --> n )</syntaxhighlight> |
|||
{{out}} |
|||
Testing in the Quackery shell. |
|||
<pre>> quackery |
|||
Welcome to Quackery. |
|||
Enter "leave" to leave the shell. |
|||
/O> [ 0 swap witheach [ 2 ** + ] ] is sumofsquares |
|||
... ' [ 2 3 5 7 11 13 17 ] sumofsquares echo cr |
|||
... ' [ ] sumofsquares echo cr |
|||
... leave |
|||
... |
|||
666 |
|||
0 |
|||
Sayonara.</pre> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
<syntaxhighlight lang="r">arr <- c(1,2,3,4,5) |
|||
result <- sum(arr^2)</syntaxhighlight> |
|||
=={{header|Racket}}== |
|||
<syntaxhighlight lang="racket"> |
|||
#lang racket |
|||
(for/sum ([x #(3 1 4 1 5 9)]) (* x x)) |
|||
</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
<syntaxhighlight lang="raku" line>say [+] map * ** 2, (3, 1, 4, 1, 5, 9);</syntaxhighlight> |
|||
If this expression seems puzzling, note that <code>* ** 2</code> is equivalent to <code>{$^x ** 2}</code>— the leftmost asterisk is not the multiplication operator but the <code>Whatever</code> star, which specifies currying behavior. |
|||
Another convenient way to distribute the exponentiation is via the cross metaoperator, which |
|||
as a list infix is looser than comma in precedence but tighter than the reduction list operator: |
|||
<syntaxhighlight lang="raku" line>say [+] <3 1 4 1 5 9> X** 2</syntaxhighlight> |
|||
=={{header|Raven}}== |
|||
<syntaxhighlight lang="raven">define sumOfSqrs use $lst |
|||
0 $lst each dup * + |
|||
[ 1 2 3 4] sumOfSqrs "Sum of squares: %d\n" print</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Sum of squares: 30</pre> |
|||
=={{header|Red}}== |
|||
<syntaxhighlight lang="red">Red [ |
|||
date: 2021-10-25 |
|||
red-version: 0.6.4 |
|||
description: "Find the sum of squares of a numeric vector" |
|||
] |
|||
sum-squares: function [ |
|||
"Returns the sum of squares of all values in a block" |
|||
values [any-list! vector!] |
|||
][ |
|||
result: 0 |
|||
foreach value values [result: value * value + result] |
|||
result |
|||
] |
|||
print sum-squares [] |
|||
print sum-squares [1 2 0.5]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 |
|||
5.25 |
|||
</pre> |
|||
=={{header|Refal}}== |
|||
<syntaxhighlight lang="refal">$ENTRY Go { |
|||
= <Prout <SquareSum 1 2 3 4 5>> |
|||
}; |
|||
SquareSum { |
|||
= 0; |
|||
s.N e.rest = <+ <* s.N s.N> <SquareSum e.rest>>; |
|||
};</syntaxhighlight> |
|||
{{out}} |
|||
<pre>55</pre> |
|||
=={{header|ReScript}}== |
|||
With integers: |
|||
<syntaxhighlight lang="rescript">let sumOfSquares = (acc, item) => { acc + item * item } |
|||
Js.log(Js.Array2.reduce([10, 2, 4], sumOfSquares, 0))</syntaxhighlight> |
|||
With floats: |
|||
<syntaxhighlight lang="rescript">let sumOfSquares = (acc, item) => { acc +. item *. item } |
|||
Js.log(Js.Array2.reduce([10., 2., 4.], sumOfSquares, 0.))</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
===input from pgm=== |
|||
<syntaxhighlight lang="rexx">/*REXX program sums the squares of the numbers in a (numeric) vector of 15 numbers. */ |
|||
numeric digits 100 /*allow 100─digit numbers; default is 9*/ |
|||
v= -100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12 /*define a vector with fifteen numbers.*/ |
|||
#=words(v) /*obtain number of words in the V list.*/ |
|||
$= 0 /*initialize the sum ($) to zero. */ |
|||
do k=1 for # /*process each number in the V vector. */ |
|||
$=$ + word(v,k)**2 /*add a squared element to the ($) sum.*/ |
|||
end /*k*/ /* [↑] if vector is empty, then sum=0.*/ |
|||
/*stick a fork in it, we're all done. */ |
|||
say 'The sum of ' # " squared elements for the V vector is: " $</syntaxhighlight> |
|||
'''output''' using an internal vector (list) of numbers: |
|||
<pre> |
|||
The sum of 15 squared elements for the V vector is: 10650.25 |
|||
</pre> |
|||
===input from C.L.=== |
|||
<syntaxhighlight lang="rexx">/*REXX program sums the squares of the numbers in a (numeric) vector of 15 numbers. */ |
|||
numeric digits 100 /*allow 100─digit numbers; default is 9*/ |
|||
parse arg v /*get optional numbers from the C.L. */ |
|||
if v='' then v= -100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12 /*Not specified? Use default*/ |
|||
#=words(v) /*obtain number of words in V*/ |
|||
say 'The vector of ' # " elements is: " space(v) /*display the vector numbers.*/ |
|||
$= 0 /*initialize the sum ($) to zero. */ |
|||
do until v==''; parse var v x v /*process each number in the V vector. */ |
|||
$=$ + x**2 /*add a squared element to the ($) sum.*/ |
|||
end /*until*/ /* [↑] if vector is empty, then sum=0.*/ |
|||
say /*stick a fork in it, we're all done. */ |
|||
say 'The sum of ' # " squared elements for the V vector is: " $</syntaxhighlight> |
|||
'''output''' using a vector (list) of numbers from the command line: |
|||
<pre> |
|||
The vector of 10 elements is: -1000 -100 -10 -1 0 +1 +10 100 1000 1e20 |
|||
The sum of 10 squared elements for the V vector is: 10000000000000000000000000000000002020202 |
|||
</pre> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
aList = [1,2,3,4,5] |
|||
see sumOfSquares(aList) |
|||
func sumOfSquares sos |
|||
sumOfSquares = 0 |
|||
for i=1 to len(sos) |
|||
sumOfSquares = sumOfSquares + pow(sos[i],2) |
|||
next |
|||
return sumOfSquares |
|||
</syntaxhighlight> |
|||
=={{header|RPL}}== |
|||
Zero-length vectors don't exist in RPL, so there's no need to tackle this case: |
|||
≪ DUP DOT ≫ '<span style="color:blue">∑SQV</span>' STO |
|||
If we really need zero-length objects, we can use lists: |
|||
≪ 0 SWAP |
|||
'''IF''' DUP SIZE '''THEN''' |
|||
1 OVER SIZE '''FOR''' j |
|||
DUP j GET SQ + '''NEXT''' |
|||
'''END''' DROP |
|||
≫ '<span style="color:blue">∑SQL</span>' STO |
|||
Using RPL 1993: |
|||
≪ '''IF''' DUP SIZE '''THEN''' SQ ∑LIST '''ELSE''' SIZE '''END''' ≫ '<span style="color:blue">∑SQL</span>' STO |
|||
[ 1 2 3 4 5 ] <span style="color:blue">∑SQV</span> |
|||
{ 1 2 3 4 5 } <span style="color:blue">∑SQL</span> |
|||
{ } <span style="color:blue">∑SQL</span> |
|||
{{out}} |
|||
<pre> |
|||
3: 55 |
|||
2: 55 |
|||
1: 0 |
|||
</pre> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
<ruby>[3,1,4,1,5,9]. |
<syntaxhighlight lang="ruby">[3,1,4,1,5,9].sum(0){|x| x*x}</syntaxhighlight> |
||
=={{header|Run BASIC}}== |
|||
<syntaxhighlight lang="runbasic">list$ = "1,2,3,4,5" |
|||
print sumOfSquares(list$) |
|||
FUNCTION sumOfSquares(sos$) |
|||
while word$(sos$,i+1,",") <> "" |
|||
i = i + 1 |
|||
sumOfSquares = sumOfSquares + val(word$(sos$,i,","))^2 |
|||
wend |
|||
END FUNCTION</syntaxhighlight> |
|||
=={{header|Rust}}== |
|||
<syntaxhighlight lang="rust">fn sq_sum(v: &[f64]) -> f64 { |
|||
v.iter().fold(0., |sum, &num| sum + num*num) |
|||
} |
|||
fn main() { |
|||
let v = vec![3.0, 1.0, 4.0, 1.0, 5.5, 9.7]; |
|||
println!("{}", sq_sum(&v)); |
|||
let u : Vec<f64> = vec![]; |
|||
println!("{}", sq_sum(&u)); |
|||
}</syntaxhighlight> |
|||
=={{header|Sather}}== |
|||
<syntaxhighlight lang="sather">class MAIN is |
|||
sqsum(s, e:FLT):FLT is |
|||
return s + e*e; |
|||
end; |
|||
sum_of_squares(v :ARRAY{FLT}):FLT is |
|||
return (#ARRAY{FLT}(|0.0|).append(v)).reduce(bind(sqsum(_,_))); |
|||
end; |
|||
main is |
|||
v :ARRAY{FLT} := |3.0, 1.0, 4.0, 1.0, 5.0, 9.0|; |
|||
#OUT + sum_of_squares(v) + "\n"; |
|||
end; |
|||
end;</syntaxhighlight> |
|||
=={{header|Scala}}== |
|||
Unfortunately there is no common "Numeric" class that Int and Double both extend, since Scala's number representation maps closely to Java's. Those concerned about precision can define a similar procedure for integers. |
|||
<syntaxhighlight lang="scala">def sum_of_squares(xs: Seq[Double]) = xs.foldLeft(0) {(a,x) => a + x*x}</syntaxhighlight> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
<scheme>(define (sum-of-squares l) |
<syntaxhighlight lang="scheme">(define (sum-of-squares l) |
||
(apply + (map * l l)))</ |
(apply + (map * l l)))</syntaxhighlight> |
||
> (sum-of-squares (list 3 1 4 1 5 9)) |
> (sum-of-squares (list 3 1 4 1 5 9)) |
||
133 |
133 |
||
=={{header|Seed7}}== |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
include "float.s7i"; |
|||
const array float: list1 is [] (3.0, 1.0, 4.0, 1.0, 5.0, 9.0); |
|||
const array float: list2 is 0 times 0.0; |
|||
const func float: squaredSum (in array float: floatList) is func |
|||
result |
|||
var float: sum is 0.0; |
|||
local |
|||
var float: number is 0.0; |
|||
begin |
|||
for number range floatList do |
|||
sum +:= number ** 2; |
|||
end for; |
|||
end func; |
|||
const proc: main is func |
|||
begin |
|||
writeln(squaredSum(list1)); |
|||
writeln(squaredSum(list2)); |
|||
end func;</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
<syntaxhighlight lang="ruby">func sum_of_squares(vector) { |
|||
var sum = 0; |
|||
vector.each { |n| sum += n**2 }; |
|||
return sum; |
|||
} |
|||
say sum_of_squares([]); # 0 |
|||
say sum_of_squares([1,2,3]); # 14</syntaxhighlight> |
|||
=={{header|Slate}}== |
|||
<syntaxhighlight lang="slate">{1. 2. 3} reduce: [|:x :y| y squared + x]. |
|||
{} reduce: [|:x :y| y squared + x] ifEmpty: [0].</syntaxhighlight> |
|||
=={{header|Smalltalk}}== |
|||
<syntaxhighlight lang="smalltalk">#(3 1 4 1 5 9) inject: 0 into: [:sum :aNumber | sum + aNumber squared]</syntaxhighlight> |
|||
=={{header|SNOBOL4}}== |
|||
{{works with|Macro Spitbol}} |
|||
{{works with|Snobol4+}} |
|||
{{works with|CSnobol}} |
|||
<syntaxhighlight lang="snobol4"> define('ssq(a)i') :(ssq_end) |
|||
ssq i = i + 1; ssq = ssq + (a<i> * a<i>) :s(sumsq)f(return) |
|||
ssq_end |
|||
* # Fill array, test and display |
|||
str = '1 2 3 5 7 11 13 17 19 23'; a = array(10) |
|||
loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop) |
|||
output = str ' -> ' sumsq(a) |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre> 1 2 3 5 7 11 13 17 19 23 -> 1557</pre> |
|||
=={{header|SQL}}== |
|||
<syntaxhighlight lang="sql">select sum(x*x) from vector</syntaxhighlight> |
|||
Note that this assumes that the values in our vector are named <code>x</code>. |
|||
=={{header|Standard ML}}== |
|||
<syntaxhighlight lang="sml">foldl (fn (a, sum) => sum + a * a) 0 ints</syntaxhighlight> |
|||
<syntaxhighlight lang="sml">foldl (fn (a, sum) => sum + a * a) 0.0 reals</syntaxhighlight> |
|||
=={{header|Stata}}== |
|||
=== Mata === |
|||
<syntaxhighlight lang="stata">a = 1..100 |
|||
sum(a:^2) |
|||
338350 |
|||
a = J(0, 1, .) |
|||
length(a) |
|||
0 |
|||
sum(a:^2) |
|||
0</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
<syntaxhighlight lang="swift">func sumSq(s: [Int]) -> Int { |
|||
return s.map{$0 * $0}.reduce(0, +) |
|||
}</syntaxhighlight> |
|||
=={{header|Tailspin}}== |
|||
<syntaxhighlight lang="tailspin"> |
|||
templates ssq |
|||
when <[](0)> do 0 ! |
|||
otherwise $... -> $*$ -> ..=Sum&{of: :()} ! |
|||
end ssq |
|||
[] -> ssq -> !OUT::write // outputs 0 |
|||
[1..5] -> ssq -> !OUT::write // outputs 55 |
|||
</syntaxhighlight> |
|||
=={{header|Tcl}}== |
|||
<syntaxhighlight lang="tcl">package require Tcl 8.6 |
|||
namespace path ::tcl::mathop |
|||
# {*} is like apply in Scheme--it turns a list into multiple arguments |
|||
proc sum_of_squares lst { |
|||
+ {*}[lmap x $lst {* $x $x}] |
|||
} |
|||
puts [sum_of_squares {1 2 3 4}]; # ==> 30 |
|||
puts [sum_of_squares {}]; # ==> 0 |
|||
</syntaxhighlight> |
|||
=={{header|Trith}}== |
|||
<syntaxhighlight lang="trith">[3 1 4 1 5 9] 0 [dup * +] foldl</syntaxhighlight> |
|||
=={{header|TUSCRIPT}}== |
|||
<syntaxhighlight lang="tuscript"> |
|||
$$ MODE TUSCRIPT |
|||
array="3'1'4'1'5'9",sum=0 |
|||
LOOP a=array |
|||
sum=sum+(a*a) |
|||
ENDLOOP |
|||
PRINT sum |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
133 |
|||
</pre> |
|||
=={{header|UnixPipes}}== |
=={{header|UnixPipes}}== |
||
<syntaxhighlight lang="bash">folder() { |
|||
(read B; res=$( expr $1 \* $1 ) ; test -n "$B" && expr $res + $B || echo $res) |
|||
} |
|||
fold() { |
|||
(while read a ; do |
|||
fold | folder $a |
|||
done) |
|||
} |
|||
(echo 3; echo 1; echo 4;echo 1;echo 5; echo 9) | fold</syntaxhighlight> |
|||
=={{header|UNIX Shell}}== |
|||
<syntaxhighlight lang="sh">sum_squares () { |
|||
_r=0 |
|||
for _n |
|||
do |
|||
: "$((_r += _n * _n))" |
|||
done |
|||
echo "$_r" |
|||
} |
|||
sum_squares 3 1 4 1 5 9</syntaxhighlight> |
|||
{{out}} |
|||
<pre>133</pre> |
|||
=={{header|Ursala}}== |
|||
The ssq function defined below zips two copies of its argument together, |
|||
maps the product function to all pairs, and then sums the |
|||
result by way of the reduction operator, -:. |
|||
<syntaxhighlight lang="ursala">#import nat |
|||
ssq = sum:-0+ product*iip |
|||
#cast %n |
|||
main = ssq <21,12,77,0,94,23,96,93,72,72,79,24,8,50,9,93></syntaxhighlight> |
|||
{{out}} |
|||
<pre>62223</pre> |
|||
=={{header|V}}== |
=={{header|V}}== |
||
<syntaxhighlight lang="v">[sumsq [dup *] map 0 [+] fold]. |
|||
[] sumsq |
|||
=0 |
|||
[1 2 3] sumsq</syntaxhighlight> |
|||
=14 |
=14 |
||
=={{header|VBA}}== |
|||
<syntaxhighlight lang="vb">Public Sub sum_of_squares() |
|||
Debug.Print WorksheetFunction.SumSq([{1,2,3,4,5,6,7,8,9,10}]) |
|||
End Sub</syntaxhighlight>{{out}} |
|||
<pre> 385 </pre> |
|||
=={{header|VBScript}}== |
|||
<syntaxhighlight lang="vb"> |
|||
Function sum_of_squares(arr) |
|||
If UBound(arr) = -1 Then |
|||
sum_of_squares = 0 |
|||
End If |
|||
For i = 0 To UBound(arr) |
|||
sum_of_squares = sum_of_squares + (arr(i)^2) |
|||
Next |
|||
End Function |
|||
WScript.StdOut.WriteLine sum_of_squares(Array(1,2,3,4,5)) |
|||
WScript.StdOut.WriteLine sum_of_squares(Array()) |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
55 |
|||
0 |
|||
</pre> |
|||
=={{header|Visual Basic .NET}}== |
|||
<syntaxhighlight lang="vbnet"> |
|||
Private Shared Function sumsq(ByVal i As ICollection(Of Integer)) As Integer |
|||
If i Is Nothing OrElse i.Count = 0 Then |
|||
Return 0 |
|||
End If |
|||
Return i.[Select](Function(x) x * x).Sum() |
|||
End Function |
|||
Private Shared Sub Main() |
|||
Dim a As Integer() = New Integer() {1, 2, 3, 4, 5} |
|||
' 55 |
|||
Console.WriteLine(sumsq(a)) |
|||
For K As Integer = 0 To 16 |
|||
Console.WriteLine("SumOfSquares({0}) = {1}", K, SumOfSquares(K)) |
|||
Next |
|||
End Sub |
|||
Function SumOfSquares(ByVal Max As Integer) |
|||
Dim Square As Integer = 0 |
|||
Dim Add As Integer = 1 |
|||
Dim Sum As Integer = 0 |
|||
For J As Integer = 0 To Max - 1 |
|||
Square += Add |
|||
Add += 2 |
|||
Sum += Square |
|||
Next |
|||
Return Sum |
|||
End Function |
|||
Function SumOfSquaresByMult(ByVal Max As Integer) |
|||
Dim Sum As Integer = 0 |
|||
For J As Integer = 1 To Max |
|||
Sum += J * J |
|||
Next |
|||
Return Sum |
|||
End Function |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
55 |
|||
SumOfSquares(0) = 0 |
|||
SumOfSquares(1) = 1 |
|||
SumOfSquares(2) = 5 |
|||
SumOfSquares(3) = 14 |
|||
SumOfSquares(4) = 30 |
|||
SumOfSquares(5) = 55 |
|||
SumOfSquares(6) = 91 |
|||
SumOfSquares(7) = 140 |
|||
SumOfSquares(8) = 204 |
|||
SumOfSquares(9) = 285 |
|||
SumOfSquares(10) = 385 |
|||
SumOfSquares(11) = 506 |
|||
SumOfSquares(12) = 650 |
|||
SumOfSquares(13) = 819 |
|||
SumOfSquares(14) = 1015 |
|||
SumOfSquares(15) = 1240 |
|||
SumOfSquares(16) = 1496 |
|||
</pre> |
|||
=={{header|VTL-2}}== |
|||
<syntaxhighlight lang="vtl2"> |
|||
1000 :1)=1 |
|||
1010 :2)=2 |
|||
1020 :3)=3 |
|||
1030 :4)=4 |
|||
1040 :5)=5 |
|||
1050 L=5 |
|||
1060 #=2000 |
|||
1070 ?=S |
|||
1080 #=9999 |
|||
2000 R=! |
|||
2010 S=0 |
|||
2020 I=1 |
|||
2030 #=I<L+(I=L)=0*R |
|||
2040 S=I*I+S |
|||
2050 I=I+1 |
|||
2060 #=2030 |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
55 |
|||
</pre> |
|||
=={{header|Wortel}}== |
|||
<syntaxhighlight lang="wortel">@sum !*^@sq [3 1 4 1 5 9] ; returns 133</syntaxhighlight> |
|||
<syntaxhighlight lang="wortel">@sum !*^@sq [] ; returns 0</syntaxhighlight> |
|||
As a function: |
|||
<syntaxhighlight lang="wortel">^(@sum *^@sq)</syntaxhighlight> |
|||
Iterative function: |
|||
<syntaxhighlight lang="wortel">&a [@var sum 0 @for x of a :!+sum *x x sum]</syntaxhighlight> |
|||
=={{header|Wren}}== |
|||
<syntaxhighlight lang="wren">var sumSquares = Fn.new { |v| v.reduce(0) { |sum, n| sum + n * n } } |
|||
var v = [1, 2, 3, -1, -2, -3] |
|||
System.print("Vector : %(v)") |
|||
System.print("Sum of squares : %(sumSquares.call(v))")</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Vector : [1, 2, 3, -1, -2, -3] |
|||
Sum of squares : 28 |
|||
</pre> |
|||
=={{header|XLISP}}== |
|||
The task specification calls for a function that takes a numeric vector. If you want a function that takes a linked list (which would be more idiomatic), just extract the inner function <tt>SUMSQ</tt> and use that instead of <tt>SUM-OF-SQUARES</tt>. |
|||
<syntaxhighlight lang="lisp">(defun sum-of-squares (vec) |
|||
(defun sumsq (xs) |
|||
(if (null xs) |
|||
0 |
|||
(+ (expt (car xs) 2) (sumsq (cdr xs))))) |
|||
(sumsq (vector->list vec))) |
|||
(define first-seven-primes #(2 3 5 7 11 13 17)) |
|||
(define zero-length-vector #()) |
|||
(print `(the sum of the squares of the first seven prime numbers is ,(sum-of-squares first-seven-primes))) |
|||
(print `(the sum of the squares of no numbers at all is ,(sum-of-squares zero-length-vector)))</syntaxhighlight> |
|||
{{out}} |
|||
<pre>(THE SUM OF THE SQUARES OF THE FIRST SEVEN PRIME NUMBERS IS 666) |
|||
(THE SUM OF THE SQUARES OF NO NUMBERS AT ALL IS 0)</pre> |
|||
=={{header|XPL0}}== |
|||
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations |
|||
func SumSq(V, L); |
|||
int V, L; |
|||
int S, I; |
|||
[S:= 0; |
|||
for I:= 0 to L-1 do S:= S+sq(V(I)); |
|||
return S; |
|||
]; \SumSq |
|||
[IntOut(0, SumSq([1,2,3,4,5,6,7,8,9,10], 10)); CrLf(0); |
|||
IntOut(0, SumSq([0], 0)); CrLf(0); \zero-length vector "[]" doesn't compile |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
385 |
|||
0 |
|||
</pre> |
|||
=={{header|zkl}}== |
|||
<syntaxhighlight lang="zkl">T().reduce(fcn(p,n){ p + n*n },0) //-->0 |
|||
T(3,1,4,1,5,9).reduce(fcn(p,n){ p + n*n },0.0) //-->133.0 |
|||
[1..5].reduce(fcn(p,n){ p + n*n },0) //-->55</syntaxhighlight> |
Latest revision as of 06:55, 10 August 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Write a program to find the sum of squares of a numeric vector.
The program should work on a zero-length vector (with an answer of 0).
- Related task
0815
{x{*%<:d:~$<:1:~>><:2:~>><:3:~>><:4:~>><:5:~>><:6:~>><:7:
~>><:8:~>><:9:~>><:a:~>><:b:~>><:c:~>><:ffffffffffffffff:
~>{x{*>}:8f:{x{*&{=+>{~>&=x<:ffffffffffffffff:/#:8f:{{~%
- Output:
0 28A
11l
print(sum([1, 2, 3, 4, 5].map(x -> x^2)))
- Output:
55
360 Assembly
* Sum of squares 27/08/2015
SUMOFSQR CSECT
USING SUMOFSQR,R12
LR R12,R15
LA R7,A a(1)
SR R6,R6 sum=0
LA R3,1 i=1
LOOPI CH R3,N do i=1 to hbound(a)
BH ELOOPI
L R5,0(R7) a(i)
M R4,0(R7) a(i)*a(i)
AR R6,R5 sum=sum+a(i)**2
LA R7,4(R7) next a
LA R3,1(R3) i=i+1
B LOOPI end i
ELOOPI XDECO R6,PG+23 edit sum
XPRNT PG,80
XR R15,R15
BR R14
A DC F'1',F'2',F'3',F'4',F'5',F'6',F'7',F'8',F'9',F'10'
PG DC CL80'The sum of squares is: '
N DC AL2((PG-A)/4)
YREGS
END SUMOFSQR
- Output:
The sum of squares is: 385
8086 Assembly
;;; Sum of squares
cpu 8086
bits 16
section .text
org 100h
jmp demo
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Calculate the sum of the squares of the array in SI.
;;; The array should contain 16-bit unsigned integers.
;;; The output will be 32-bit.
;;; Input: (DS:)SI = array, CX = array length
;;; Output: DX:AX = sum of squares
;;; Registers used: AX,BX,CX,DX,SI,DI
sumsqr: xor bx,bx ; Keep accumulator in BX:DI.
xor di,di ; (So zero it out first)
and cx,cx ; Counter register 0? "Program should work
jz .done ; on a zero-length vector"
.loop: mov ax,[si] ; Grab value from array
mul ax ; Calculate square of value (into DX:AX)
add di,ax ; Add low 16 bits to accumulator
adc bx,dx ; Add high 16 bits, plus carry
inc si ; Point to next value
inc si
loop .loop ; Next value in array
.done: mov ax,di ; Return the value in DX:AX as is tradition
mov dx,bx
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Demo: use the subroutine to calculate the sum of squares
;;; in the included array, and show the result
demo: mov si,array
mov cx,arrlen
call sumsqr
;;; Print the return value in DX:AX as a decimal number
;;; (Note: max supported value 655359 - this is a limitation
;;; of this rudimentary output code, not of the sum of squares
;;; routine.)
mov di,outstr_end
mov cx,10
.decloop: div cx
dec di
add dl,'0'
mov [di],dl
xor dx,dx
and ax,ax
jnz .decloop
mov dx,di
mov ah,9
int 21h
ret
section .data
outstr: db '######' ; Placeholder for decimal output
outstr_end: db '$'
array: dw 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
arrlen: equ ($-array)/2 ; length is in words
ACL2
(defun sum-of-squares (xs)
(if (endp xs)
0
(+ (* (first xs) (first xs))
(sum-of-squares (rest xs)))))
Action!
CARD FUNC SumOfSqr(BYTE ARRAY a BYTE count)
BYTE i
CARD res
IF count=0 THEN
RETURN (0)
FI
res=0
FOR i=0 TO count-1
DO
res==+a(i)*a(i)
OD
RETURN (res)
PROC Test(BYTE ARRAY a BYTE count)
BYTE i
CARD res
res=SumOfSqr(a,count)
Print("[")
IF count>0 THEN
FOR i=0 to count-1
DO
PrintB(a(i))
IF i<count-1 THEN
Put(' )
FI
OD
FI
PrintF("]->%U%E%E",res)
RETURN
PROC Main()
BYTE ARRAY a=[1 2 3 4 5]
BYTE ARRAY b=[10 20 30 40 50 60 70 80 90]
BYTE ARRAY c=[11]
Test(a,5)
Test(b,9)
Test(c,1)
Test(c,0)
RETURN
- Output:
Screenshot from Atari 8-bit computer
[1 2 3 4 5]->55 [10 20 30 40 50 60 70 80 90]->28500 [11]->121 []->0
ActionScript
function sumOfSquares(vector:Vector.<Number>):Number
{
var sum:Number = 0;
for(var i:uint = 0; i < vector.length; i++)
sum += vector[i]*vector[i];
return sum;
}
Ada
with Ada.Text_IO; use Ada.Text_IO;
procedure Test_Sum_Of_Squares is
type Float_Array is array (Integer range <>) of Float;
function Sum_Of_Squares (X : Float_Array) return Float is
Sum : Float := 0.0;
begin
for I in X'Range loop
Sum := Sum + X (I) ** 2;
end loop;
return Sum;
end Sum_Of_Squares;
begin
Put_Line (Float'Image (Sum_Of_Squares ((1..0 => 1.0)))); -- Empty array
Put_Line (Float'Image (Sum_Of_Squares ((3.0, 1.0, 4.0, 1.0, 5.0, 9.0))));
end Test_Sum_Of_Squares;
- Output:
0.00000E+00 1.33000E+02
Aime
real
squaredsum(list l)
{
integer i;
real s;
s = 0;
i = -~l;
while (i) {
s += sq(l[i += 1]);
}
s;
}
integer
main(void)
{
list l;
l = list(0, 1, 2, 3);
o_form("~\n", squaredsum(l));
o_form("~\n", squaredsum(list()));
o_form("~\n", squaredsum(list(.5, -.5, 2)));
0;
}
- Output:
14 0 4.5
ALGOL 60
Using Jensen's Device.
begin
integer i;
integer array A[ 1 : 5 ];
real procedure sum (i, lo, hi, term);
value lo, hi;
integer i, lo, hi;
real term;
comment term is passed by-name, and so is i;
begin
real temp;
temp := 0;
for i := lo step 1 until hi do
temp := temp + term;
sum := temp
end;
comment initialie A;
for i := 1 step 1 until 5 do A[i] := i;
comment note the correspondence between the mathematical notation and the call to sum;
outreal(1, sum (i, 1, 5, A[i] * A[i]))
end
ALGOL 68
The computation can be written as a loop.
PROC sum of squares = ([]REAL argv)REAL:(
REAL sum := 0;
FOR i FROM LWB argv TO UPB argv DO
sum +:= argv[i]**2
OD;
sum
);
test:(
printf(($g(0)l$,sum of squares([]REAL(3, 1, 4, 1, 5, 9))));
)
- Output:
133
Another implementation could define a procedure (proc) or operator (op) called map.
[]REAL data = (3, 1, 4, 1, 5, 9);
PROC map = ( PROC(REAL)REAL func, []REAL argv)REAL:
( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out);
test:(
REAL sum := 0;
printf(($xg(0)l$, map ( ((REAL argv)REAL: sum +:= argv ** 2), data) ));
PRIO MAP = 5; # the same priority as the operators <, =<, >=, & > maybe... #
OP MAP = ( PROC(REAL)REAL func, []REAL argv)REAL:
( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out);
sum := 0;
printf(($g(0)l$, ((REAL argv)REAL: sum +:= argv ** 2) MAP data ))
)
- Output:
133 133
The computation can be written as a generator.
#!/usr/bin/a68g --script #
# -*- coding: utf-8 -*- #
MODE YIELDREAL = PROC(REAL)VOID;
MODE GENREAL = PROC(YIELDREAL)VOID;
PROC gen real of vector = ([]REAL data, YIELDREAL yield)VOID:
FOR i FROM LWB data TO UPB data DO yield(data[i]) OD;
PROC real sum sq of gen = (GENREAL gen real)REAL: (
REAL sum:=0;
# FOR REAL value IN # gen real(#) DO (#
(REAL value)VOID:(
sum+:=value**2
# OD #));
sum
);
PROC real sum map of gen = (PROC(REAL)REAL func, GENREAL gen real)REAL: (
REAL sum:=0;
# FOR REAL value IN # gen real(#) DO (#
(REAL value)VOID:(
sum+:=func(value)
# OD #));
sum
);
OP GEN = ([]REAL array)GENREAL:gen real of vector(array,);
OP (GENREAL #gen real#)REAL SUMSQ = real sum sq of gen;
PRIO SUMMAP = 5;
OP (PROC(REAL)REAL #func#, GENREAL #gen real#)REAL SUMMAP = real sum map of gen;
test:(
[]REAL data = (3, 1, 4, 1, 5, 9);
# Permutations of the above routines #
printf(($"real sum sq GEN: "g(0)l$, real sum sq of gen(GEN data)));
printf(($"real sum sq real gen: "g(0)l$, real sum sq of gen(gen real of vector(data,))));
printf(($"real sum map real gen: "g(0)l$, real sum map of gen(((REAL x)REAL: x*x),gen real of vector(data,))));
printf(($"SUMSQ real gen: "g(0)l$, SUMSQ gen real of vector(data,)));
printf(($"SUMSQ GEN: "g(0)l$, SUMSQ GEN data));
printf(($"sq SUMMAP GEN: "g(0)l$, ((REAL x)REAL: x*x)SUMMAP GEN data))
)
- Output:
real sum sq GEN: 133 real sum sq real gen: 133 real sum map real gen: 133 SUMSQ real gen: 133 SUMSQ GEN: 133 sq SUMMAP GEN: 133
ALGOL W
Using a dedicated "sum of squares" procedure
begin
% procedure to sum the squares of the elements of a vector. %
% the bounds of the vector must be passed in lb and ub %
real procedure sumSquares ( real array vector ( * )
; integer value lb
; integer value ub
) ;
begin
real sum;
sum := 0;
for i := lb until ub do sum := sum + ( vector( i ) * vector( i ) );
sum
end sumOfSquares ;
% test the sumSquares procedure %
real array numbers ( 1 :: 5 );
for i := 1 until 5 do numbers( i ) := i;
r_format := "A"; r_w := 10; r_d := 1; % set fixed point output %
write( sumSquares( numbers, 1, 5 ) );
end.
Using Jensen's device
Using the classic Jensen's Device (first introduced in Algol 60) we can use a generic summation procedure, as in this sample:
begin % sum the squares of the elements of a vector, using Jensen's Device %
integer i;
real procedure sum ( integer %name% i; integer value lo, hi; real procedure term );
% i is passed by-name, term is passed as a procedure which makes it effectively passed by-name %
begin
real temp;
temp := 0;
i := lo;
while i <= hi do begin % The Algol W "for" loop (as in Algol 68) creates a distinct %
temp := temp + term; % variable which would not be shared with the passed "i" %
i := i + 1 % Here the actual passed "i" is incremented. %
end while_i_le_temp;
temp
end;
real array A ( 1 :: 5 );
for i := 1 until 5 do A( i ) := i;
r_format := "A"; r_w := 10; r_d := 1; % set fixed point output %
write( sum( i, 1, 5, A( i ) * A( i ) ) );
end.
Alore
def sum_squares(a)
var sum = 0
for i in a
sum = sum + i**2
end
return sum
end
WriteLn(sum_squares([3,1,4,1,5,9]))
end
APL
square_sum←{+/⍵*2}
square_sum 1 2 3 4 5
55
square_sum ⍬ ⍝The empty vector
0
AppleScript
Two ways of composing a sumOfSquares function:
------ TWO APPROACHES – SUM OVER MAP, AND DIRECT FOLD ----
-- sumOfSquares :: Num a => [a] -> a
on sumOfSquares(xs)
script squared
on |λ|(x)
x ^ 2
end |λ|
end script
sum(map(squared, xs))
end sumOfSquares
-- sumOfSquares2 :: Num a => [a] -> a
on sumOfSquares2(xs)
script plusSquare
on |λ|(a, x)
a + x ^ 2
end |λ|
end script
foldl(plusSquare, 0, xs)
end sumOfSquares2
--------------------------- TEST -------------------------
on run
set xs to [3, 1, 4, 1, 5, 9]
{sumOfSquares(xs), sumOfSquares2(xs)}
-- {133.0, 133.0}
end run
-------------------- GENERIC FUNCTIONS -------------------
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- sum :: Num a => [a] -> a
on sum(xs)
script add
on |λ|(a, b)
a + b
end |λ|
end script
foldl(add, 0, xs)
end sum
- Output:
{133.0, 133.0}
Arturo
arr: 1..10
print sum map arr [x][x^2]
- Output:
385
Astro
sum([1, 2, 3, 4]²)
Asymptote
int suma;
int[] a={1, 2, 3, 4, 5, 6};
for(var i : a)
suma = suma + a[i] ^ 2;
write("The sum of squares is: ", suma);
AutoHotkey
list = 3 1 4 1 5 9
Loop, Parse, list, %A_Space%
sum += A_LoopField**2
MsgBox,% sum
AWK
Vectors are read, space-separated, from stdin; sum of squares goes to stdout. The empty line produces 0.
$ awk '{s=0;for(i=1;i<=NF;i++)s+=$i*$i;print s}'
3 1 4 1 5 9
133
0
BASIC
Assume the numbers are in an array called a
.
sum = 0
FOR I = LBOUND(a) TO UBOUND(a)
sum = sum + a(I) ^ 2
NEXT I
PRINT "The sum of squares is: " + sum
BaCon
' Sum of squares
FUNCTION ss(int arr[], NUMBER elem)
sum = 0
FOR i = 0 TO elem - 1
sum = sum + POW(arr[i], 2)
NEXT
RETURN sum
END FUNCTION
' 1 to 10 in the test vector, or 1 to -s n
option = CMDLINE("s:")
IF option = ASC("s") THEN
elem = VAL(ARGUMENT$)
ELSE
elem = 10
END IF
DECLARE vector TYPE int ARRAY elem
FOR i = 0 TO elem - 1
vector[i] = i + 1
NEXT
PRINT ss(vector, elem)
- Output:
prompt$ ./sumsquares 385 prompt$ ./sumsquares -s 1000 333833500
BASIC256
arraybase 1
dim a(6)
a[1] = 1.0
a[2] = 2.0
a[3] = 3.0
a[4] = -1.0
a[5] = -2.0
a[6] = -3.0
sum = 0
for i = 1 to a[?]
sum += a[i] ^ 2
next i
print "The sum of squares is: "; sum
end
BBC BASIC
BBC BASIC cannot have a zero-length array.
DIM vector(5)
vector() = 1, 2, 3, 4, 5, 6
PRINT "Sum of squares = " ; MOD(vector()) ^ 2
- Output:
Sum of squares = 91
IS-BASIC
100 INPUT PROMPT "Number of elements: ":N
110 NUMERIC A(1 TO N)
120 FOR I=1 TO N
130 PRINT I;:INPUT PROMPT ". = ":A(I)
140 NEXT
150 PRINT "The sum of squares is:";SQ(A)
160 DEF SQ(REF T)
170 LET S=0
180 FOR I=LBOUND(T) TO UBOUND(T)
190 LET S=S+T(I)^2
200 NEXT
210 LET SQ=S
220 END DEF
Yabasic
data 1.0, 2.0, 3.0, -1.0, -2.0, -3.0
dim a(5)
sum = 0
for i = 0 to arraysize(a(), 1)
read a(i)
sum = sum + a(i) ^ 2
next i
print "The sum of squares is: ", sum
end
bc
define s(a[], n) {
auto i, s
for (i = 0; i < n; i++) {
s += a[i] * a[i]
}
return(s)
}
BCPL
get "libhdr"
let sumsquares(v, len) =
len=0 -> 0,
!v * !v + sumsquares(v+1, len-1)
let start() be
$( let vector = table 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
writef("%N*N", sumsquares(vector, 10))
$)
- Output:
385
BQN
Similar to the BQN entry in Sum of a series.
SSq ← +´√⁼
•Show SSq 1‿2‿3‿4‿5
•Show SSq ⟨⟩
55
0
Bracmat
( ( sumOfSquares
= sum component
. 0:?sum
& whl
' ( !arg:%?component ?arg
& !component^2+!sum:?sum
)
& !sum
)
& out$(sumOfSquares$(3 4))
& out$(sumOfSquares$(3 4 i*5))
& out$(sumOfSquares$(a b c))
);
- Output:
25 0 a^2+b^2+c^2
Brat
p 1.to(10).reduce 0 { res, n | res = res + n ^ 2 } #Prints 385
C
#include <stdio.h>
double squaredsum(double *l, int e)
{
int i; double sum = 0.0;
for(i = 0 ; i < e ; i++) sum += l[i]*l[i];
return sum;
}
int main()
{
double list[6] = {3.0, 1.0, 4.0, 1.0, 5.0, 9.0};
printf("%lf\n", squaredsum(list, 6));
printf("%lf\n", squaredsum(list, 0));
/* the same without using a real list as if it were 0-element long */
printf("%lf\n", squaredsum(NULL, 0));
return 0;
}
C#
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static int SumOfSquares(IEnumerable<int> list)
{
return list.Sum(x => x * x);
}
static void Main(string[] args)
{
Console.WriteLine(SumOfSquares(new int[] { 4, 8, 15, 16, 23, 42 })); // 2854
Console.WriteLine(SumOfSquares(new int[] { 1, 2, 3, 4, 5 })); // 55
Console.WriteLine(SumOfSquares(new int[] { })); // 0
}
}
C++
Using accumulate
#include <iostream>
#include <numeric>
#include <vector>
double add_square(double prev_sum, double new_val)
{
return prev_sum + new_val*new_val;
}
double vec_add_squares(std::vector<double>& v)
{
return std::accumulate(v.begin(), v.end(), 0.0, add_square);
}
int main()
{
// first, show that for empty vectors we indeed get 0
std::vector<double> v; // empty
std::cout << vec_add_squares(v) << std::endl;
// now, use some values
double data[] = { 0, 1, 3, 1.5, 42, 0.1, -4 };
v.assign(data, data+7);
std::cout << vec_add_squares(v) << std::endl;
return 0;
}
Using inner_product
#include <iostream>
#include <numeric>
#include <vector>
int main()
{
// first, show that for empty vectors we indeed get 0
std::vector<double> v; // empty
std::cout << std::inner_product(begin(v), end(v), begin(v), 0.0) << std::endl;
// now, use some values
double data[] = { 0, 1, 3, 1.5, 42, 0.1, -4 };
v.assign(data, data+7);
std::cout << std::inner_product(begin(v), end(v), begin(v), 0.0) << std::endl;
return 0;
}
Using Boost.Lambda
#include <numeric>
#include <vector>
#include "boost/lambda/lambda.hpp"
double vec_add_squares(std::vector<double>& v)
{
using namespace boost::lambda;
return std::accumulate(v.begin(), v.end(), 0.0, _1 + _2 * _2);
}
Chef
Sum of squares.
First input is length of vector, then rest of input is vector.
Ingredients.
1 g eggs
0 g bacon
Method.
Put bacon into the 1st mixing bowl.
Take eggs from refrigerator.
Square the eggs.
Take bacon from refrigerator.
Put bacon into 2nd mixing bowl.
Combine bacon into 2nd mixing bowl.
Fold bacon into 2nd mixing bowl.
Add the bacon into the 1st mixing bowl.
Ask the eggs until squared.
Pour contents of the 1st mixing bowl into the 1st baking dish.
Serves 1.
Clojure
(defn sum-of-squares [v]
(reduce #(+ %1 (* %2 %2)) 0 v))
CLU
sum_squares = proc (ns: sequence[int]) returns (int)
sum: int := 0
for n: int in sequence[int]$elements(ns) do
sum := sum + n ** 2
end
return(sum)
end sum_squares
start_up = proc ()
po: stream := stream$primary_output()
stream$putl(po, int$unparse(sum_squares(sequence[int]$[])))
stream$putl(po, int$unparse(sum_squares(sequence[int]$[1,2,3,4,5])))
stream$putl(po, int$unparse(sum_squares(sequence[int]$[42])))
end start_up
- Output:
0 55 1764
CoffeeScript
sumOfSquares = ( list ) ->
list.reduce (( sum, x ) -> sum + ( x * x )), 0
Common Lisp
(defun sum-of-squares (vector)
(loop for x across vector sum (expt x 2)))
Or in a functional way:
(defun sum-of-squares (vec)
(reduce #'+ (map 'vector (lambda (x) (* x x)) vec)))
Cowgol
include "cowgol.coh";
include "argv.coh";
# Sum of squares
sub sumsquare(vec: [int32], len: intptr): (out: uint32) is
out := 0;
while len > 0 loop
var cur := [vec];
# make positive first so we can use extra range of uint32
if cur < 0 then cur := -cur; end if;
out := out + cur as uint32 * cur as uint32;
vec := @next vec;
len := len - 1;
end loop;
end sub;
# Read array from command line, allowing empty line (giving 0)
var nums: int32[128];
var len: @indexof nums := 0;
ArgvInit();
loop
var argmt := ArgvNext(); # read number
if argmt == (0 as [uint8]) then
break; # stop when no more numbers
end if;
var dummy: [uint8];
(nums[len], dummy) := AToI(argmt);
len := len + 1;
end loop;
# Print sum of squares of numbers
print_i32(sumsquare(&nums[0], len as intptr));
print_nl();
- Output:
$ ./sumsq.386 0 $ ./sumsq.386 {1..30} 9455 $ ./sumsq.386 512 262144
Crystal
def sum_squares(a)
a.map{|e| e*e}.sum()
end
puts sum_squares([1, 2, 3])
# => 14
D
Iterative Version
T sumSquares(T)(T[] a) pure nothrow @safe @nogc {
T sum = 0;
foreach (e; a)
sum += e ^^ 2;
return sum;
}
void main() {
import std.stdio: writeln;
[3.1, 1.0, 4.0, 1.0, 5.0, 9.0].sumSquares.writeln;
}
- Output:
133.61
Polymorphic Functional Style
import std.stdio, std.algorithm, std.traits, std.range;
auto sumSquares(Range)(Range data) pure nothrow @safe @nogc {
return reduce!q{a + b ^^ 2}(ForeachType!Range(0), data);
}
void main() {
immutable items = [3.1, 1.0, 4.0, 1.0, 5.0, 9.0];
items.sumSquares.writeln;
10.iota.sumSquares.writeln;
}
- Output:
133.61 285
Dart
Iterative Version
sumOfSquares(list) {
var sum=0;
list.forEach((var n) { sum+=(n*n); });
return sum;
}
main() {
print(sumOfSquares([]));
print(sumOfSquares([1,2,3]));
print(sumOfSquares([10]));
}
- Output:
0 14 100
Functional Style Version
num sumOfSquares(List<num> l) => l.map((num x)=>x*x)
.fold(0, (num p,num n)=> p + n);
void main(){
print(sumOfSquares([]));
print(sumOfSquares([1,2,3]));
print(sumOfSquares([10]));
}
- Output:
0 14 100
Delphi
Delphi has standard SumOfSquares function in Math unit:
program SumOfSq;
{$APPTYPE CONSOLE}
uses Math;
type
TDblArray = array of Double;
var
A: TDblArray;
begin
Writeln(SumOfSquares([]):6:2); // 0.00
Writeln(SumOfSquares([1, 2, 3, 4]):6:2); // 30.00
A:= nil;
Writeln(SumOfSquares(A):6:2); // 0.00
A:= TDblArray.Create(1, 2, 3, 4);
Writeln(SumOfSquares(A):6:2); // 30.00
Readln;
end.
Draco
proc nonrec sum_squares([*] int arr) ulong:
ulong sum, item;
word i, len;
sum := 0;
len := dim(arr,1);
if len>0 then
for i from 0 upto len-1 do
item := |arr[i];
sum := sum + item * item
od
fi;
sum
corp
proc nonrec main() void:
type A0 = [0] int,
A1 = [1] int,
A5 = [5] int;
writeln(sum_squares(A0()));
writeln(sum_squares(A1(42)));
writeln(sum_squares(A5(1,2,3,4,5)))
corp
- Output:
0 1764 55
E
def sumOfSquares(numbers) {
var sum := 0
for x in numbers {
sum += x**2
}
return sum
}
EasyLang
nums[] = [ 1 2 3 4 5 ]
for v in nums[]
sum += v * v
.
print sum
Eiffel
class
APPLICATION
create
make
feature -- Initialization
make
local
a: ARRAY [INTEGER]
do
a := <<1, -2, 3>>
print ("%NSquare sum of <<1, 2, 3>>: " + sum_of_square (a).out)
a := <<>>
print ("%NSquare sum of <<>>: " + sum_of_square (a).out)
end
feature -- Access
sum_of_square (a: ITERABLE [INTEGER]): NATURAL
-- sum of square of each items
do
Result := 0
across a as it loop
Result := Result + (it.item * it.item).as_natural_32
end
end
end
Elena
ELENA 6.x :
import system'routines;
import extensions;
SumOfSquares(list)
= list.selectBy::(x => x * x).summarize(new Integer());
public program()
{
console
.printLine(SumOfSquares(new int[]{4, 8, 15, 16, 23, 42}))
.printLine(SumOfSquares(new int[]{1, 2, 3, 4, 5}))
.printLine(SumOfSquares(Array.MinValue))
}
- Output:
2854 55 0
Elixir
iex(1)> Enum.reduce([3,1,4,1,5,9], 0, fn x,sum -> sum + x*x end)
133
Emacs Lisp
(defun sum-of-squares (numbers)
(apply #'+ (mapcar (lambda (k) (* k k)) numbers)))
(sum-of-squares (number-sequence 0 3)) ;=> 14
Erlang
lists:foldl(fun(X, Sum) -> X*X + Sum end, 0, [3,1,4,1,5,9]).
Euler
Using Jensen's Device
begin new i; new A; new sum; sum <- ` formal i; formal lo; formal hi; formal term; begin new temp; label loop; temp <- 0; i <- lo; loop: begin temp <- temp + term; if [ i <- i + 1 ] <= hi then goto loop else 0 end; temp end '; A <- ( 1, 2, 3, 4, 5 ); out sum( @i, 1, length A, `A[i]*A[i]' ) end $
Euphoria
function SumOfSquares(sequence v)
atom sum
sum = 0
for i = 1 to length(v) do
sum += v[i]*v[i]
end for
return sum
end function
Excel
To find the sum of squares of values from A1 to A10, type in any other cell :
=SUMSQ(A1:A10)
The above expression will return zero if there are no values in any cell.
12 3 5 23 13 67 15 9 4 2
5691
F#
[1 .. 10] |> List.fold (fun a x -> a + x * x) 0
[|1 .. 10|] |> Array.fold (fun a x -> a + x * x) 0
Factor
USE: math sequences ;
: sum-of-squares ( seq -- n ) [ sq ] map-sum ;
{ 1.0 2.0 4.0 8.0 16.0 } sum-of-squares
FALSE
0 3 1 4 1 5 9$*\ [$0=~][$*+\]#%.
Fantom
class SumSquares
{
static Int sumSquares (Int[] numbers)
{
Int sum := 0
numbers.each |n| { sum += n * n }
return sum
}
public static Void main ()
{
Int[] n := [,]
echo ("Sum of squares of $n = ${sumSquares(n)}")
n = [1,2,3,4,5]
echo ("Sum of squares of $n = ${sumSquares(n)}")
}
}
Fish
v
\0&
>l?!v:*&+&
>&n;
Forth
: fsum**2 ( addr n -- f )
0e
dup 0= if 2drop exit then
floats bounds do
i f@ fdup f* f+
1 floats +loop ;
create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f,
test 6 fsum**2 f. \ 133.
Fortran
In ISO Fortran 90 orlater, use SUM intrinsic and implicit element-wise array arithmetic:
real, dimension(1000) :: a = (/ (i, i=1, 1000) /)
real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array
real :: result, zresult
result = sum(a*a) ! Multiply array by itself to get squares
result = sum(a**2) ! Use exponentiation operator to get squares
zresult = sum(p*p) ! P is zero-length; P*P is valid zero-length array expression; SUM(P*P) == 0.0 as expected
FreeBASIC
' FB 1.05.0 Win64
Function SumSquares(a() As Double) As Double
Dim As Integer length = UBound(a) - LBound(a) + 1
If length = 0 Then Return 0.0
Dim As Double sum = 0.0
For i As Integer = LBound(a) To UBound(a)
sum += a(i) * a(i)
Next
Return sum
End Function
Dim a(5) As Double = {1.0, 2.0, 3.0, -1.0, -2.0, -3.0}
Dim sum As Double = SumSquares(a())
Print "The sum of the squares is"; sum
Print
Print "Press any key to quit"
Sleep
- Output:
The sum of the squares is 28
Frink
f = {|x| x^2} // Anonymous function which squares its argument
a = [1,2,3,5,7]
println[sum[map[f,a], 0]]
FutureBasic
void local fn DoIt
NSUinteger i, sum = 0
CFArrayRef array = @[@3, @1, @4, @1, @5, @9]
for i = 0 to len(array) -1
sum = sum + intVal( array[i] ) ^ 2
next
print "The sum of squares is: ", sum
end fn
fn DoIt
HandleEvents
- Output:
The sum of squares is: 133
Fōrmulæ
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in its website.
In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solution
Test cases
GAP
# Just multiplying a vector by itself yields the sum of squares (it's an inner product)
# It's necessary to check for the empty vector though
SumSq := function(v)
if Size(v) = 0 then
return 0;
else
return v*v;
fi;
end;
GEORGE
read (n) print ;
0
1, n rep (i)
read print dup mult +
]
print
data
11 8 12 15 6 25 19 33 27 3 37 4
results:
1.100000000000000E+0001 << number of values (11) 8.000000000000000 << 11 data 1.200000000000000E+0001 1.500000000000000E+0001 6.000000000000000 2.500000000000000E+0001 1.900000000000000E+0001 3.300000000000000E+0001 2.700000000000000E+0001 3.000000000000000 3.700000000000000E+0001 4.000000000000000 4.667000000000000E+0003 << sum of squares
Go
- Implementation
package main
import "fmt"
var v = []float32{1, 2, .5}
func main() {
var sum float32
for _, x := range v {
sum += x * x
}
fmt.Println(sum)
}
- Output:
5.25
- Library
package main
import (
"fmt"
"github.com/gonum/floats"
)
var v = []float64{1, 2, .5}
func main() {
fmt.Println(floats.Dot(v, v))
}
- Output:
5.25
Golfscript
{0\{.*+}%}:sqsum;
# usage example
[1 2 3]sqsum puts
Groovy
def array = 1..3
// square via multiplication
def sumSq = array.collect { it * it }.sum()
println sumSq
// square via exponentiation
sumSq = array.collect { it ** 2 }.sum()
println sumSq
- Output:
14 14
Haskell
Three approaches:
versions :: [[Int] -> Int]
versions =
[ sum . fmap (^ 2) -- ver 1
, sum . ((^ 2) <$>) -- ver 2
, foldr ((+) . (^ 2)) 0 -- ver 3
]
main :: IO ()
main =
mapM_ print ((`fmap` [[3, 1, 4, 1, 5, 9], [1 .. 6], [], [1]]) <$> versions)
- Output:
[133,91,0,1] [133,91,0,1] [133,91,0,1]
Icon and Unicon
IDL
print,total(array^2)
Inform 7
Sum Of Squares is a room.
To decide which number is the sum of (N - number) and (M - number) (this is summing):
decide on N + M.
To decide which number is (N - number) squared (this is squaring):
decide on N * N.
To decide which number is the sum of squares of (L - list of numbers):
decide on the summing reduction of squaring applied to L.
When play begins:
say the sum of squares of {};
say line break;
say the sum of squares of {1, 2, 3};
end the story.
Io
list(3,1,4,1,5,9) map(squared) sum
J
ss=: +/ @: *:
That is, sum composed with square. The verb also works on higher-ranked arrays. For example:
ss 3 1 4 1 5 9
133
ss $0 NB. $0 is a zero-length vector
0
x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers
ss x
9.09516 5.19512 5.84173 6.6916
The computation can also be written as a loop. It is shown here for comparison only and is highly non-preferred compared to the version above.
ss1=: 3 : 0
z=. 0
for_i. i.#y do. z=. z+*:i{y end.
)
ss1 3 1 4 1 5 9
133
ss1 $0
0
ss1 x
9.09516 5.19512 5.84173 6.6916
Java
public class SumSquares
{
public static void main(final String[] args)
{
double sum = 0;
int[] nums = {1,2,3,4,5};
for (int i : nums)
sum += i * i;
System.out.println("The sum of the squares is: " + sum);
}
}
JavaScript
ES5
function sumsq(array) {
var sum = 0;
var i, iLen;
for (i = 0, iLen = array.length; i < iLen; i++) {
sum += array[i] * array[i];
}
return sum;
}
alert(sumsq([1,2,3,4,5])); // 55
An alternative using a while loop and Math.pow
function sumsq(array) {
var sum = 0,
i = array.length;
while (i--) sum += Math.pow(array[i], 2);
return sum;
}
alert(sumsq([1,2,3,4,5])); // 55
Functional.reduce("x+y*y", 0, [1,2,3,4,5])
map (JS 1.6) and reduce (JS 1.8)
[3,1,4,1,5,9].map(function (n) { return Math.pow(n,2); }).reduce(function (sum,n) { return sum+n; });
ES6
Two ways of composing a sumOfSquares function
(() => {
'use strict';
// sumOfSquares :: Num a => [a] -> a
const sumOfSquares = xs =>
sum(xs.map(squared));
// sumOfSquares2 :: Num a => [a] -> a
const sumOfSquares2 = xs =>
xs.reduce((a, x) => a + squared(x), 0);
// ---------------------- TEST -----------------------
const main = () => [
sumOfSquares,
sumOfSquares2
].map(
f => f([3, 1, 4, 1, 5, 9])
).join('\n');
// --------------------- GENERIC ---------------------
// squared :: Num a => a -> a
const squared = x =>
Math.pow(x, 2);
// sum :: [Num] -> Num
const sum = xs =>
// The numeric sum of all values in xs.
xs.reduce((a, x) => a + x, 0);
// MAIN ---
return main();
})();
- Output:
133 133
Joy
[1 2 3 4 5] 0 [dup * +] fold.
jq
jq supports both arrays and streams, and so we illustrate how to handle both.
# ss for an input array:
def ss: map(.*.) | add;
# ss for a stream, S, without creating an intermediate array:
def ss(S): reduce S as $x (0; . + ($x * $x) );
We can also use a generic "SIGMA" filter that behaves like the mathematical SIGMA:
# SIGMA(exp) computes the sum of exp over the input array:
def SIGMA(exp): map(exp) | add;
# SIGMA(exp; S) computes the sum of exp over elements of the stream, S,
# without creating an intermediate array:
def SIGMA(exp; S): reduce (S|exp) as $x (0; . + $x);
Finally, a "mapreduce" filter:
def mapreduce(mapper; reducer; zero):
if length == 0 then zero
else map(mapper) | reducer
end;
Demonstration:
def demo(n):
"ss: \( [range(0;n)] | ss )",
"ss(S): \( ss( range(0;n) ) )",
"SIGMA(.*.): \( [range(0;n)] | SIGMA(.*.) )",
"SIGMA(.*.;S): \( SIGMA( .*.; range(0;n) ) )",
"mapreduce(.*.; add; 0): \( [range(0;n)] | mapreduce(.*.; add; 0) )"
;
demo(3) # 0^2 + 1^2 + 2^2
- Output:
"ss: 5"
"ss(S): 5"
"SIGMA(.*.): 5"
"SIGMA(.*.;S): 5"
"mapreduce(.*.; add; 0): 5"
Julia
There are several easy ways to do this in Julia:
julia> sum([1,2,3,4,5].^2)
55
julia> sum([x^2 for x in [1,2,3,4,5]])
55
julia> mapreduce(x->x^2,+,[1:5])
55
julia> sum([x^2 for x in []])
0
K
ss: {+/x*x}
ss 1 2 3 4 5
55
ss@!0
0
Kotlin
Kotlin functional capabilities make this easy. map
can be used to transform the elements of any array, collection, iterable or sequence, and then sum
can be used to compute the sum. So .map {it * it}.sum()
.
However, when the input is a collection, map
will also output a collection. This can be wasteful not only in terms of computation, but also in terms of memory. Piping a .asSequence()
first will make the operation lazy, making it faster, and less memory intensive. A Kotlin Sequence
is the spiritual equivalent of Java’s Stream
Still, Sequences are not free either. Kotlin also offers reduce
and fold
to do the above in a single operation. This is actually much faster than the above 2 approaches.
Finally, a classic for-loop can also be used. Note that because forEach
and fold
are inline functions, these are actually exactly as efficient as the had-written for-loop.
import kotlin.random.Random
import kotlin.system.measureTimeMillis
import kotlin.time.milliseconds
enum class Summer {
MAPPING {
override fun sum(values: DoubleArray) = values.map {it * it}.sum()
},
SEQUENCING {
override fun sum(values: DoubleArray) = values.asSequence().map {it * it}.sum()
},
FOLDING {
override fun sum(values: DoubleArray) = values.fold(0.0) {acc, it -> acc + it * it}
},
FOR_LOOP {
override fun sum(values: DoubleArray): Double {
var sum = 0.0
values.forEach { sum += it * it }
return sum
}
},
;
abstract fun sum(values: DoubleArray): Double
}
fun main() {
run {
val testArrays = listOf(
doubleArrayOf(),
doubleArrayOf(Random.nextInt(100) / 10.0),
DoubleArray(6) { Random.nextInt(100) / 10.0 },
)
for (impl in Summer.values()) {
println("Test with ${impl.name}:")
for (v in testArrays) println(" ${v.contentToString()} -> ${impl.sum(v)}")
}
}
run {
val elements = 100_000
val longArray = DoubleArray(elements) { Random.nextDouble(10.0) }
for (impl in Summer.values()) {
val time = measureTimeMillis {
impl.sum(longArray)
}.milliseconds
println("Summing $elements with ${impl.name} takes: $time")
}
var acc = 0.0
for (v in longArray) acc += v
}
}
- Output:
Test with MAPPING: [] -> 0.0 [3.5] -> 12.25 [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 Test with SEQUENCING: [] -> 0.0 [3.5] -> 12.25 [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 Test with FOLDING: [] -> 0.0 [3.5] -> 12.25 [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 Test with FOR_LOOP: [] -> 0.0 [3.5] -> 12.25 [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87 Summing 100000 elements with MAPPING takes: 31.0ms Summing 100000 elements with SEQUENCING takes: 13.0ms Summing 100000 elements with FOLDING takes: 2.00ms Summing 100000 elements with FOR_LOOP takes: 2.00ms
Lambdatalk
{def sumsq
{lambda {:s}
{+ {S.map {lambda {:i} {* :i :i}} :s}}}}
-> sumsq
{sumsq 1 2 3 4 5}
-> 55
{sumsq 0}
-> 0
Lang5
[1 2 3 4 5] 2 ** '+ reduce .
Lasso
define sumofsquares(values::array) => {
local(sum = 0)
with value in #values do {
#sum += #value * #value
}
return #sum
}
sumofsquares(array(1,2,3,4,5))
- Output:
55
LFE
(defun sum-sq (nums)
(lists:foldl
(lambda (x acc)
(+ acc (* x x)))
0 nums))
Usage:
> (sum-sq '(3 1 4 1 5 9))
133
Liberty BASIC
' [RC] Sum of Squares
SourceList$ ="3 1 4 1 5 9"
'SourceList$ =""
' If saved as an array we'd have to have a flag for last data.
' LB has the very useful word$() to read from delimited strings.
' The default delimiter is a space character, " ".
SumOfSquares =0
n =0
data$ ="666" ' temporary dummy to enter the loop.
while data$ <>"" ' we loop until no data left.
data$ =word$( SourceList$, n +1) ' first data, as a string
NewVal =val( data$) ' convert string to number
SumOfSquares =SumOfSquares +NewVal^2 ' add to existing sum of squares
n =n +1 ' increment number of data items found
wend
n =n -1
print "Supplied data was "; SourceList$
print "This contained "; n; " numbers."
print "Sum of squares is "; SumOfSquares
end
LiveCode
put "1,2,3,4,5" into nums
repeat for each item n in nums
add (n * n) to m
end repeat
put m // 55
Logo
print apply "sum map [? * ?] [1 2 3 4 5] ; 55
Logtalk
sum(List, Sum) :-
sum(List, 0, Sum).
sum([], Sum, Sum).
sum([X| Xs], Acc, Sum) :-
Acc2 is Acc + X,
sum(Xs, Acc2, Sum).
Lua
function squaresum(a, ...) return a and a^2 + squaresum(...) or 0 end
function squaresumt(t) return squaresum(unpack(t)) end
print(squaresumt{3, 5, 4, 1, 7})
M2000 Interpreter
M2000 use two concepts for arrays: standard array like A() and pointer to array as A. Pointer arithmetic not allowed here. Standard arrays are values types, and pointers are reference types. So we can handle an array both with pointer and without.
Dim A() 'make an array with zero items
A=(,) 'make a pointer to array with zero items
A=(1,) 'make a pointer to array with one item
A()=A 'make a copy of array pointed by A to A()
A=A() 'make A a pointer for A()
Dim A(10)=1 'redim A() and pass 1 to each item
k=lambda m=1->{=m:m++} ' a lambda function with a closure m
Dim B(10)<<k() 'fill B() from 1 to 10
A()=B() ' copy B() to A(), A() object stay as is, but new items loaded, so pointer A points to A.
A+=100 ' add 100 to each element of A()
A(0)+=100 ' add 100 to first element
A()=Cons(A,A)
Now A and A() prints a 20 item array (Cons() add a list of arrays)
Print A ' or Print A() print the same
And this is the task, using a lambda function (we can use a standard function, just use Function Square { code here })
Because M2000 modules and functions use stack for passing values, we use read statement to read a value. Functions in expressions has no return to stack because they have own stack, so passing values are filled in a fresh stack in every call. This not hold if we call function using Call (as a module), so stack is passed from parent (caller).
When we pass an array in stack, a pointer to array (to one of two interfaces) and depends the name type of a read to make this a copy or a pointer to array. So here we use: read a as a pointer to array (so it is a by reference pass). We can use Read a() and then a=a() (and remove Link a to a()), so we use by value pass, and that is a decision from callee, not the caller (this happen for objects)
Module Checkit {
A=(1,2,3,4,5)
Square=lambda -> {
read a
if len(a)=0 then =0: exit
link a to a()
\\ make sum same type as a(0)
sum=a(0)-a(0)
for i=0 to len(a)-1 {sum+=a(i)*a(i)}
=sum
}
Print Square(a)=55
Print Square((,))=0 ' empty array
Dim k(10)=2, L()
Print Square(K())=40
Print Square(L())=0
A=(1@,2@,3@,4@,5@)
X=Square(A)
Print Type$(X)="Decimal", X=55@
}
Checkit
Maple
F := V -> add(v^2, v in V):
F(<1,2,3,4,5>);
Mathematica /Wolfram Language
As a function 1:
SumOfSquares[x_]:=Total[x^2]
SumOfSquares[{1,2,3,4,5}]
As a function 2:
SumOfSquares[x_]:=x.x
SumOfSquares[{1,2,3,4,5}]
Pure function 1: (postfix operator in the following examples)
{1,2,3,4,5} // Total[#^2] &
Pure function 2:
{1, 2, 3, 4, 5} // #^2 & // Total
Pure function 3:
{1, 2, 3, 4, 5} // #.#&
MATLAB
function [squaredSum] = sumofsquares(inputVector)
squaredSum = sum( inputVector.^2 );
Maxima
nums : [3,1,4,1,5,9];
sum(nums[i]^2,i,1,length(nums));
or
nums : [3,1,4,1,5,9];
lsum(el^2, el, nums);
Mercury
:- module sum_of_squares.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module int, list.
main(!IO) :-
io.write_int(sum_of_squares([3, 1, 4, 1, 5, 9]), !IO),
io.nl(!IO).
:- func sum_of_squares(list(int)) = int.
sum_of_squares(Ns) = list.foldl((func(N, Acc) = Acc + N * N), Ns, 0).
min
((bool) ((dup *) (+) map-reduce) (pop 0) if) :sq-sum
(1 2 3 4 5) sq-sum puts
() sq-sum puts
- Output:
55 0
MiniScript
sumOfSquares = function(seq)
sum = 0
for item in seq
sum = sum + item*item
end for
return sum
end function
print sumOfSquares([4, 8, 15, 16, 23, 42])
print sumOfSquares([1, 2, 3, 4, 5])
print sumOfSquares([])
- Output:
2854 55 0
МК-61/52
x^2 + С/П БП 00
Modula-3
MODULE SumSquares EXPORTS Main;
IMPORT IO, Fmt;
TYPE RealArray = ARRAY OF REAL;
PROCEDURE SumOfSquares(x: RealArray): REAL =
VAR sum := 0.0;
BEGIN
FOR i := FIRST(x) TO LAST(x) DO
sum := sum + x[i] * x[i];
END;
RETURN sum;
END SumOfSquares;
BEGIN
IO.Put(Fmt.Real(SumOfSquares(RealArray{3.0, 1.0, 4.0, 1.0, 5.0, 9.0})));
IO.Put("\n");
END SumSquares.
MOO
@verb #100:sum_squares this none this rd
@program #100:sum_squares
sum = 0;
list = args[1];
for i in (list)
sum = sum + (i^2);
endfor
player:tell(toliteral(list), " => ", sum);
.
{{out}}
;#100:sum_squares({3,1,4,1,5,9})
{3, 1, 4, 1, 5, 9} => 133
;#100:sum_squares({})
{} => 0
MUMPS
SUMSQUARE(X)
;X is assumed to be a list of numbers separated by "^"
NEW RESULT,I
SET RESULT=0,I=1
FOR QUIT:(I>$LENGTH(X,"^")) SET RESULT=($PIECE(X,"^",I)*$PIECE(X,"^",I))+RESULT,I=I+1
QUIT RESULT
Nanoquery
def sum_squares(vector)
if len(vector) = 0
return 0
end
sum = 0
for n in vector
sum += n ^ 2
end
return sum
end
println sum_squares({})
println sum_squares({1, 2, 3, 4, 5})
println sum_squares({10, 3456, 2, 6})
- Output:
0 55 11944076
Nemerle
SS(x : list[double]) : double
{
|[] => 0.0
|_ => x.Map(fun (x) {x*x}).FoldLeft(0.0, _+_)
}
NetRexx
/*NetRexx *************************************************************
* program to sum the squares of a vector of fifteen numbers.
* translated from REXX
* 14.05.2013 Walter Pachl
**********************************************************************/
numeric digits 50 /*allow 50-digit # (default is 9)*/
v='-100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12' /* vector with some #s. */
n=v.words()
x=''
sum=0 /*initialize SUM to zero. */
/*if vector is empty, sum = zero.*/
loop Until x='' /*loop until list is exhausted */
Parse v x v /* pick next number */
If x>'' Then /* there is a number */
sum=sum + x**2 /*add its square to the sum. */
end
say "The sum of" n "elements for the V vector is:" sum
- Output:
The sum of 15 elements for the V vector is: 10650.25
NewLISP
(apply + (map (fn(x) (* x x)) '(3 1 4 1 5 9)))
-> 133
(apply + (map (fn(x) (* x x)) '()))
-> 0
Nim
import math, sequtils
proc sumSquares[T: SomeNumber](a: openArray[T]): T =
sum(a.mapIt(it * it))
let a1 = [1, 2, 3, 4, 5]
echo a1, " → ", sumSquares(a1)
let a2: seq[float] = @[]
echo a2, " → ", sumSquares(a2)
- Output:
[1, 2, 3, 4, 5] → 55 @[] → 0.0
Nu
def sqsum []: {
reduce -f 0 {|x res| $x * $x + $res }
}
Oberon-2
MODULE SumSquares;
IMPORT Out;
VAR
A1:ARRAY 6 OF REAL;
PROCEDURE Init;
BEGIN
A1[0] := 3.0; A1[1] := 1.0; A1[2] := 4.0; A1[3] := 5.0; A1[4] := 9.0;
END Init;
PROCEDURE SumOfSquares(VAR arr:ARRAY OF REAL):REAL;
VAR
i:LONGINT;
sum:REAL;
BEGIN
sum := 0.0;
FOR i := 0 TO LEN(arr)-1 DO
sum := sum + arr[i] * arr[i]
END;
RETURN sum
END SumOfSquares;
BEGIN
Init;
Out.Real(SumOfSquares(A1),0);
Out.Ln
END SumSquares.
- Output:
1.32E+02
Objeck
bundle Default {
class Sum {
function : native : SquaredSum(values : Float[]) ~ Float {
sum := 0.0;
for(i := 0 ; i < values->Size() ; i += 1;) {
sum += (values[i] * values[i]);
};
return sum;
}
function : Main(args : String[]) ~ Nil {
SquaredSum([3.0, 1.0, 4.0, 1.0, 5.0, 9.0])->PrintLine();
}
}
}
OCaml
List.fold_left (fun sum a -> sum + a * a) 0 ints
List.fold_left (fun sum a -> sum +. a *. a) 0. floats
Octave
a = [1:10];
sumsq = sum(a .^ 2);
Oforth
#sq [1, 1.2, 3, 4.5 ] map sum
Ol
(define (sum-of-squares l)
(fold + 0 (map * l l)))
(print (sum-of-squares '(1 2 3 4 5 6 7 8 9 10)))
; ==> 385
Order
#include <order/interpreter.h>
ORDER_PP(8to_lit(
8seq_fold(8plus, 0,
8seq_map(8fn(8X, 8times(8X, 8X)), 8seq(3, 1, 4, 1, 5, 9)))
))
Oz
declare
fun {SumOfSquares Xs}
for X in Xs sum:S do
{S X*X}
end
end
in
{Show {SumOfSquares [3 1 4 1 5 9]}}
PARI/GP
Generic
It is possible to apply a function, in this case ^2 to each element of an iterable and sum the result:
ss(v)={
sum(i=1,#v,v[i]^2)
};
Specific
For this particular task the product of a row matrix and its transpose is the sum of squares:
n=[2,5,23]
print(n*n~)
n=[]
print(n*n~)
- Output:
558 0
Pascal
Example from the documenation of the run time library:
Program Example45;
{ Program to demonstrate the SumOfSquares function. }
Uses math;
Var
I : 1..100;
ExArray : Array[1..100] of Float;
begin
Randomize;
for I:=low(ExArray) to high(ExArray) do
ExArray[i]:=(Random-Random)*100;
Writeln('Max : ',MaxValue(ExArray):8:4);
Writeln('Min : ',MinValue(ExArray):8:4);
Writeln('Sum squares : ',SumOfSquares(ExArray):8:4);
Writeln('Sum squares (b) : ',SumOfSquares(@ExArray[1],100):8:4);
end.
PascalABC.NET
##
var vector := Arr(1,2,3,4,5,6,7);
vector.Sum(x -> x * x).Println
- Output:
140
Perl
sub sum_of_squares {
my $sum = 0;
$sum += $_**2 foreach @_;
return $sum;
}
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";
or
use List::Util qw(reduce);
sub sum_of_squares {
reduce { $a + $b **2 } 0, @_;
}
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";
Phix
function sum_of_squares(sequence s) return sum(sq_power(s,2)) end function ?apply({{},{3,1,4,1,5,9},tagset(10)},sum_of_squares)
- Output:
{0,133,385}
Phixmonti
0 tolist
10 for 0 put endfor
0 swap len for
get
2 power rot + swap
endfor
drop print /# 385 #/
PHP
function sum_squares(array $args) {
return array_reduce(
$args, create_function('$x, $y', 'return $x+$y*$y;'), 0
);
}
In PHP5.3 support for anonymous functions was reworked. While the above code would still work, it is suggested to use
function sum_squares(array $args) {
return array_reduce($args, function($x, $y) {
return $x+$y*$y;
}, 0);
}
Usage for both examples: sum_squares(array(1,2,3,4,5)); // 55
Picat
go =>
List = 1..666,
println(sum_squares(List)),
println(sum_squares([])),
nl.
sum_squares([]) = 0.
sum_squares(List) = sum([I*I : I in List]).
- Output:
98691321 0
PicoLisp
: (sum '((N) (* N N)) (3 1 4 1 5 9))
-> 133
: (sum '((N) (* N N)) ())
-> 0
PL/0
PL/0 has no arrays but they can be simulated.
const maxlist = 5;
var sub, v, l1, l2, l3, l4, l5, sum;
procedure getelement;
begin
if sub = 1 then v := l1;
if sub = 2 then v := l2;
if sub = 3 then v := l3;
if sub = 4 then v := l4;
if sub = 5 then v := l5;
end;
procedure setelement;
begin
if sub = 1 then l1 := v;
if sub = 2 then l2 := v;
if sub = 3 then l3 := v;
if sub = 4 then l4 := v;
if sub = 5 then l5 := v;
end;
procedure sumofsquares;
begin
sub := 0;
sum := 0;
while sub < maxlist do begin
sub := sub + 1;
call getelement;
sum := sum + v * v
end;
end;
begin
sub := 0;
while sub < maxlist do begin
sub := sub + 1;
v := sub;
call setelement;
end;
call sumofsquares;
! sum;
end.
- Output:
55
PL/I
declare A(10) float initial (10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
put (sum(A**2));
PL/M
... under CP/M (or an emulator)
100H: /* CALCULATE THE SUM OF THE SQUARES OF THE ELEMENTS OF AN ARRAY */
/* CP/M BDOS SYSTEM CALL AND I/O ROUTINES */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PR$NL: PROCEDURE; CALL PR$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END;
PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH */
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR ( 6 )BYTE, W BYTE;
V = N;
W = LAST( N$STR );
N$STR( W ) = '$';
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PR$STRING( .N$STR( W ) );
END PR$NUMBER;
/* TASK */
/* RETURNS THE SUM OF THE SQUARES OF THE ARRAY AT A$PTR, UB MUST BE THE */
/* UB MUST BE THE UPPER-BOUND OF THE ARRAY */
SUM$OF$SQUARES: PROCEDURE( A$PTR, UB )ADDRESS;
DECLARE ( A$PTR, UB ) ADDRESS;
DECLARE ( I, SUM ) ADDRESS;
DECLARE A BASED A$PTR ( 0 )ADDRESS;
SUM = 0;
DO I = 0 TO UB;
SUM = SUM + ( A( I ) * A( I ) );
END;
RETURN SUM;
END SUM$OF$SQUARES;
DECLARE VALUES ( 5 )ADDRESS INITIAL( 1, 2, 3, 4, 5 );
CALL PR$NUMBER( SUM$OF$SQUARES( .VALUES, LAST( VALUES ) ) );
EOF
Plain English
To run:
Start up.
Create a list.
Sum the squares of the list giving a ratio.
Destroy the list.
Write "Sum of squares: " then the ratio on the console.
Wait for the escape key.
Shut down.
An element is a thing with a ratio.
A list is some elements.
To add a ratio to a list:
Allocate memory for an element.
Put the ratio into the element's ratio.
Append the element to the list.
To create a list:
Add 3-1/10 to the list.
Add 1/1 to the list.
Add 4/1 to the list.
Add 1/1 to the list.
Add 5/1 to the list.
Add 9/1 to the list.
To sum the squares of a list giving a ratio:
Put 0 into the ratio.
Get an element from the list.
Loop.
If the element is nil, exit.
Add the element's ratio times the element's ratio to the ratio.
Put the element's next into the element.
Repeat.
- Output:
Sum of squares: 133-61/100
Pop11
define sum_squares(v);
lvars s = 0, j;
for j from 1 to length(v) do
s + v(j)*v(j) -> s;
endfor;
s;
enddefine;
sum_squares({1 2 3 4 5}) =>
PostScript
/sqrsum{
/x exch def
/sum 0 def
/i 0 def
x length 0 eq
{}
{
x length{
/sum sum x i get 2 exp add def
/i i 1 add def
}repeat
}ifelse
sum ==
}def
[3 1 4 1 5 9] 0 {dup * +} fold
PowerShell
function Get-SquareSum ($a) {
if ($a.Length -eq 0) {
return 0
} else {
$x = $a `
| ForEach-Object { $_ * $_ } `
| Measure-Object -Sum
return $x.Sum
}
}
Prolog
sum([],0). sum([H|T],S) :- sum(T, S1), S is S1 + (H * H).
PureBasic
Procedure SumOfSquares(List base())
ForEach base()
Sum + base()*base()
Next
ProcedureReturn Sum
EndProcedure
Python
Using generator expression
sum(x * x for x in [1, 2, 3, 4, 5])
# or
sum(x ** 2 for x in [1, 2, 3, 4, 5])
# or
sum(pow(x, 2) for x in [1, 2, 3, 4, 5])
Functional versions:
# using lambda and map:
sum(map(lambda x: x * x, [1, 2, 3, 4, 5]))
# or
sum(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))
# or
sum(map(lambda x: pow(x, 2), [1, 2, 3, 4, 5]))
# using pow and repeat
from itertools import repeat
sum(map(pow, [1, 2, 3, 4, 5], repeat(2)))
# using starmap and mul
from itertools import starmap
from operator import mul
a = [1, 2, 3, 4, 5]
sum(starmap(mul, zip(a, a)))
# using reduce
from functools import reduce
powers_of_two = (x * x for x in [1, 2, 3, 4, 5])
reduce(lambda x, y : x + y, powers_of_two)
# or
from operator import add
powers_of_two = (x * x for x in [1, 2, 3, 4, 5])
reduce(add, powers_of_two)
# or using a bit more complex lambda
reduce(lambda a, x: a + x*x, [1, 2, 3, 4, 5])
Using NumPy:
import numpy as np
a = np.array([1, 2, 3, 4, 5])
np.sum(a ** 2)
Q
ssq:{sum x*x}
Quackery
[ 0 swap witheach [ 2 ** + ] ] is sumofsquares ( [ --> n )
- Output:
Testing in the Quackery shell.
> quackery Welcome to Quackery. Enter "leave" to leave the shell. /O> [ 0 swap witheach [ 2 ** + ] ] is sumofsquares ... ' [ 2 3 5 7 11 13 17 ] sumofsquares echo cr ... ' [ ] sumofsquares echo cr ... leave ... 666 0 Sayonara.
R
arr <- c(1,2,3,4,5)
result <- sum(arr^2)
Racket
#lang racket
(for/sum ([x #(3 1 4 1 5 9)]) (* x x))
Raku
(formerly Perl 6)
say [+] map * ** 2, (3, 1, 4, 1, 5, 9);
If this expression seems puzzling, note that * ** 2
is equivalent to {$^x ** 2}
— the leftmost asterisk is not the multiplication operator but the Whatever
star, which specifies currying behavior.
Another convenient way to distribute the exponentiation is via the cross metaoperator, which
as a list infix is looser than comma in precedence but tighter than the reduction list operator:
say [+] <3 1 4 1 5 9> X** 2
Raven
define sumOfSqrs use $lst
0 $lst each dup * +
[ 1 2 3 4] sumOfSqrs "Sum of squares: %d\n" print
- Output:
Sum of squares: 30
Red
Red [
date: 2021-10-25
red-version: 0.6.4
description: "Find the sum of squares of a numeric vector"
]
sum-squares: function [
"Returns the sum of squares of all values in a block"
values [any-list! vector!]
][
result: 0
foreach value values [result: value * value + result]
result
]
print sum-squares []
print sum-squares [1 2 0.5]
- Output:
0 5.25
Refal
$ENTRY Go {
= <Prout <SquareSum 1 2 3 4 5>>
};
SquareSum {
= 0;
s.N e.rest = <+ <* s.N s.N> <SquareSum e.rest>>;
};
- Output:
55
ReScript
With integers:
let sumOfSquares = (acc, item) => { acc + item * item }
Js.log(Js.Array2.reduce([10, 2, 4], sumOfSquares, 0))
With floats:
let sumOfSquares = (acc, item) => { acc +. item *. item }
Js.log(Js.Array2.reduce([10., 2., 4.], sumOfSquares, 0.))
REXX
input from pgm
/*REXX program sums the squares of the numbers in a (numeric) vector of 15 numbers. */
numeric digits 100 /*allow 100─digit numbers; default is 9*/
v= -100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12 /*define a vector with fifteen numbers.*/
#=words(v) /*obtain number of words in the V list.*/
$= 0 /*initialize the sum ($) to zero. */
do k=1 for # /*process each number in the V vector. */
$=$ + word(v,k)**2 /*add a squared element to the ($) sum.*/
end /*k*/ /* [↑] if vector is empty, then sum=0.*/
/*stick a fork in it, we're all done. */
say 'The sum of ' # " squared elements for the V vector is: " $
output using an internal vector (list) of numbers:
The sum of 15 squared elements for the V vector is: 10650.25
input from C.L.
/*REXX program sums the squares of the numbers in a (numeric) vector of 15 numbers. */
numeric digits 100 /*allow 100─digit numbers; default is 9*/
parse arg v /*get optional numbers from the C.L. */
if v='' then v= -100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12 /*Not specified? Use default*/
#=words(v) /*obtain number of words in V*/
say 'The vector of ' # " elements is: " space(v) /*display the vector numbers.*/
$= 0 /*initialize the sum ($) to zero. */
do until v==''; parse var v x v /*process each number in the V vector. */
$=$ + x**2 /*add a squared element to the ($) sum.*/
end /*until*/ /* [↑] if vector is empty, then sum=0.*/
say /*stick a fork in it, we're all done. */
say 'The sum of ' # " squared elements for the V vector is: " $
output using a vector (list) of numbers from the command line:
The vector of 10 elements is: -1000 -100 -10 -1 0 +1 +10 100 1000 1e20 The sum of 10 squared elements for the V vector is: 10000000000000000000000000000000002020202
Ring
aList = [1,2,3,4,5]
see sumOfSquares(aList)
func sumOfSquares sos
sumOfSquares = 0
for i=1 to len(sos)
sumOfSquares = sumOfSquares + pow(sos[i],2)
next
return sumOfSquares
RPL
Zero-length vectors don't exist in RPL, so there's no need to tackle this case:
≪ DUP DOT ≫ '∑SQV' STO
If we really need zero-length objects, we can use lists:
≪ 0 SWAP
IF DUP SIZE THEN
1 OVER SIZE FOR j
DUP j GET SQ + NEXT
END DROP
≫ '∑SQL' STO
Using RPL 1993:
≪ IF DUP SIZE THEN SQ ∑LIST ELSE SIZE END ≫ '∑SQL' STO
[ 1 2 3 4 5 ] ∑SQV { 1 2 3 4 5 } ∑SQL { } ∑SQL
- Output:
3: 55 2: 55 1: 0
Ruby
[3,1,4,1,5,9].sum(0){|x| x*x}
Run BASIC
list$ = "1,2,3,4,5"
print sumOfSquares(list$)
FUNCTION sumOfSquares(sos$)
while word$(sos$,i+1,",") <> ""
i = i + 1
sumOfSquares = sumOfSquares + val(word$(sos$,i,","))^2
wend
END FUNCTION
Rust
fn sq_sum(v: &[f64]) -> f64 {
v.iter().fold(0., |sum, &num| sum + num*num)
}
fn main() {
let v = vec![3.0, 1.0, 4.0, 1.0, 5.5, 9.7];
println!("{}", sq_sum(&v));
let u : Vec<f64> = vec![];
println!("{}", sq_sum(&u));
}
Sather
class MAIN is
sqsum(s, e:FLT):FLT is
return s + e*e;
end;
sum_of_squares(v :ARRAY{FLT}):FLT is
return (#ARRAY{FLT}(|0.0|).append(v)).reduce(bind(sqsum(_,_)));
end;
main is
v :ARRAY{FLT} := |3.0, 1.0, 4.0, 1.0, 5.0, 9.0|;
#OUT + sum_of_squares(v) + "\n";
end;
end;
Scala
Unfortunately there is no common "Numeric" class that Int and Double both extend, since Scala's number representation maps closely to Java's. Those concerned about precision can define a similar procedure for integers.
def sum_of_squares(xs: Seq[Double]) = xs.foldLeft(0) {(a,x) => a + x*x}
Scheme
(define (sum-of-squares l)
(apply + (map * l l)))
> (sum-of-squares (list 3 1 4 1 5 9)) 133
Seed7
$ include "seed7_05.s7i";
include "float.s7i";
const array float: list1 is [] (3.0, 1.0, 4.0, 1.0, 5.0, 9.0);
const array float: list2 is 0 times 0.0;
const func float: squaredSum (in array float: floatList) is func
result
var float: sum is 0.0;
local
var float: number is 0.0;
begin
for number range floatList do
sum +:= number ** 2;
end for;
end func;
const proc: main is func
begin
writeln(squaredSum(list1));
writeln(squaredSum(list2));
end func;
Sidef
func sum_of_squares(vector) {
var sum = 0;
vector.each { |n| sum += n**2 };
return sum;
}
say sum_of_squares([]); # 0
say sum_of_squares([1,2,3]); # 14
Slate
{1. 2. 3} reduce: [|:x :y| y squared + x].
{} reduce: [|:x :y| y squared + x] ifEmpty: [0].
Smalltalk
#(3 1 4 1 5 9) inject: 0 into: [:sum :aNumber | sum + aNumber squared]
SNOBOL4
define('ssq(a)i') :(ssq_end)
ssq i = i + 1; ssq = ssq + (a<i> * a<i>) :s(sumsq)f(return)
ssq_end
* # Fill array, test and display
str = '1 2 3 5 7 11 13 17 19 23'; a = array(10)
loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)
output = str ' -> ' sumsq(a)
end
- Output:
1 2 3 5 7 11 13 17 19 23 -> 1557
SQL
select sum(x*x) from vector
Note that this assumes that the values in our vector are named x
.
Standard ML
foldl (fn (a, sum) => sum + a * a) 0 ints
foldl (fn (a, sum) => sum + a * a) 0.0 reals
Stata
Mata
a = 1..100
sum(a:^2)
338350
a = J(0, 1, .)
length(a)
0
sum(a:^2)
0
Swift
func sumSq(s: [Int]) -> Int {
return s.map{$0 * $0}.reduce(0, +)
}
Tailspin
templates ssq
when <[](0)> do 0 !
otherwise $... -> $*$ -> ..=Sum&{of: :()} !
end ssq
[] -> ssq -> !OUT::write // outputs 0
[1..5] -> ssq -> !OUT::write // outputs 55
Tcl
package require Tcl 8.6
namespace path ::tcl::mathop
# {*} is like apply in Scheme--it turns a list into multiple arguments
proc sum_of_squares lst {
+ {*}[lmap x $lst {* $x $x}]
}
puts [sum_of_squares {1 2 3 4}]; # ==> 30
puts [sum_of_squares {}]; # ==> 0
Trith
[3 1 4 1 5 9] 0 [dup * +] foldl
TUSCRIPT
$$ MODE TUSCRIPT
array="3'1'4'1'5'9",sum=0
LOOP a=array
sum=sum+(a*a)
ENDLOOP
PRINT sum
- Output:
133
UnixPipes
folder() {
(read B; res=$( expr $1 \* $1 ) ; test -n "$B" && expr $res + $B || echo $res)
}
fold() {
(while read a ; do
fold | folder $a
done)
}
(echo 3; echo 1; echo 4;echo 1;echo 5; echo 9) | fold
UNIX Shell
sum_squares () {
_r=0
for _n
do
: "$((_r += _n * _n))"
done
echo "$_r"
}
sum_squares 3 1 4 1 5 9
- Output:
133
Ursala
The ssq function defined below zips two copies of its argument together, maps the product function to all pairs, and then sums the result by way of the reduction operator, -:.
#import nat
ssq = sum:-0+ product*iip
#cast %n
main = ssq <21,12,77,0,94,23,96,93,72,72,79,24,8,50,9,93>
- Output:
62223
V
[sumsq [dup *] map 0 [+] fold].
[] sumsq
=0
[1 2 3] sumsq
=14
VBA
Public Sub sum_of_squares()
Debug.Print WorksheetFunction.SumSq([{1,2,3,4,5,6,7,8,9,10}])
End Sub
- Output:
385
VBScript
Function sum_of_squares(arr)
If UBound(arr) = -1 Then
sum_of_squares = 0
End If
For i = 0 To UBound(arr)
sum_of_squares = sum_of_squares + (arr(i)^2)
Next
End Function
WScript.StdOut.WriteLine sum_of_squares(Array(1,2,3,4,5))
WScript.StdOut.WriteLine sum_of_squares(Array())
- Output:
55 0
Visual Basic .NET
Private Shared Function sumsq(ByVal i As ICollection(Of Integer)) As Integer
If i Is Nothing OrElse i.Count = 0 Then
Return 0
End If
Return i.[Select](Function(x) x * x).Sum()
End Function
Private Shared Sub Main()
Dim a As Integer() = New Integer() {1, 2, 3, 4, 5}
' 55
Console.WriteLine(sumsq(a))
For K As Integer = 0 To 16
Console.WriteLine("SumOfSquares({0}) = {1}", K, SumOfSquares(K))
Next
End Sub
Function SumOfSquares(ByVal Max As Integer)
Dim Square As Integer = 0
Dim Add As Integer = 1
Dim Sum As Integer = 0
For J As Integer = 0 To Max - 1
Square += Add
Add += 2
Sum += Square
Next
Return Sum
End Function
Function SumOfSquaresByMult(ByVal Max As Integer)
Dim Sum As Integer = 0
For J As Integer = 1 To Max
Sum += J * J
Next
Return Sum
End Function
- Output:
55 SumOfSquares(0) = 0 SumOfSquares(1) = 1 SumOfSquares(2) = 5 SumOfSquares(3) = 14 SumOfSquares(4) = 30 SumOfSquares(5) = 55 SumOfSquares(6) = 91 SumOfSquares(7) = 140 SumOfSquares(8) = 204 SumOfSquares(9) = 285 SumOfSquares(10) = 385 SumOfSquares(11) = 506 SumOfSquares(12) = 650 SumOfSquares(13) = 819 SumOfSquares(14) = 1015 SumOfSquares(15) = 1240 SumOfSquares(16) = 1496
VTL-2
1000 :1)=1
1010 :2)=2
1020 :3)=3
1030 :4)=4
1040 :5)=5
1050 L=5
1060 #=2000
1070 ?=S
1080 #=9999
2000 R=!
2010 S=0
2020 I=1
2030 #=I<L+(I=L)=0*R
2040 S=I*I+S
2050 I=I+1
2060 #=2030
- Output:
55
Wortel
@sum !*^@sq [3 1 4 1 5 9] ; returns 133
@sum !*^@sq [] ; returns 0
As a function:
^(@sum *^@sq)
Iterative function:
&a [@var sum 0 @for x of a :!+sum *x x sum]
Wren
var sumSquares = Fn.new { |v| v.reduce(0) { |sum, n| sum + n * n } }
var v = [1, 2, 3, -1, -2, -3]
System.print("Vector : %(v)")
System.print("Sum of squares : %(sumSquares.call(v))")
- Output:
Vector : [1, 2, 3, -1, -2, -3] Sum of squares : 28
XLISP
The task specification calls for a function that takes a numeric vector. If you want a function that takes a linked list (which would be more idiomatic), just extract the inner function SUMSQ and use that instead of SUM-OF-SQUARES.
(defun sum-of-squares (vec)
(defun sumsq (xs)
(if (null xs)
0
(+ (expt (car xs) 2) (sumsq (cdr xs)))))
(sumsq (vector->list vec)))
(define first-seven-primes #(2 3 5 7 11 13 17))
(define zero-length-vector #())
(print `(the sum of the squares of the first seven prime numbers is ,(sum-of-squares first-seven-primes)))
(print `(the sum of the squares of no numbers at all is ,(sum-of-squares zero-length-vector)))
- Output:
(THE SUM OF THE SQUARES OF THE FIRST SEVEN PRIME NUMBERS IS 666) (THE SUM OF THE SQUARES OF NO NUMBERS AT ALL IS 0)
XPL0
include c:\cxpl\codes; \intrinsic 'code' declarations
func SumSq(V, L);
int V, L;
int S, I;
[S:= 0;
for I:= 0 to L-1 do S:= S+sq(V(I));
return S;
]; \SumSq
[IntOut(0, SumSq([1,2,3,4,5,6,7,8,9,10], 10)); CrLf(0);
IntOut(0, SumSq([0], 0)); CrLf(0); \zero-length vector "[]" doesn't compile
]
- Output:
385 0
zkl
T().reduce(fcn(p,n){ p + n*n },0) //-->0
T(3,1,4,1,5,9).reduce(fcn(p,n){ p + n*n },0.0) //-->133.0
[1..5].reduce(fcn(p,n){ p + n*n },0) //-->55
- Programming Tasks
- Arithmetic operations
- 0815
- 11l
- 360 Assembly
- 8086 Assembly
- ACL2
- Action!
- ActionScript
- Ada
- Aime
- ALGOL 60
- ALGOL 68
- ALGOL W
- Alore
- APL
- AppleScript
- Arturo
- Astro
- Asymptote
- AutoHotkey
- AWK
- BASIC
- BaCon
- BASIC256
- BBC BASIC
- IS-BASIC
- Yabasic
- Bc
- BCPL
- BQN
- Bracmat
- Brat
- C
- C sharp
- C++
- Boost.Lambda
- Chef
- Clojure
- CLU
- CoffeeScript
- Common Lisp
- Cowgol
- Crystal
- D
- Dart
- Delphi
- Draco
- E
- EasyLang
- Eiffel
- Elena
- Elixir
- Emacs Lisp
- Erlang
- Euler
- Euphoria
- Excel
- F Sharp
- Factor
- FALSE
- Fantom
- Fish
- Forth
- Fortran
- FreeBASIC
- Frink
- FutureBasic
- Fōrmulæ
- GAP
- GEORGE
- Go
- Golfscript
- Groovy
- Haskell
- Icon
- Unicon
- IDL
- Inform 7
- Io
- J
- Java
- JavaScript
- Functional
- Joy
- Jq
- Julia
- K
- Kotlin
- Lambdatalk
- Lang5
- Lasso
- LFE
- Liberty BASIC
- LiveCode
- Logo
- Logtalk
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Maxima
- Mercury
- Min
- MiniScript
- МК-61/52
- Modula-3
- MOO
- MUMPS
- Nanoquery
- Nemerle
- NetRexx
- NewLISP
- Nim
- Nu
- Oberon-2
- Objeck
- OCaml
- Octave
- Oforth
- Ol
- Order
- Oz
- PARI/GP
- Pascal
- Math
- PascalABC.NET
- Perl
- Phix
- Phixmonti
- PHP
- Picat
- PicoLisp
- PL/0
- PL/I
- PL/M
- Plain English
- Pop11
- PostScript
- Initlib
- PowerShell
- Prolog
- PureBasic
- Python
- Q
- Quackery
- R
- Racket
- Raku
- Raven
- Red
- Refal
- ReScript
- REXX
- Ring
- RPL
- Ruby
- Run BASIC
- Rust
- Sather
- Scala
- Scheme
- Seed7
- Sidef
- Slate
- Smalltalk
- SNOBOL4
- SQL
- Standard ML
- Stata
- Swift
- Tailspin
- Tcl
- Trith
- TUSCRIPT
- UnixPipes
- UNIX Shell
- Ursala
- V
- VBA
- VBScript
- Visual Basic .NET
- VTL-2
- Wortel
- Wren
- XLISP
- XPL0
- Zkl
- Pages with too many expensive parser function calls