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|C++}}==

#include <fstream>

#include <cmath>

cout<<entropy(readFile("entropy.cpp"));

return 0;

{{out}}

<pre>4.58688</pre>

=={{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>Entropy of file "src/EntropyNarcissist.java" = 4.691381977073.</pre>

 

=={{header|Julia}}==

 

entropy(s) = -sum(x -> x / length(s) * log2(x / length(s)), values(counter(s)))

 

{{out}}

 

=={{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|Nim}}==

 

let execName = getAppFilename().splitPath().tail

 

echo "Source file entropy: ", srcName.readFile().entropy().formatFloat(ffDecimal, 5)

 

{{out}}

 

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

 

=={{header|PHP}}==

 

$h = 0;

$s = file_get_contents(__FILE__);

( $c / $l ) *

log( $c / $l, 2 );

 

{{out}}

<pre>2.9339128173013</pre>

 

=={{header|PicoLisp}}==

(scl 8)

(load "@lib/math.l")

 

(bye)

{{Out}}

<pre>

My entropy is 4.12169822

</pre>

=={{header|Python}}==

{{works with|Python 3.4}}

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

(formerly Perl 6)

{{Works with|rakudo|2016.05}}

Result should be in the neighborhood of 4.9

{{out}}

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

numeric digits length( e() ) % 2 - length(.) /*use 1/2 of the decimal digits of E. */

#= 0; @.= 0; $=; $$=; recs= sourceline() /*define some handy─dandy REXX vars. */

ox=izz; ii=ii+is*2**j; end /*while*/; x= x * e** -ii -1; z= 0; _= -1; p= z

do k=1; _= -_ * x; z= z+_/k; if z=p then leave; p= z; end /*k*/

{{out|output|text=&nbsp; when using this REXX program as input:}}

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

Basically an amalgam of the code in the [[Print_itself#Wren]] and [[Entropy#Wren]] tasks.

import "io" for File

 

var args = Process.allArguments

for (k in m.keys) {

var c = m[k]

}

var l = s.count

 

{{out}}

<pre>

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