Entropy/Narcissist: Difference between revisions

{{task}}

 

;Task:

 

=={{header|Ada}}==

with Ada.Command_Line;

with Ada.Numerics.Elementary_Functions;

Float_Io.Put (Entr);

New_Line;

{{out}}

<pre>Entropy of 'entropy.adb' is 4.559854</pre>

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>

As we have compiled without specific options to change the way the executable is named, we can retrieve the source file name by adding the suffix “.nim” to the executable file name. We suppose also that the source file is in the same directory as the executable (which is true in our environment).

 

 

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 = s.each_char.tally

size = s.size.to_f

s = File.read(__FILE__)

p entropy(s)

{{out}}

<pre>4.653607496799478

 

=={{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 l = s.count

 

{{out}}

4.6302314663

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