Entropy/Narcissist: Difference between revisions

{{task}}

 

;Task:

:*   [[Entropy]]

<br><br>

 

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

Note that the source here uses spaces, not tabs, hence the low entropy, replacing all runs of four spaces with a single space

results in an entropy of +4.64524532762062e +0.

# calculate the shannon entropy of a string #

PROC shannon entropy = ( STRING s )REAL:

print( ( shannon entropy( file contents ), newline ) )

FI

{{out}}

<pre>

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

MsgBox, % Entropy(var)

 

}

return, e

{{Output}}

<pre>5.942956</pre>

 

=={{header|C}}==

 

Assumes that the source file is stored in the working directory as "entropy.c".

#include <stdlib.h>

#include <stdbool.h>

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

return 0;

{{out}}

 

=={{header|Crystal}}==

{{trans|Ruby}}

counts = s.chars.each_with_object(Hash(Char, Float64).new(0.0)) { |c, h| h[c] += 1 }

counts.values.sum do |count|

end

 

{{out}}

<pre>

 

=={{header|D}}==

import std.stdio, std.algorithm, std.math, std.file;

 

.sum

.writeln;

{{out}}

<pre>6.29803</pre>

 

=={{header|Elixir}}==

text = IO.read(file, :all)

leng = String.length(text)

end)

|> IO.puts

 

{{out}}

 

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

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

(entropy 0)

(shannon-entropy (with-temp-buffer

(insert-file-contents "U:/rosetta/narcissist.el")

{{out}}

 

=={{header|Erlang}}==

 

-define(LOG2E, 1.44269504088896340735992).

_ -> count(Data, I+1, Frq #{Chr => 1})

end.

{{out}}

<pre>

 

=={{header|Factor}}==

math.functions math.statistics prettyprint sequences ;

IN: rosetta-code.entropy-narcissist

"entropy-narcissist.factor" utf8 [

contents entropy .

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

' modified code from ENTROPY entry

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Windows version

 

=={{header|Go}}==

 

import (

l := float64(len(d))

return math.Log2(l) - hm/l

{{out}}

<pre>

 

=={{header|Haskell}}==

import Data.List

import System.Environment

entropy = sort >>> group >>> map genericLength >>> normalize >>> map lg >>> sum

where lg c = -c * logBase 2 c

 

{{out}} In a shell

 

=={{header|J}}==

 

=={{header|Java}}==

 

import java.io.BufferedReader;

import java.io.File;

}

 

}

 

}

 

{{out}}

</pre>

 

=={{header|Kotlin}}==

 

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

val prog = java.io.File("entropy_narc.kt").readText()

println("This program's entropy is ${"%18.16f".format(shannon(prog))}")

 

{{out}}

=={{header|Lua}}==

arg[0] gives the path of the script currently being executed

local inFile = io.open(filename, "r")

local fileContent = inFile:read("*all")

end

 

{{out}}

<pre>4.3591214356783</pre>

 

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

{{out}}

<pre>%1 = 4.54978213</pre>

 

=={{header|Perl}}==

use strict ;

use warnings ;

}

$infocontent *= -1 ;

{{out}}

<pre>The information content of the source file is 4.6487923749222 !</pre>

 

=={{header|Phix}}==

Minor edit to the [[Entropy#Phix|Entropy]] answer, if compiled assumes source code is in the same directory.

 

 

{{out}}

<pre>

</pre>

 

Minor edit to the [[Entropy#Python|Entropy]] answer.

 

from collections import Counter

 

b=f.read()

{{Output}}

<pre>4.575438063744619</pre>

=={{header|Racket}}==

The entropy of the program below is 4.512678555350348.

#lang racket

(require math)

(- (for/sum ([(d c) (in-hash (samples->hash ds))])

(* (/ c n) (log2 (/ c n)))))

 

=={{header|REXX}}==

REXX doesn't have a BIF (built-in function) for &nbsp; '''log''' &nbsp; or &nbsp; '''ln''', &nbsp; so the subroutine (function) &nbsp; '''log2''' &nbsp; is included herein.

L=length($) /*the byte length of this REXX program.*/

say ' program length: ' L /*pgm length doesn't include meta chars*/

say 'program statements: ' recs /*pgm statements are actually pgm lines*/

say 'The information entropy of this REXX program ──► ' format(sum,,12)

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

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

<pre>

 

</pre>

 

=={{header|Ruby}}==

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

entropy - freq * Math.log2(freq)

end

end

s = File.read(__FILE__)

{{out}}

</pre>

 

=={{header|Rust}}==

use std::io::{Read, BufReader};

 

let file = BufReader::new(File::open(name).expect("Could not read file."));

println!("Entropy is {}.", entropy(file.bytes().flatten()));

{{out}}

<pre>Entropy is 5.7108583.</pre>

 

=={{header|Sidef}}==

[0,

s.chars.freq.values.map {|c|

}

 

{{out}}

<pre>

=={{header|Tcl}}==

Note that this code doesn't bother to close the open handle on the script; it is only suitable as a demonstration program.

set log2 [expr log(2)]

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

}

 

{{out}}

<pre>

entropy = 4.59099

</pre>

 

=={{header|zkl}}==

Minor edit to the [[Entropy#zkl|Entropy]] answer.

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

.fp1((0).pump(256,List,(0.0).create.fp(0)).copy()))

}

 

{{out}}

<pre>