Module:Harmonic entropy

Module documentation[view] [edit] [history] [purge]

This module primarily serves as a library for other modules and has no corresponding template.

This module provides a means to calculate harmonic Shannon entropy of a particular interval.

Introspection summary for Module:Harmonic entropy
Functions provided (7) Line Function Params Description 7 to_cents (invokable) (frame) 12 _to_cents (ratio, prec) 34 parse_ET_size (invokable) (frame) 41 parse_ET_equave (invokable) (frame) 48 parse_ET (input) 65 backslash_ratio (invokable) (frame) 70 _backslash_ratio (input)	Lua modules required (3) Variable Module Functions used getArgs Module:Arguments getArgs rat Module:Rational new as_float parse u Module:Utils eval_num_arg _log _round

---

local getArgs = require('Module:Arguments').getArgs
local u = require('Module:Utils')
local rat = require('Module:Rational')
local p = {}

-- return measure in cents of an interval ratio, rounded to prec decimal places
function p.to_cents(frame)
	local args = getArgs(frame)
	return p._to_cents(args[1], args[2])
end	

function p._to_cents(ratio, prec)
	-- ratio defaults to 1
	ratio = u.eval_num_arg(ratio, 1)
	-- prec defaults to nil
	prec = u.eval_num_arg(prec)
	local result = 1200*u._log(ratio), prec
	if prec == nil then
		return result
	else
		return u._round(result, prec)
	end
end

-- edf = ed3/2, edo = ed2, edt = ed3
local equaves =
{
  ['f'] = rat.new(3, 2),
  ['o'] = 2,
  ['t'] = 3
}

-- returns size of an ET given its name
function p.parse_ET_size(frame)
	local args = getArgs(frame)
	local size, equave = p.parse_ET(args[1])
	return size
end

-- returns equave of an ET given its name
function p.parse_ET_equave(frame)
	local args = getArgs(frame)
	local size, equave = p.parse_ET(args[1])
	return rat.as_float(equave)
end

-- returns size and equave of an ET given its name; cannot be used with {{#invoke:}}
function p.parse_ET(input)
	input = string.lower(input)
	local size, equave
	-- size defaults to 12
	size = u.eval_num_arg(input:match("^([0-9]+)"), 12)
	if input:match("^[0-9]*[%-]?ed[fot]$") then
		equave = equaves[tostring(input:match("[fot]"))]
	else
		-- equave defaults to 2
		equave = rat.parse(input:match("^.-ed(.+)%s*$")) or 2
	end
	return size, equave
end

-- return ratio corresponding to an interval written in backslash notation
-- ("steps" of "size" equal divisions of the "equave")

function p.backslash_ratio(frame)
	local args = getArgs(frame)
	return p._backslash_ratio(args[1])
end	

function p._backslash_ratio(input)
	-- result defaults to 0
	local result = 0
	-- steps defaults to 1
	local steps = input:match("%s*(%-?[0-9]+)\\.-") or 1
	local size, equave = p.parse_ET(input:match("\\(.*)"))
	if tonumber(size) == 0 then
		return 1
	end
	result = rat.as_float(equave)^(tonumber(steps)/tonumber(size))
	return result
end

return p