Sum of squares: Difference between revisions

Content added Content deleted

Inline

Revision as of 20:06, 4 November 2009

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

Ada

<lang 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;</lang> Sample output:

 0.00000E+00
 1.33000E+02

ALGOL 68

The computation can be written as a loop.

main1:(
  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
  );

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

Output:

Another implementation could define a procedure (PROC) or operator (OP) called map.

main2:(
  []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);

  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(($xg(0)l$, ((REAL argv)REAL: sum +:= argv ** 2) MAP data ))
)

Output:

133
133

AWK

Vectors are read, space-separated, from stdin; sum of squares goes to stdout. The empty line produces 0. <lang awk>$ awk '{s=0;for(i=1;i<=NF;i++)s+=$i*$i;print s}' 3 1 4 1 5 9 133

0</lang>

BASIC

Works with: QuickBasic version 4.5

Assume the numbers are in a DIM 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

Common Lisp

(defun sum-of-squares (vector)
  (loop for x across vector sum (expt x 2)))

Erlang

lists:foldl(fun(X, Sum) -> X*X + Sum end, 0, [3,1,4,1,5,9]).

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

F#

Just like OCaml for this.

List.fold_left (fun a x -> a + x * x) 0 [1 .. 10]
Array.fold_left (fun a x -> a + x * x) 0 [|1 .. 10|]

Groovy

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

Output:

14
14

Haskell

sumOfSquares = sum . map (^ 2)

> sumOfSquares [3,1,4,1,5,9]
133

IDL

print,total(array^2)

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

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

Assume the numbers are in a double array called "nums".

<lang java>... double sum = 0; for(double a : nums){

 sum+= a * a;

} System.out.println("The sum of the squares is: " + sum); ...</lang>

JavaScript

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

Library: Functional

<lang javascript>Functional.reduce("x+y*y", 0, [1,2,3,4,5]) // 55</lang>

Logo

print apply "sum map [? * ?] [1 2 3 4 5]  ; 55

As a function 1: <lang Mathematica > SumOfSquares[x_]:=Total[x^2] SumOfSquares[{1,2,3,4,5}] </lang> As a function 2: <lang Mathematica > SumOfSquares[x_]:=x.x SumOfSquares[{1,2,3,4,5}] </lang> Pure function 1: (postfix operator in the following examples) <lang Mathematica > {1,2,3,4,5} // Total[#^2] & </lang> Pure function 2: <lang Mathematica > {1, 2, 3, 4, 5} // #^2 & // Total </lang> Pure function 3: <lang Mathematica > {1, 2, 3, 4, 5} // #.#& </lang>

MATLAB

<lang Matlab>function [squaredSum] = sumofsquares(inputVector)

  squaredSum = sum( inputVector.^2 );</lang>

Maxima

nums : [3,1,4,1,5,9];
sum(nums[i]^2,i,1,length(nums));

OCaml

<lang ocaml>List.fold_left (fun sum a -> sum +. a *. a) 0. floats</lang>

Octave

<lang octave>a = [1:10]; sumsq = sum(a .^ 2);</lang>

Perl

<lang perl>sub sum_of_squares {

 my $sum = 0;
 $sum += $_**2 foreach @_;
 return $sum;

}

print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</lang> or <lang perl>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";</lang>

Perl 6

Works with: Rakudo version #21 "Seattle"

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.

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

PowerShell

<lang powershell>function Get-SquareSum ($a) {

   if ($a.Length -eq 0) {
       return 0
   } else {
       $x = $a `
            | ForEach-Object { $_ * $_ } `
            | Measure-Object -Sum
       return $x.Sum
   }

}</lang>

Python

Prolog

R

arr <- c(1,2,3,4,5)
result <- sum(arr^2)

Ruby

<lang ruby>[3,1,4,1,5,9].inject(0) { |sum,x| sum += x*x }</lang>

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.

<lang scala> def sum_of_squares(xs: Seq[Double]) = xs.foldLeft(0.0)((a,x) => a + x*x) </lang>

Scheme

<lang scheme>(define (sum-of-squares l)

 (apply + (map * l l)))</lang>

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

Slate

<lang slate> {1. 2. 3} reduce: [|:x :y| y squared + x]. {} reduce: [|:x :y| y squared + x] ifEmpty: [0]. </lang>

Smalltalk

<lang smalltalk>#(3 1 4 1 5 9) inject: 0 into: [:sum :aNumber | sum + aNumber squared]</lang>

Standard ML

<lang sml>foldl (fn (a, sum) => sum + a * a) 0 ints</lang>

<lang sml>foldl (fn (a, sum) => sum + a * a) 0.0 reals</lang>

Tcl

<lang tcl>proc sumOfSquares {nums} {

   set sum 0
   foreach num $nums {
       set sum [expr {$sum + $num**2}]
   }
   return $sum

} sumOfSquares {1 2 3 4 5} ;# ==> 55 sumOfSquares {} ;# ==> 0</lang>

Using the struct::list package from

Library: tcllib

<lang tcl>package require struct::list

proc square x {expr {$x * $x}} proc + {a b} {expr {$a + $b}} proc sumOfSquares {nums} {

   struct::list fold [struct::list map $nums square] 0 +

} sumOfSquares {1 2 3 4 5} ;# ==> 55 sumOfSquares {} ;# ==> 0</lang> Generic "sum of function" <lang tcl>package require Tcl 8.5 package require struct::list namespace path ::tcl::mathop

proc sum_of {lambda nums} {

   struct::list fold [struct::list map $nums [list apply $lambda]] 0 +

}

sum_of {x {* $x $x}} {1 2 3 4 5} ;# ==> 55</lang>

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

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, -:. <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></lang> output:

V

[sumsq [dup *] map 0 [+] fold].

[] sumsq
=0
[1 2 3] sumsq
=14