June 2018 Update

Task/Entropy/ALGOL-68/entropy.alg

@@ -1,27 +1,19 @@
-# calculate the shannon entropy of a string                                #
-
-PROC shannon entropy = ( STRING s )REAL:
+BEGIN
+    # calculate the shannon entropy of a string                                #
+    PROC shannon entropy = ( STRING s )REAL:
     BEGIN
-
         INT string length = ( UPB s - LWB s ) + 1;
-
-        # count the occurances of each character #
-
+        # count the occurences of each character #
         [ 0 : max abs char ]INT char count;
-
         FOR char pos FROM LWB char count TO UPB char count DO
             char count[ char pos ] := 0
         OD;
-
         FOR char pos FROM LWB s TO UPB s DO
             char count[ ABS s[ char pos ] ] +:= 1
         OD;
-
         # calculate the entropy, we use log base 10 and then convert #
         # to log base 2 after calculating the sum                    #
-
         REAL entropy := 0;
-
         FOR char pos FROM LWB char count TO UPB char count DO
             IF char count[ char pos ] /= 0
             THEN
@@ -30,14 +22,10 @@ PROC shannon entropy = ( STRING s )REAL:
                 entropy -:= probability * log( probability )
             FI
         OD;
-
         entropy / log( 2 )
     END; # shannon entropy #
 
-
-
-main:
-(
     # test the shannon entropy routine #
     print( ( shannon entropy( "1223334444" ), newline ) )
-)
+
+END

Task/Entropy/Aime/entropy.aime

@@ -1,25 +1,16 @@
-integer i, l;
-record r;
-real h, x;
-text s;
+integer c;
+real h, v;
+index x;
+data s;
 
-s = argv(1);
-l = length(s);
-
-i = l;
-while (i) {
-    i -= 1;
-    rn_a_integer(r, cut(s, i, 1), 1);
+for (, c in (s = argv(1))) {
+    x[c] += 1r;
 }
 
 h = 0;
-if (r_first(r, s)) {
-    do {
-        x = r_q_integer(r, s);
-        x /= l;
-        h -= x * log2(x);
-    } while (r_greater(r, s, s));
+for (, v in x) {
+    v /= ~s;
+    h -= v * log2(v);
 }
 
-o_real(6, h);
-o_newline();
+o_form("/d6/\n", h);

Task/Entropy/BASIC/entropy-1.basic

@@ -0,0 +1,23 @@
+10 DEF FN L(X)=LOG(X)/LOG(2)
+20 S$="1223334444"
+30 U$=""
+40 FOR I=1 TO LEN(S$)
+50 K=0
+60 FOR J=1 TO LEN(U$)
+70 IF MID$(U$,J,1)=MID$(S$,I,1) THEN K=1
+80 NEXT J
+90 IF K=0 THEN U$=U$+MID$(S$,I,1)
+100 NEXT I
+110 DIM R(LEN(U$)-1)
+120 FOR I=1 TO LEN(U$)
+130 C=0
+140 FOR J=1 TO LEN(S$)
+150 IF MID$(U$,I,1)=MID$(S$,J,1) THEN C=C+1
+160 NEXT J
+170 R(I-1)=(C/LEN(S$))*FN L(C/LEN(S$))
+180 NEXT I
+190 E=0
+200 FOR I=0 TO LEN(U$)-1
+210 E=E-R(I)
+220 NEXT I
+230 PRINT E

Task/Entropy/BASIC/entropy-2.basic

@@ -0,0 +1,22 @@
+ 10 LET X$="1223334444"
+ 20 LET U$=""
+ 30 FOR I=1 TO LEN X$
+ 40 LET K=0
+ 50 FOR J=1 TO LEN U$
+ 60 IF U$(J)=X$(I) THEN LET K=K+1
+ 70 NEXT J
+ 80 IF K=0 THEN LET U$=U$+X$(I)
+ 90 NEXT I
+100 DIM R(LEN U$)
+110 FOR I=1 TO LEN U$
+120 LET C=0
+130 FOR J=1 TO LEN X$
+140 IF U$(I)=X$(J) THEN LET C=C+1
+150 NEXT J
+160 LET R(I)=C/LEN X$*LN (C/LEN X$)/LN 2
+170 NEXT I
+180 LET E=0
+190 FOR I=1 TO LEN U$
+200 LET E=E-R(I)
+210 NEXT I
+220 PRINT E

Task/Entropy/BBC-BASIC/entropy.bbc

@@ -0,0 +1,24 @@
+REM >entropy
+PRINT FNentropy("1223334444")
+END
+:
+DEF FNentropy(x$)
+LOCAL unique$, count%, n%, ratio(), u%, i%, j%
+unique$ = ""
+n% = LEN x$
+FOR i% = 1 TO n%
+  IF INSTR(unique$, MID$(x$, i%, 1)) = 0 THEN unique$ += MID$(x$, i%, 1)
+NEXT
+u% = LEN unique$
+DIM ratio(u% - 1)
+FOR i% = 1 TO u%
+  count% = 0
+  FOR j% = 1 TO n%
+    IF MID$(unique$, i%, 1) = MID$(x$, j%, 1) THEN count% += 1
+  NEXT
+  ratio(i% - 1) = (count% / n%) * FNlogtwo(count% / n%)
+NEXT
+= -SUM(ratio())
+:
+DEF FNlogtwo(n)
+= LN n / LN 2

Task/Entropy/C++/entropy.cpp

@@ -17,10 +17,10 @@ int main( int argc , char *argv[ ] ) {
    double infocontent = 0 ;
    for ( std::pair<char , int> p : frequencies ) {
       double freq = static_cast<double>( p.second ) / numlen ;
-      infocontent += freq * log2( freq ) ;
+      infocontent -= freq * log2( freq ) ;
    }
-   infocontent *= -1 ;
+
    std::cout << "The information content of " << teststring
-      << " is " << infocontent << " !\n" ;
+      << " is " << infocontent << std::endl ;
    return 0 ;
 }

Task/Entropy/Common-Lisp/entropy-1.lisp

@@ -3,6 +3,8 @@
         (entropy 0))
     (mapc (lambda (c) (setf (gethash c table) (+ (gethash c table 0) 1)))
           (coerce string 'list))
-    (maphash (lambda (k v) (decf entropy (* (/ v (length input-string)) (log (/ v (length input-string)) 2))))
+    (maphash (lambda (k v)
+               (decf entropy (* (/ v (length input-string))
+                                (log (/ v (length input-string)) 2))))
              table)
     entropy))

Task/Entropy/Common-Lisp/entropy-2.lisp

@@ -0,0 +1,8 @@
+(defun entropy (string &aux (length (length string)))
+  (declare (type string string))
+  (let ((table (make-hash-table)))
+    (loop for char across string
+          do (incf (gethash char table 0)))
+    (- (loop for freq being each hash-value in table
+             for freq/length = (/ freq length)
+             sum (* freq/length (log freq/length 2))))))

Task/Entropy/Factor/entropy.factor

@@ -0,0 +1,11 @@
+USING: assocs kernel math math.functions math.statistics
+prettyprint sequences ;
+IN: rosetta-code.entropy
+
+: shannon-entropy ( str -- entropy )
+    [ length ] [ histogram >alist [ second ] map ] bi
+    [ swap / ] with map
+    [ dup log 2 log / * ] map-sum neg ;
+
+"1223334444" shannon-entropy .
+"Factor is my favorite programming language." shannon-entropy .

Task/Entropy/Julia/entropy.julia

@@ -1 +1,3 @@
-entropy(s)=-sum(x->x*log(2,x), [count(x->x==c,s)/length(s) for c in unique(s)])
+entropy(s) = -sum(x -> x * log(2, x), count(x -> x == c, s) / length(s) for c in unique(s))
+@show entropy("1223334444")
+@show entropy([1, 2, 3, 1, 2, 1, 2, 3, 1, 2, 3, 4, 5]

Task/Entropy/Objeck/entropy.objeck

@@ -0,0 +1,48 @@
+use Collection;
+
+class Entropy {
+  function : native : GetShannonEntropy(result : String) ~ Float {
+    frequencies := IntMap->New();
+
+    each(i : result) {
+      c := result->Get(i);
+
+      if(frequencies->Has(c)) {
+        count := frequencies->Find(c)->As(IntHolder);
+        count->Set(count->Get() + 1);
+      }
+      else {
+        frequencies->Insert(c, IntHolder->New(1));
+      };
+    };
+
+    length := result->Size();
+    entropy := 0.0;
+
+    counts := frequencies->GetValues();
+    each(i : counts) {
+      count := counts->Get(i)->As(IntHolder)->Get();
+      freq := count->As(Float) / length;
+      entropy += freq * (freq->Log() / 2.0->Log());
+    };
+
+    return -1 * entropy;
+  }
+
+  function : Main(args : String[]) ~ Nil {
+    inputs := [
+      "1223334444",
+      "1223334444555555555",
+      "122333",
+      "1227774444",
+      "aaBBcccDDDD",
+      "1234567890abcdefghijklmnopqrstuvwxyz",
+      "Rosetta Code"];
+
+    each(i : inputs) {
+      input := inputs[i];
+      "Shannon entropy of '{$input}': "->Print();
+      GetShannonEntropy(inputs[i])->PrintLine();
+    };
+  }
+}