モジュール:MOS mode degrees

このモジュールについての説明文ページを モジュール:MOS mode degrees/doc に作成できます

local p = {}

local mos = require("Module:MOS")
local tamnams = require("Module:TAMNAMS")
local tip = require("Module:Template input parse")
local yesno = require("Module:Yesno")

-- TODO
-- - Split off modmos mode degrees as a separate template

-- Global variables for cell colors
-- Colors are as follows:
-- - Orange and blue for small and large sizes, respectively
-- - Darker colors for altered scale degrees
-- - No color for period intervals
p.cell_color_none = "NONE"				-- For cells that don't have a color (default cell color applies)
p.cell_color_perfect_size = "NONE"		-- Only applies for periods, including the root and equave
p.cell_color_lg_altered_size = "#BDD7EE"
p.cell_color_large_size      = "#DDEBF7"
p.cell_color_small_size      = "#FCE4D6"
p.cell_color_sm_altered_size = "#F8CBAD"

-- Finds the row color for a single cell
function p.cell_color(interval, input_mos)
	local interval = interval or {["L"] = 3, ["s"] = 1}
	local input_mos = input_mos or mos.new(5, 2)
	
	local period_step_count = mos.period_step_count(input_mos)
	local interval_step_count = mos.interval_step_count(interval)
	local chroma_count = mos.interval_chroma_count(interval, input_mos)
	
	local is_period_interval = interval_step_count % period_step_count == 0
	
	local color = p.cell_color_none
	if is_period_interval then
		if chroma_count > 0 then
			color = p.cell_color_lg_altered_size
		elseif chroma_count == 0 then
			color = p.cell_color_none
		elseif chroma_count < 0 then
			color = p.cell_color_sm_altered_size
		end
	else
		if chroma_count > 0 then
			color = p.cell_color_lg_altered_size
		elseif chroma_count == 0 then
			color = p.cell_color_large_size
		elseif chroma_count == -1 then
			color = p.cell_color_small_size
		elseif chroma_count < -1 then
			color = p.cell_color_sm_altered_size
		end
	end
	return color
end

-- Create a table of a mos's degrees
-- If a step pattern is provided, it's assumed to be that of a modmos
function p._mos_mode_degrees(input_mos, mos_prefix, is_collapsed, step_pattern)
	local is_true_mos = step_pattern == nil
	local input_mos = input_mos or mos.new(5, 2)
	local mos_prefix = mos_prefix or "mos"
	local is_collapsed = is_collapsed == true
	
	-- Get the modes as strings and step vectors
	local step_patterns = {}
	local step_matrices = {}
	if is_true_mos then
		step_patterns = mos.modes_by_brightness(input_mos)
		step_matrices = mos.modes_to_step_matrices(input_mos)
	else
		step_patterns = mos.mode_rotations(step_pattern)
		step_matrices = mos.mode_rotations_to_step_matrices(step_pattern)
	end
	
	-- Get the scale sig
	local scale_sig = mos.as_string(input_mos)

	-- Equave step count; needed for degree column count
	local equave_step_count = mos.equave_step_count(input_mos)
	
	-- Get the brightness (UDP) and rotational orderings (CPOs).
	-- Also produce default mode names if set to do so.
	local udps = {}
	local cpos = {}
	if is_true_mos then
		-- Get UDPs and CPOs
		udps = tamnams.mos_mode_udps(input_mos)
		cpos = tamnams.mos_mode_cpos(input_mos)
	else
		-- Modmos udps require a mosabbrev; this is forced to be "m" since some
		-- abbrevs are tooo long. Get both the names for the closest-bright and
		-- closest-dark mode. If they're the same, only one name will be used;
		-- if not, both are used.
		-- The CPOs of a modmos are simply 1 to n (n is the mode count).
		local udps_closest_bright = tamnams.mode_rotation_udps(step_pattern, input_mos, "m", true)
		local udps_closest_dark = tamnams.mode_rotation_udps(step_pattern, input_mos, "m", false)
		for i = 1, #udps_closest_bright do
			if udps_closest_bright[i] == udps_closest_dark[i] then
				table.insert(udps, udps_closest_bright[i])
			else
				table.insert(udps, string.format("%s<br />%s", udps_closest_bright[i], udps_closest_dark[i]))
			end
			table.insert(cpos, i)
		end
	end
	
	-- Create table
	local result = "{| class=\"wikitable sortable mw-collapsible center-2 center-3"
		.. (is_collapsed and " mw-collapsed\"" or "\"") .. "\n"
	
	-- Table's title
	-- If it's for a modmos, add the step pattern
	result = result .. "|+ style=\"font-size: 105%; white-space: nowrap;\" | " .. string.format("%s各旋法における音階の度数", scale_sig)
		.. (is_true_mos and "\n" or string.format(" (%s)\n", step_pattern))
		.. "|-\n"
	
	-- Add table headers for first row
	result = result
		.. "! rowspan=\"2\" | UDP" .. (is_true_mos and "\n" or " and<br />alterations\n")		-- If modmos, add "and alterations" string
		.. "! rowspan=\"2\" | 循環順序\n"
		.. "! rowspan=\"2\" | パターン\n"
	
	-- Add header for scale degrees
	result = result .. string.format("! colspan=\"%d\" class=\"unsortable\" | 音階の度数 (%sdegree)\n", #step_matrices[1], mos_prefix)
	
	-- Add second row of headers
	result = result .. "|- class=\"unsortable\"\n"
		.. "! 0"
	for i = 1, #step_patterns[1] do
		result = result .. string.format("\n! %d", i)
	end
	
	result = result .. "\n"
	
	-- Add table contents
	for i = 1, #step_patterns do
		result = result .. "|-\n"
		
		-- Add brightness order (as UDP), rotational order, and step pattern
			.. string.format("| %s\n| %s\n| %s\n", udps[i], cpos[i], step_patterns[i])

		-- Add scale degrees with cell coloring
		for j = 1, #step_matrices[i] do
			local current_interval = step_matrices[i][j]
			local degree_quality = tamnams.decode_quality_japanese(current_interval, input_mos)
			
			local cell_color = p.cell_color(current_interval, input_mos)
			local style_code = (cell_color == p.cell_color_none and "" or string.format("style=\"background: %s;\" | ", cell_color))
			
			result = result .. string.format("| %s%s\n", style_code, degree_quality)
		end
	end
	
	-- End of table
	result = result .. "|}"
	
	return result
end

-- Function to be called as part of a template
function p.mos_mode_degrees(frame)
	-- Get args
	local input_mos    = mos.parse(frame.args["Scale Signature"])
	local mos_prefix   = frame.args["MOS Prefix"]
	local step_pattern = frame.args["MODMOS Step Pattern"]
	local mode_names_unparsed = frame.args["Mode Names"]
	
	-- Parse debugging option
	local debugg = yesno(frame.args["debug"])
	
	-- Get the scale sig; for calculating the mos prefix
	local scale_sig = mos.as_string(input_mos)
	
	-- Verify mosprefix
	mos_prefix = tamnams.verify_prefix(input_mos, mos_prefix)
	
	-- Get the mode names
	local mode_names = nil
	-- Default names for 5L 2s modes and select modmosses.
	-- Names are based on whichever mode is returnd by UDP closest-mode search,
	-- with common names added wherever applicable. Sources include:
	-- - https://www.jazz-guitar-licks.com/ and likely others
	-- - Whatever Wikipedia has cited for the Neapolitan scales
	-- NOTE: these names can be overridden if they don't suffice.
	if scale_sig == "5L 2s" then
		if step_pattern == "LsLLsAs" then
			-- Modes of harmonic minor
			-- Closest-mode search always returns one name
			mode_names = {
				"ハーモニックマイナー(和声的短音階)<br />(エオリアン♮7)",
				"ロクリアン♮6",
				"イオニアンオーグメンテッド<br />(イオニアン♯5)",
				"ドリアン♯4",
				"フリジアンドミナント<br />(フリジアン♮3)",
				"リディアン♯2",
				"オルタードディミニッシュド<br />(ロクリアン ♭4 𝄫7)",
			}
		elseif step_pattern == "LLsLsAs" then
			-- Modes of harmonic major
			-- Closest-mode search always returns one name
			mode_names = {
				"ハーモニックメジャー(和声的長音階)<br />(イオニアン♭6)",
				"ドリアン♭5",
				"フリジアン♭4",
				"リディアン♭3",
				"ミクソリディアン♭2",
				"リディアンオーグメンテッド♯2<br />(リディアン ♯2 ♯5)",
				"ロクリアン𝄫7",
			}
		elseif step_pattern == "LsLLLLs" then
			-- Modes of melodic minor
			-- Closest-mode search sometimes returns two names
			mode_names = {
				"メロディックマイナー(旋律的短音階)<br />(イオニアン♭3, ドリアン♮7)",
				"ドリアン♭2, フリジアン♮6",
				"リディアンオーグメンテッド<br />(リディアン♯5)",
				"リディアンドミナント<br />(リディアン♭7, ミクソリディアン♯4)",
				"ミクソリディアン♭6, エオリアン♮3",
				"ハーフディミニッシュド<br />(エオリアン♭5, ロクリアン♮2)",
				"オルタード、オルタードドミナント<br />(ロクリアン♭4)",
			}
		elseif step_pattern == "sLLLLLs" then
			-- Modes of Neapolitan major
			-- Closest-mode search sometimes returns two names
			mode_names = {
				"ナポリタンメジャー<br />(イオニアン ♭2 ♭3, フリジアン ♮6 ♮7)",
				"リディアンオーグメンテッド♯6<br />(リディアン ♯5 ♯6)",
				"リディアンオーグメンテッドドミナント<br />(リディアン ♯5 ♭7, ミクソリディアン ♯4 ♯5)",
				"リディアンマイナー<br />(ロクリアン ♭6 ♭7, エオリアン ♮3 ♯4)",
				"メジャーロクリアン<br />(ミクソリディアン ♭5 ♭6, ロクリアン ♮2 ♮3)",
				"オルタードドミナント♮2<br />(エオリアン ♭4 ♭5, ロクリアン ♮2, ♭4)",
				"オルタードドミナント𝄫3<br />(ロクリアン 𝄫3 ♭4)",
			}
		elseif step_pattern == "sLLLsAs" then
			-- Modes of Neapolitan minor
			-- Closest-mode search always returns one name
			mode_names = {
				"ナポリタンマイナー<br />(フリジアン♮7)",
				"リディアン♯6",
				"ミクソリディアンオーグメンテッド<br />(ミクソリディアン♯5)",
				"エオリアン♯4",
				"ロクリアンドミナント<br />(ロクリアン♮3)",
				"イオニアン♯2",
				"オルタードディミニッシュド𝄫3<br />(ロクリアン 3 ♭4 𝄫7)",
			}
			elseif step_pattern == "sAsLsAs" then
			-- Modes of double harmonic
			-- Closest-mode search sometimes returns two names
			mode_names = {
				"ダブルハーモニック<br />(イオニアン ♭2 ♭6, フリジアン ♮3 ♮7)",
				"リディアン♯2 ♯6",
				"オルタード♮5 𝄫6<br />(フリジアン ♭4 𝄫7)",
				"ダブルハーモニックマイナー<br />(リディアン ♭3 ♭6, エオリアン ♯4 ♮7)",
				"ミクソリディアン ♭2 ♭5, ロクリアン ♮3 ♮6",
				"イオニアンオーグメンテッド ♯2<br />(イオニアン ♯2 ♯5)",
				"ロクリアン 𝄫3 𝄫7",
			}
		elseif #step_pattern == 0 then
			-- True-mos modes
			mode_names = { 
				"リディアン",
				"イオニアン (長調/メジャー)",
				"ミクソリディアン",
				"ドリアン",
				"エオリアン(短調/マイナー)",
				"フリジアン",
				"ロクリアン"
			}
		end
	end
	
	-- If mode names are given, use those instead
	-- If using default mode names (scalesig+udp), those names are auto-added by the relevant function
	local use_default_names = false
	if #mode_names_unparsed ~= 0 then
		if mode_names_unparsed == "Default" then
			use_default_names = true
		else
			mode_names = tip.parse_entries(mode_names_unparsed)
		end
	end
	
	-- Check if the table should start collapsed
	local is_collapsed = yesno(frame.args["Collapsed"], false)
	
	-- If a modmos step pattern was never provided, call the function mos_mode_degrees
	-- Otherwise, call the function modmos_mode_degrees
	local result = ""
	if step_pattern == "" then
		result = p._mos_mode_degrees(input_mos, mos_prefix, is_collapsed)
	--elseif #step_pattern == input_mos.nL + input_mos.ns then
	else
		result = p._mos_mode_degrees(input_mos, mos_prefix, is_collapsed, step_pattern)
	end
	
	-- Debugger option
	if debugg == true then
		result = "<syntaxhighlight lang=\"wikitext\">" .. result .. "</syntaxhighlight>"
	end
	
	return frame:preprocess(result)
end

return p