Entropy: Difference between revisions

:* [[Entropy/Narcissist]]

<br><br>

 

=={{header|Ada}}==

Uses Ada 2012.

 

procedure Count_Entropy is

Put(Result, Fore => 1, Aft => 5, Exp => 0);

end;

 

=={{header|Aime}}==

 

}

 

h = 0;

}

 

Examples:

<pre>$ aime -a tmp/entr 1223334444

 

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

BEGIN

INT string length = ( UPB s - LWB s ) + 1;

[ 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

FI

OD;

entropy / log( 2 )

END; # shannon entropy #

 

# test the shannon entropy routine #

print( ( shannon entropy( "1223334444" ), newline ) )

{{out}}

<pre>

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

{{trans|ALGOL 68}}

% calculates the shannon entropy of a string %

% strings are fixed length in algol W and the length is part of the %

write( shannon_entropy( "1223334444", 10 ) )

 

{{out}}

<pre>

 

=={{header|APL}}==

ENTROPY←{-+/R×2⍟R←(+⌿⍵∘.=∪⍵)÷⍴⍵}

 

-+/RATIO×2⍟RATIO

1.846439345

{{out}}

<pre>

1.846439345

</pre>

 

=={{header|AutoHotkey}}==

 

Entropy(n)

}

return, e

{{out}}

<pre>1.846440</pre>

 

=={{header|AWK}}==

{

}

 

END {

{{out|Usage}}

 

=={{header|Burlesque}}==

 

=={{header|C}}==

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include <math.h>

#define MAXLEN 100 //maximum string length

int wherechar[256];

int i,histlen;

return histlen;

}

double entropy(int *hist,int histlen,int len){

int i;

return H;

}

int main(void){

int len,*hist,histlen;

double H;

printf("%lf\n",H);

return 0;

Examples:

1223334444

1.846439

$ ./entropy

Rosetta Code is the best site in the world!

 

Translation of C++.

using System;

using System.Collections.Generic;

}

}

{{out}}

<pre>The Entropy of 1223334444 is 1.84643934467102</pre>

Without using Hashtables or Dictionaries:

namespace Entropy

{

}

}

 

=={{header|CoffeeScript}}==

freq = (s) ->

result = {}

((frq[f]/n for f of frq).reduce ((e, p) -> e - p * Math.log(p)), 0) * Math.LOG2E

 

{{out}}

<pre>The entropy of the string '1223334444' is 1.8464393446710157</pre>

 

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

Not very Common Lisp-y version:

(let ((table (make-hash-table :test 'equal))

(entropy 0))

(log (/ v (length input-string)) 2))))

table)

 

More like Common Lisp version:

 

(declare (type string string))

(let ((table (make-hash-table)))

(- (loop for freq being each hash-value in table

for freq/length = (/ freq length)

 

=={{header|D}}==

 

double entropy(T)(T[] s)

void main() {

"1223334444"d.dup.entropy.writeln;

{{out}}

<pre>1.84644</pre>

 

=={{header|EchoLisp}}==

(lib 'hash)

;; counter: hash-table[key]++

(for/sum ((s (make-set S))) (hi (hash-ref ht s) n)))

{{out}}

;; by increasing entropy

 

(H (for/list ((i 1000_000)) (random 1000_000))) → 19.104028424596976

 

=={{header|Elena}}==

{{trans|C#}}

{

}

{{out}}

<pre>

{{works with|Erlang/OTP|18}}

<code>:math.log2</code> was added in OTP 18.

def entropy(str) do

leng = String.length(str)

end

 

 

{{out}}

 

=={{header|Emacs Lisp}}==

(let ((freq-table (make-hash-table))

(entropy 0)

(log (/ v length) 2)))))

freq-table)

 

{{out}}

as shown below (type ctrl-j at the end of the first line

and the output will be placed by emacs on the second line).

 

=={{header|Erlang}}==

-module( entropy ).

 

Frequency = How_many / String_length,

{String_length, Acc - (Frequency * math:log(Frequency))}.

 

{{out}}

 

=={{header|Euler Math Toolbox}}==

$ v=strtochar(s);

$ m=getmultiplicities(unique(v),v);

$endfunction

>entropy("1223334444")

 

 

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

 

let ld x = Math.Log x / Math.Log 2.

|> Seq.fold (fun e p -> e - p * ld p) 0.

 

{{out}}

<pre>1.846439</pre>

 

=={{header|Forth}}==

 

create freq 256 cells allot

 

s" 1223334444" entropy f. \ 1.84643934467102 ok

 

=={{header|Fortran}}==

Please find the GNU/linux compilation instructions along with sample run among the comments at the start of the FORTRAN 2008 source. This program acquires input from the command line argument, thereby demonstrating the fairly new get_command_argument intrinsic subroutine. The expression of the algorithm is a rough translated of the j solution. Thank you.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Tue May 21 21:43:12

 

end program shannonEntropy

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Char count

Sort of hacky, but friendly interactive shell isn't really optimized for mathematic tasks (in fact, it doesn't even have associative arrays).

 

for arg in $argv

set name count_$arg

echo "$entropy / l(2)" | bc -l

end

{{out}}

<pre>1.84643934467101549345</pre>

=={{header|Go}}==

===Go: Slice version===

 

import (

}

 

func H(data string) (entropy float64) {

if data == "" {

}

return entropy

{{out}}

<pre>

 

===Go: Map version===

 

import (

const s = "1223334444"

 

m := map[rune]float64{}

for _, r := range s {

m[r]++

}

for _, c := range m {

hm += c * math.Log2(c)

}

fmt.Println(math.Log2(l) - hm/l)

{{out}}

<pre>

 

=={{header|Groovy}}==

-delegate.inject([:]) { map, v -> map[v] = (map[v] ?: 0) + 1; map }.values().inject(0.0) { sum, v ->

def p = (BigDecimal)v / delegate.size()

sum + p * Math.log(p) / Math.log(2)

}

Testing

'1223334444555555555': '1.969811065121',

'122333': '1.459147917061',

println "Checking $s has a shannon entrophy of $expected"

assert sprintf('%.12f', s.shannonEntrophy) == expected

{{out}}

<pre>Checking 1223334444 has a shannon entrophy of 1.846439344671

 

=={{header|Haskell}}==

 

main = print $ entropy "1223334444"

entropy = sum . map lg . fq . map genericLength . group . sort

where lg c = -c * logBase 2 c

 

{{out}}

 

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

Hmmm, the 2nd equation sums across the length of the string (for the

example, that would be the sum of 10 terms). However, the answer cited

description.

 

s := !a | "1223334444"

write(H(s))

every (h := 0.0) -:= P[c := key(P)] * log(P[c],2)

return h

 

{{out}}

 

=={{header|J}}==

{{out|Example}}

1.84644

entropy i.256

1

entropy 256$0 1 2 3

 

So it looks like entropy is roughly the number of bits which would be needed to ''distinguish between'' each item in the argument (for example, with perfect compression). Note that in some contexts this might not be the same thing as information because the choice of the items themselves might matter. But it's good enough in contexts with a fixed set of symbols.

{{trans|REXX}}

{{works with|Java|7+}}

import java.util.Map;

import java.util.HashMap;

return;

}

{{out}}

<pre>

 

=={{header|JavaScript}}==

 

}

{{out}}

 

=={{header|jq}}==

The helper function, ''counter'', could be defined as an inner function of ''entropy'', but for the sake of clarity and because it is independently useful,

it is defined separately.

# Output: an object with the strings as keys, the values of which are the corresponding frequencies.

def counter:

(explode | map( [.] | implode ) | counter

| [ .[] | . * log ] | add) as $sum

 

{{out|Example}}

 

=={{header|Julia}}==

 

=={{header|Kotlin}}==

 

fun log2(d: Double) = Math.log(d) / Math.log(2.0)

println("------------------------------------ ------------------")

for (sample in samples) println("${sample.padEnd(36)} -> ${"%18.16f".format(shannon(sample))}")

{{out}}

<pre>

Rosetta Code -> 3.0849625007211556

</pre>

 

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

dim countOfChar( 255) ' all possible one-byte ASCII chars

 

logBase =log( x) /log( 2)

end function

{{Out}}

<pre> Characters used and the number of occurrences of each

Entropy of '1223334444' is 1.84643934 bits.

The result should be around 1.84644 bits.</pre>

 

=={{header|Lua}}==

 

function entropy (X)

end

 

 

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

1.84644

shE["Rosetta Code"]

 

=={{header|MATLAB}} / {{header|Octave}}==

This version allows for any input vectors,

including strings, floats, negative integers, etc.

if ischar(d), d=abs(d); end;

[Y,I,J] = unique(d);

p = full(H(H>0))/length(d);

E = -sum(p.*log2(p));

{{out|Usage}}

 

=={{header|NetRexx}}==

{{trans|REXX}}

options replace format comments java crossref savelog symbols

 

end report

return

{{out}}

<pre>

 

=={{header|Nim}}==

 

var t = initCountTable[char]()

for c in s: t.inc(c)

for x in t.values: result -= x/s.len * log2(x/s.len)

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|OCaml}}==

 

(* pre-bake & return an inner-loop function to bin & assemble a character frequency map *)

let get_fproc (m: (char, int) Hashtbl.t) :(char -> unit) =

 

-1.0 *. List.fold_left (fun b x -> b +. calc x) 0.0 relative_probs

 

=={{header|Oforth}}==

| freq sz |

s size dup ifZero: [ return ] asFloat ->sz

0.0 freq applyIf( #[ 0 <> ], #[ sz / dup ln * - ] ) Ln2 / ;

 

{{out}}

 

 

 

PROGRAM entropytest;

 

Writeln('Entropy of "',strng,'" is ',entropy(strng):2:5, ' bits.');

END.

 

{{out}}

Entropy of "1223334444" is 1.84644 bits.

</pre>

 

=={{header|Perl}}==

my %count; $count{$_}++ for @_;

my $entropy = 0;

}

 

{{out}}

 

 

}

}

 

 

 

 

{{out}}

<pre>

</pre>

 

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

/*--------------------------------------------------------------------

* 08.08.2014 Walter Pachl translated from REXX version 1

End;

Put Edit('s='''!!s!!''' Entropy=',-e)(Skip,a,f(15,12));

{{out}}

<pre>s='1223334444' Entropy= 1.846439344671</pre>

 

=={{header|PowerShell}}==

function entropy ($string) {

$n = $string.Length

}

entropy "1223334444"

<b>Output:</b>

<pre>

 

=={{header|Prolog}}==

{{works with|Swi-Prolog|7.3.3}}

This solution calculates the run-length encoding of the input string to get the relative frequencies of its characters.

 

%! shannon_entropy(+String, -Entropy) is det.

,must_be(number, B)

,Sum is A + B.

 

Example query:

 

=={{header|PureBasic}}==

NewMap uchar.i() : Define.d e

 

OpenConsole()

Print("Entropy of ["+#TESTSTR+"] = "+StrD(e,15))

{{out}}

<pre>Entropy of [1223334444] = 1.846439344671015</pre>

=={{header|Python}}==

===Python: Longer version===

import math

 

print 'Length',l

print 'Entropy:', entropy(h, l)

 

{{out}}

 

===Python: More succinct version===

The <tt>Counter</tt> module is only available in Python >= 2.7.

 

 

===Uses Python 2===

import math

log2=lambda x:math.log(x)/math.log(2)

 

while True:

 

=={{header|R}}==

 

 

=={{header|Racket}}==

(require math)

(provide entropy hash-entropy list-entropy digital-entropy)

(check-= (entropy "xggooopppp") 1.8464393446710154 1E-8))

 

{{out}}

<pre> 1.8464393446710154</pre>

 

=={{header|REXX}}==

===version 1===

 

* 28.02.2013 Walter Pachl

* 12.03.2013 Walter Pachl typo in log corrected. thanx for testing

Numeric Digits (prec)

r=r+0

 

* Test program to compare Versions 1 and 2

* (the latter tweaked to be acceptable by my (oo)Rexx

Say ' '

Return

{{out}}

<pre>Version 1: 1223334444 Entropy 1.846439344671

 

Version 1: 1234567890abcdefghijklmnopqrstuvwxyz Entropy 5.169925001442

 

===version 2===

 

The &nbsp; '''LOG2''' &nbsp; subroutine is only included here for functionality, not to document how to calculate &nbsp; LOG₂ &nbsp; using REXX.

$$= /*initialize the $$ list. */

end

end /*j*/

end /*i*/

say ' input string: ' $

say 'string length: ' L

say 'the information entropy of the string ──► ' format(sum,,12) " bits."

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

input string: 1223334444

the information entropy of the string ──► 1.846439344671 bits.

</pre>

<pre>

input string: Rosetta Code

 

=={{header|Ring}}==

decimals(8)

entropy = 0

logBase =log( x) /log( 2)

return logBase

Output:

<pre>

</pre>

 

counts.values.reduce(0) do |entropy, count|

freq = count / leng

end

 

{{out}}

<pre>

1.8464393446710154

</pre>

 

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

 

source$ = "1223334444"

print " Entropy of '"; source$; "' is "; entropy; " bits."

 

Characters used and times used of each

'1' 1

 

=={{header|Rust}}==

 

}

}

 

fn main() {

let arg = std::env::args().nth(1).expect("Need a string.");

{{out}}

<pre>$ ./entropy 1223334444

 

=={{header|Scala}}==

 

def entropy( v:String ) = { v

 

// Confirm that "1223334444" has an entropy of about 1.84644

 

=={{header|scheme}}==

A version capable of calculating multidimensional entropy.

(define (entropy input)

(define (close? a b)

(entropy (list 1 2 2 3 3 3 4 4 4 4))

(entropy (list (list 1 1) (list 1.1 1.1) (list 1.2 1.2) (list 1.3 1.3) (list 1.5 1.5) (list 1.6 1.6)))

 

{{out}}

 

=={{header|Scilab}}==

d=strsplit(d);

n=unique(string(d));

word ='1223334444';

E = entropy(word);

 

{{out}}

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

begin

writeln(entropy("1223334444") digits 5);

 

{{out}}

1.84644

</pre>

 

=={{header|Sidef}}==

var counts = Hash.new;

s.each { |c| counts{c} := 0 ++ };

}

 

{{out}}

<pre>1.846439344671015493434197746305045223237</pre>

 

=={{header|Tcl}}==

set log2 [expr log(2)]

foreach char [split $str ""] {dict incr counts $char}

}

return $entropy

Demonstration:

{{out}}

<pre>

entropy = 1.84644

entropy = 3.08496

</pre>

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

];

 

{{out}}

<pre>

1.84644

</pre>

 

=={{header|zkl}}==

{{trans|D}}

text.pump(Void,fcn(c,freq){ c=c.toAsc(); freq[c]+=1; freq }

.fp1( (0).pump(256,List,0.0).copy() )) // array[256] of 0.0

}

 

{{out}}

<pre>

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

{{trans|FreeBASIC}}

20 LET sourcelen=LEN s$

30 DIM t(255)

100 IF t(i)<>0 THEN PRINT CHR$ i;TAB (6);t(i): LET prop=t(i)/sourcelen: LET entropy=entropy-(prop*(LN prop)/(LN base))

110 NEXT i