Sum of squares: Difference between revisions

{{task|Arithmetic operations}}

 

 

=={{header|ACL2}}==

(if (endp xs)

0

(+ (* (first xs) (first xs))

 

=={{header|ActionScript}}==

{

var sum:Number = 0;

sum += vector[i]*vector[i];

return sum;

 

=={{header|Ada}}==

 

procedure Test_Sum_Of_Squares is

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

{{out}}

<pre>

1.33000E+02

</pre>

=={{header|Aime}}==

squaredsum(list l)

{

 

s = 0;

while (i) {

s += sq(l[i += 1]);

}

 

}

 

list l;

 

 

o_form("~\n", squaredsum(l));

 

{{out}}

<pre>14

0

4.5</pre>

 

=={{header|ALGOL 68}}==

 

The computation can be written as a loop.

REAL sum := 0;

FOR i FROM LWB argv TO UPB argv DO

test:(

printf(($g(0)l$,sum of squares([]REAL(3, 1, 4, 1, 5, 9))));

{{out}}

<pre>

 

{{trans|python}}

 

PROC map = ( PROC(REAL)REAL func, []REAL argv)REAL:

sum := 0;

printf(($g(0)l$, ((REAL argv)REAL: sum +:= argv ** 2) MAP data ))

{{out}}

<pre>

133

133

</pre>

 

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

real procedure sumSquares ( real array vector ( * )

; integer value lb

r_format := "A"; r_w := 10; r_d := 1; % set fixed point output %

write( sumSquares( numbers, 1, 5 ) );

 

=={{header|Alore}}==

 

var sum = 0

for i in a

 

WriteLn(sum_squares([3,1,4,1,5,9]))

 

=={{header|APL}}==

square_sum 1 2 3 4 5

55

square_sum ⍬ ⍝The empty vector

 

=={{header|AutoHotkey}}==

Loop, Parse, list, %A_Space%

sum += A_LoopField**2

 

=={{header|AWK}}==

Vectors are read, space-separated, from stdin; sum of squares goes to stdout. The empty line produces 0.

3 1 4 1 5 9

133

 

 

=={{header|BASIC}}==

{{works with|QBasic}}

Assume the numbers are in an array called <code>a</code>.

FOR I = LBOUND(a) TO UBOUND(a)

sum = sum + a(I) ^ 2

NEXT I

 

BBC BASIC cannot have a zero-length array.

vector() = 1, 2, 3, 4, 5, 6

{{out}}

<pre>Sum of squares = 91</pre>

 

=={{header|bc}}==

auto i, s

return(s)

 

=={{header|Bracmat}}==

= sum component

. 0:?sum

& out$(sumOfSquares$(3 4 i*5))

& out$(sumOfSquares$(a b c))

{{out}}

<pre>25

 

=={{header|Brat}}==

 

=={{header|C}}==

 

 

double squaredsum(double *l, int e)

printf("%lf\n", squaredsum(NULL, 0));

return 0;

 

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

#include <numeric>

#include <vector>

std::cout << vec_add_squares(v) << std::endl;

return 0;

 

#include <vector>

#include "boost/lambda/lambda.hpp"

 

return std::accumulate(v.begin(), v.end(), 0.0, _1 + _2 * _2);

 

=={{header|Chef}}==

 

First input is length of vector, then rest of input is vector.

Serves 1.

 

 

=={{header|Clojure}}==

 

=={{header|CoffeeScript}}==

sumOfSquares = ( list ) ->

list.reduce (( sum, x ) -> sum + ( x * x )), 0

 

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

 

 

=={{header|D}}==

===Iterative Version===

T sum = 0;

foreach (e; a)

 

[3.1, 1.0, 4.0, 1.0, 5.0, 9.0].sumSquares.writeln;

{{out}}

<pre>133.61</pre>

 

===Polymorphic Functional Style===

 

auto sumSquares(Range)(Range data) pure nothrow @safe @nogc {

items.sumSquares.writeln;

10.iota.sumSquares.writeln;

{{out}}

<pre>133.61

=={{header|Dart}}==

===Iterative Version===

var sum=0;

list.forEach((var n) { sum+=(n*n); });

print(sumOfSquares([1,2,3]));

print(sumOfSquares([10]));

{{out}}

<pre>0

 

===Functional Style Version===

.fold(0, (num p,num n)=> p + n);

 

print(sumOfSquares([1,2,3]));

print(sumOfSquares([10]));

{{out}}

<pre>0

=={{header|Delphi}}==

Delphi has standard SumOfSquares function in Math unit:

 

{$APPTYPE CONSOLE}

Writeln(SumOfSquares(A):6:2); // 30.00

Readln;

 

=={{header|E}}==

 

var sum := 0

for x in numbers {

}

return sum

 

 

=={{header|Eiffel}}==

 

class

APPLICATION

 

end

 

=={{header|Elixir}}==

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

atom sum

sum = 0

end for

return sum

 

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

 

=={{header|Factor}}==

 

: sum-of-squares ( seq -- n ) [ sq ] map-sum ;

 

 

=={{header|FALSE}}==

0 3 1 4 1 5 9$*\ [$0=~][$*+\]#%.

 

=={{header|Fantom}}==

class SumSquares

{

}

}

 

=={{header|Fish}}==

\0&

>l?!v:*&+&

 

=={{header|Forth}}==

0e

dup 0= if 2drop exit then

 

create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f,

 

=={{header|Fortran}}==

In ISO Fortran 90 orlater, use SUM intrinsic and implicit element-wise array arithmetic:

real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array

real :: result, zresult

result = sum(a**2) ! Use exponentiation operator to get squares

 

 

=={{header|Frink}}==

f = {|x| x^2} // Anonymous function which squares its argument

a = [1,2,3,5,7]

println[sum[map[f,a], 0]]

 

=={{header|GAP}}==

# It's necessary to check for the empty vector though

SumSq := function(v)

return v*v;

fi;

 

=={{header|GEORGE}}==

0

1, n rep (i)

read print dup mult +

]

data

<pre>

 

=={{header|Go}}==

 

import "fmt"

 

func main() {

var sum float32

}

fmt.Println(sum)

 

=={{header|Golfscript}}==

# usage example

 

=={{header|Groovy}}==

 

// square via multiplication

sumSq = array.collect { it ** 2 }.sum()

 

 

{{out}}

 

=={{header|Haskell}}==

 

 

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

local lst

lst := []

every total +:= !lst ^ 2

return total

 

=={{header|Inform 7}}==

 

To decide which number is the sum of (N - number) and (M - number) (this is summing):

say line break;

say the sum of squares of {1, 2, 3};

 

=={{header|Io}}==

 

=={{header|J}}==

 

 

That is, sum composed with square. The verb also works on higher-ranked arrays. For example:

 

133

ss $0 NB. $0 is a zero-length vector

x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers

ss x

 

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.

 

z=. 0

for_i. i.#y do. z=. z+*:i{y end.

0

ss1 x

 

=={{header|Java}}==

{{works with|Java|1.5+}}

{

public static void main(final String[] args)

System.out.println("The sum of the squares is: " + sum);

}

 

=={{header|JavaScript}}==

var sum = 0;

var i, iLen;

}

 

 

An alternative using a while loop and Math.pow

 

var sum = 0,

i = array.length;

}

 

 

 

 

map (JS 1.6) and reduce (JS 1.8)

 

 

=={{header|jq}}==

jq supports both arrays and streams, and so we illustrate how to handle both.

def ss: map(.*.) | add;

 

# ss for a stream, S, without creating an intermediate array:

# 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 mapreduce(mapper; reducer; zero):

if length == 0 then zero

else map(mapper) | reducer

end;

"ss: \( [range(0;n)] | ss )",

"ss(S): \( ss( range(0;n) ) )",

;

 

{{out}}

"ss(S): 5"

"SIGMA(.*.): 5"

"SIGMA(.*.;S): 5"

 

=={{header|Julia}}==

There are several easy ways to do this in Julia:

55

 

 

julia> sum([x^2 for x in []])

 

=={{header|K}}==

ss: {+/x*x}

ss 1 2 3 4 5

ss@!0

0

 

 

 

=={{header|Lasso}}==

 

local(sum = 0)

}

 

{{out}}

<pre>55</pre>

 

=={{header|LFE}}==

(defun sum-sq (nums)

(lists:foldl

(+ acc (* x x)))

0 nums))

 

Usage:

> (sum-sq '(3 1 4 1 5 9))

133

 

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

 

SourceList$ ="3 1 4 1 5 9"

print "Sum of squares is "; SumOfSquares

 

 

=={{header|Logo}}==

 

=={{header|Logtalk}}==

sum(List, 0, Sum).

 

sum([X| Xs], Acc, Sum) :-

Acc2 is Acc + X,

 

=={{header|Lua}}==

function squaresumt(t) return squaresum(unpack(t)) end

 

 

=={{header|Maple}}==

F := V -> add(v^2, v in V):

F(<1,2,3,4,5>);

 

As a function 1:

As a function 2:

Pure function 1: (postfix operator in the following examples)

Pure function 2:

Pure function 3:

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

or

 

=={{header|Mercury}}==

:- module sum_of_squares.

:- interface.

 

sum_of_squares(Ns) = list.foldl((func(N, Acc) = Acc + N * N), Ns, 0).

 

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

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

IO.Put(Fmt.Real(SumOfSquares(RealArray{3.0, 1.0, 4.0, 1.0, 5.0, 9.0})));

IO.Put("\n");

 

=={{header|MOO}}==

@program #100:sum_squares

sum = 0;

;#100:sum_squares({})

{} => 0

 

=={{header|MUMPS}}==

;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

 

=={{header|Nemerle}}==

{

|[] => 0.0

|_ => x.Map(fun (x) {x*x}).FoldLeft(0.0, _+_)

 

=={{header|NetRexx}}==

* program to sum the squares of a vector of fifteen numbers.

* translated from REXX

sum=sum + x**2 /*add its square to the sum. */

end

{{out}}

<pre>The sum of 15 elements for the V vector is: 10650.25</pre>

 

=={{header|NewLISP}}==

-> 133

(apply + (map (fn(x) (* x x)) '()))

 

=={{header|Nim}}==

 

 

=={{header|Objeck}}==

bundle Default {

class Sum {

}

}

 

=={{header|OCaml}}==

 

 

 

=={{header|Oforth}}==

 

 

 

 

=={{header|Order}}==

 

 

ORDER_PP(8to_lit(

8seq_fold(8plus, 0,

8seq_map(8fn(8X, 8times(8X, 8X)), 8seq(3, 1, 4, 1, 5, 9)))

 

=={{header|Oz}}==

fun {SumOfSquares Xs}

for X in Xs sum:S do

end

in

 

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

sum(i=1,#v,v[i]^2)

 

=={{header|Pascal}}==

{{libheader|Math}}

Example from the documenation of the run time library:

 

{ Program to demonstrate the SumOfSquares function. }

Writeln('Sum squares : ',SumOfSquares(ExArray):8:4);

Writeln('Sum squares (b) : ',SumOfSquares(@ExArray[1],100):8:4);

 

=={{header|Perl}}==

my $sum = 0;

$sum += $_**2 foreach @_;

}

 

or

sub sum_of_squares {

reduce { $a + $b **2 } 0, @_;

}

 

 

 

 

 

 

=={{header|PHP}}==

function sum_squares(array $args) {

return array_reduce(

);

}

 

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

}, 0);

}

Usage for both examples: <code>sum_squares(array(1,2,3,4,5)); // 55</code>

 

=={{header|PicoLisp}}==

-> 133

: (sum '((N) (* N N)) ())

 

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

declare A(10) float initial (10, 9, 8, 7, 6, 5, 4, 3, 2, 1);

 

put (sum(A**2));

 

=={{header|Pop11}}==

 

lvars s = 0, j;

for j from 1 to length(v) do

enddefine;

 

 

=={{header|PostScript}}==

/sqrsum{

/x exch def

sum ==

}def

 

{{libheader|initlib}}

[3 1 4 1 5 9] 0 {dup * +} fold

 

=={{header|PowerShell}}==

if ($a.Length -eq 0) {

return 0

return $x.Sum

}

 

=={{header|PureBasic}}==

ForEach base()

Sum + base()*base()

Next

ProcedureReturn Sum

 

=={{header|Python}}==

 

 

 

=={{header|R}}==

 

=={{header|Racket}}==

#lang racket

(for/sum ([x #(3 1 4 1 5 9)]) (* x x))

 

=={{header|Raven}}==

0 $lst each dup * +

 

{{out}}

<pre>Sum of squares: 30</pre>

 

 

{{out}}

<pre>

The sum of 15 squared elements for the V vector is: 10650.25

</pre>

 

 

 

 

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

print sumOfSquares(list$)

 

sumOfSquares = sumOfSquares + val(word$(sos$,i,","))^2

wend

 

=={{header|Rust}}==

v.iter().fold(0., |sum, &num| sum + num*num)

}

let u : Vec<f64> = vec![];

println!("{}", sq_sum(&u));

 

=={{header|Sather}}==

 

sqsum(s, e:FLT):FLT is

end;

 

 

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

 

 

=={{header|Scheme}}==

 

> (sum-of-squares (list 3 1 4 1 5 9))

 

=={{header|Seed7}}==

include "float.s7i";

writeln(squaredSum(list1));

writeln(squaredSum(list2));

 

=={{header|Sidef}}==

var sum = 0;

vector.each { |n| sum += n**2 };

 

say sum_of_squares([]); # 0

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

ssq i = i + 1; ssq = ssq + (a<i> * a<i>) :s(sumsq)f(return)

ssq_end

loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)

output = str ' -> ' sumsq(a)

 

{{out}}

<pre> 1 2 3 5 7 11 13 17 19 23 -> 1557</pre>

 

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

 

 

 

 

 

=={{header|Swift}}==

 

return s.map{$0 * $0}.reduce(0, +)

 

 

 

namespace path ::tcl::mathop

 

}

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

array="3'1'4'1'5'9",sum=0

ENDLOOP

PRINT sum

{{out}}

<pre>

=={{header|UnixPipes}}==

 

(read B; res=$( expr $1 \* $1 ) ; test -n "$B" && expr $res + $B || echo $res)

}

 

 

 

=={{header|Ursala}}==

maps the product function to all pairs, and then sums the

result by way of the reduction operator, -:.

 

ssq = sum:-0+ product*iip

#cast %n

 

{{out}}

<pre>62223</pre>

 

=={{header|V}}==

 

[] sumsq

=0

=14

 

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

Private Shared Function sumsq(ByVal i As ICollection(Of Integer)) As Integer

If i Is Nothing OrElse i.Count = 0 Then

End Function

{{out}}

<pre>

SumOfSquares(15) = 1240

SumOfSquares(16) = 1496

</pre>

 

=={{header|Wortel}}==

As a function:

Iterative function:

 

=={{header|XPL0}}==

 

func SumSq(V, L);

[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

 

{{out}}

 

=={{header|zkl}}==