% \iffalse meta-comment
% Copyright (C) 2021 Jamal Bouajjaj | 2015, 2016, 2017 Mattias Jacobsson and contributors
% This work, cartonaugh, is a fork of Mattias Jacobsson's [karnaugh-map](
https://github.com/2pi/karnaugh-map) package with major changes. As the copyright on the base package is under [CC BY-SA](
https://creativecommons.org/licenses/by-sa/3.0/), so is this fork.
% \fi
%
% \iffalse
%<*package>
%<package>%%
%<package>%% Copyright (C) 2021 Jamal Bouajjaj | 2015, 2016, 2017 Mattias Jacobsson and contributors
%<package>%% This work, cartonaugh, is a fork of Mattias Jacobsson's [karnaugh-map](
https://github.com/2pi/karnaugh-map) package with major changes. As the copyright on the base package is under [CC BY-SA](
https://creativecommons.org/licenses/by-sa/3.0/), so is this fork.
%<package>%%
%<package>
%<package>\NeedsTeXFormat{LaTeX2e}
%<package>\ProvidesPackage{cartonaugh}[2021/07/15 v1.0 Draw Karnaugh Maps]
%
%<*driver>
\documentclass{ltxdoc}
\usepackage{cartonaugh}
\usepackage{multicol}% for documentation
\usepackage{tabularx}% for documentation
\usepackage{float}% for documentation
\usepackage{hyperref}% for documentation
\setlength{\parindent}{0pt}
\setlength{\parskip}{0.6em}
\EnableCrossrefs
\CodelineIndex
\RecordChanges
\OnlyDescription
\begin{document}
\DeleteShortVerb{\|}
\DocInput{cartonaugh.dtx}
\PrintChanges
\end{document}
%</driver>
% \fi
%
% \CharacterTable
% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z
% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z
% Digits \0\1\2\3\4\5\6\7\8\9
% Exclamation \! Double quote \" Hash (number) \#
% Dollar \$ Percent \% Ampersand \&
% Acute accent \' Left paren \( Right paren \)
% Asterisk \* Plus \+ Comma \,
% Minus \- Point \. Solidus \/
% Colon \: Semicolon \; Less than \<
% Equals \= Greater than \> Question mark \?
% Commercial at \@ Left bracket \[ Backslash \\
% Right bracket \] Circumflex \^ Underscore \_
% Grave accent \` Left brace \{ Vertical bar \|
% Right brace \} Tilde \~}
%
%
% \changes{v1.0}{2021/07/15}{Initial Release}
%
% \GetFileInfo{cartonaugh.sty}
%
% \title{The \textsf{cartonaugh} package}
% \author{Jamal Bouajjaj}
% \date{\textsf{cartonaugh}~\fileversion, \filedate}
%
%\maketitle
%
% \begin{abstract}
% This package, a fork of Mattias Jacobsson/2pi's \href{
https://github.com/2pi/karnaugh-map}{karnaugh-map} package, draws karnaugh maps with 2, 3, 4, 5, and 6 variables.
% It also contains commands for filling the karnaugh map with terms semi-automatically or manually.
% Last but not least it contains commands for drawing implicants on top of the map.
% Cartonaugh is a portmanteau of ``cartographer`` and ``karnaugh``.
% Below is an example of a two variable karnaugh map of $X_0 \oplus X_1$.
% \end{abstract}
% \begin{figure}[H]
% \centering
% \begin{cartonaugh}[2][2][1][$X_0$][$X_1$]
% \minterms{1,2}
% \autoterms[0]
% \implicant{1}{1}
% \implicant{2}{2}
% \end{cartonaugh}
% \end{figure}
% \tableofcontents
% \pagebreak
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
%%
%% Dependencies
%%
%% Check if ran under LuaLaTeX. If not, exit
\RequirePackage{iftex}
\RequireLuaTeX
%% parsing arguments
\RequirePackage{xparse}
%% working with strings
\RequirePackage{xstring}
%% drawing
\RequirePackage{tikz}
\usetikzlibrary{calc,matrix}
%%
%% Helpers
%%
\directlua{require("cartonaugh")}
%% command raises an error if executed outside the cartonaugh environment
\newcommand{\@cartonaugh@func@bailoutsideenvironment@}[0]{%
\ifnum\@cartonaugh@var@isactive@=0
\PackageError{cartonaugh}{%
Command can not be used outside cartonaugh environment%
}{%
Do not use this command outside the cartonaugh environment.%
}
\fi
}
\newcommand{\cartonaughSetColorAtIndex}[2]{\directlua{CARTONAUGH_COLORS[\the\numexpr(#1)\relax] = "\luaescapestring{#2}"}}
%% store whether a kmap has been created
\newcommand{\@cartonaugh@var@isactive@}{0}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
% \fi
%
% \section{Usage}
%
% \begin{environment}{cartonaugh}
% The |cartonaugh| environment is the base for this package, and everything related to this package happens inside an instances of this environment.
%
% \textbf{Usage:}
% \MakeShortVerb{\|}
% \begin{tabularx}{\textwidth}{l X}
% \small{|\begin{cartonaugh}|} & \\
% \small{\meta{*}} & \small{One asterisk for black and white implicants, non for colorized implicants} \\
% \small{\oarg{X size}} & \small{Number of X-axis cells. Default: ''4''} \\
% \small{\oarg{Y size}} & \small{Number of Y-axis cells. Default: ''4''} \\
% \small{\oarg{Z size}} & \small{Number of X$\times$Y submaps. Default: ''1''} \\
% \small{\oarg{X label}} & \small{Label for the X-axis. Default: ''$X_1X_0$''} \\
% \small{\oarg{Y label}} & \small{Label for the Y-axis. Default: ''$X_3X_2$''} \\
% \small{\oarg{Z label}} & \small{Label for the submaps. Default: ''$X_5X_4$''} \\
% \small{\oarg{Submap Seperation Type}} & \small{Whether to seperate the submap by space or by a thick line. Default: 0 (so seperation by space)} \\
% \end{tabularx}
% \DeleteShortVerb{\|}
% \textbf{Example:}
%
% Four variable karnaugh map, colorized, with X label $X_1X_0$, and Y label $X_3X_2$.
% \begin{verbatim}
%\begin{cartonaugh}
%\end{cartonaugh}
%
%or
%
%\begin{cartonaugh}[4][4][1][$X_1X_0$][$X_3X_2$]
%\end{cartonaugh}
% \end{verbatim}
% Six variable karnaugh map, black and white, with X label $ba$, Y label $dc$, and Z label $fe$.
% \begin{verbatim}
%\begin{cartonaugh}*[4][4][4][$ba$][$dc$][$fe$]
%\end{cartonaugh}
% \end{verbatim}
%
% Six variable karnaugh map, black and white, with X label $ba$, Y label $dc$, and Z label $fe$, and the submaps are seperated by a thick line in between.
% \begin{verbatim}
%\begin{cartonaugh}*[4][4][4][$ba$][$dc$][$fe$][1]
%\end{cartonaugh}
% \end{verbatim}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\NewDocumentEnvironment{cartonaugh}{s O{4} O{4} O{1} O{$X_1X_0$} O{$X_3X_2$} O{$X_5X_4$} O{0}} {%
\begingroup
% store map size {[START]
\renewcommand{\@cartonaugh@var@isactive@}{1}%
% [END]}
% determinate if markings should be color or black and white
%
% [END]}
% test if a matrix template is found or not(aka "\@cartonaugh@local@matrixtemplate@" equals to '0')
\begin{tikzpicture}
\directlua{init_cartonaught_env(
\the\numexpr(#2)\relax,
\the\numexpr(#3)\relax,
\the\numexpr(#4)\relax,
\the\numexpr(#1)\relax,
"\luaescapestring{\detokenize{#5}}",
"\luaescapestring{\detokenize{#6}}",
"\luaescapestring{\detokenize{#7}}",
\the\numexpr(#8)\relax
)}
}{
\end{tikzpicture}
\endgroup
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
% \fi
% \end{environment}
%
% \newpage
% \MakeShortVerb{\|}
% \subsection{Terms}
% \begin{macro}{\autoterms}
% The |\autoterms| command fills the remaining unfilled cells of the karnaugh map with the contents of the optional argument.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\autoterms|} & \\
% \small{\oarg{content}} & \small{Content for the remaining unfilled cells. Default: ''-''}
% \end{tabularx}
%
% \textbf{Example:}
%
% Fill all remaining unfilled cells with ''-''.
% \begin{verbatim}
% \DeleteShortVerb{\|}
%\begin{cartonaugh}
% \autoterms[-]
%\end{cartonaugh}
% \end{verbatim}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\autoterms}{O{-}} {%
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
autoterms("\luaescapestring{\detokenize{#1}}", '-')
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
% \fi
%
% \end{macro}
%
% \begin{macro}{\indeterminants}
% The |\indeterminants| command fills the specified cells with ''-'' if they aren't already filled. Order of the cell numbers does not matter.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\indeterminants|} & \\
% \small{\marg{cells}} & \small{Comma separated list of cells to fill with ''-''}
% \end{tabularx}
%
% \textbf{Example:}
%
% Fill the top left and right cell with ''-''.
% \begin{verbatim}
%\begin{cartonaugh}
% \indeterminants{0,2}
%\end{cartonaugh}
% \end{verbatim}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\indeterminants}{m} {%
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
write_to_cell("\luaescapestring{\detokenize{#1}}", '-')
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
% \fi
%
% \end{macro}
%
% \begin{macro}{\manualterms}
% The |\manualterms| command fills the 0th cell with the first element in the argument, the 1st cell with the second element in the argument, and so on. If any of the cells already is filled, it is left as it was.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\manualterms|} & \\
% \small{\marg{content}} & \small{Comma separated list of cell contents}
% \end{tabularx}
%
% \textbf{Example:}
%
% Fill the first four cells with 0, 1, 0, and 1 respectively.
% \begin{verbatim}
%\begin{cartonaugh}
% \manualterms{0,1,0,1}
%\end{cartonaugh}
% \end{verbatim}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\manualterms}{m} {%
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
manualterms("\luaescapestring{\detokenize{#1}}")
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
% \fi
%
% \end{macro}
%
% \begin{macro}{\maxterms}
% The |\maxterms| command fills the specified cells with ''0'' if they aren't already filled. Order of the cell numbers does not matter.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\maxterms|} & \\
% \small{\marg{cells}} & \small{Comma separated list of cells to fill with ''0''} \\
% \end{tabularx}
%
% \textbf{Example:}
%
% Fill the top left and right cell with ''0''.
% \begin{verbatim}
%\begin{cartonaugh}
% \maxterms{0,2}
%\end{cartonaugh}
% \end{verbatim}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\maxterms}{m} {%
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
write_to_cell("\luaescapestring{\detokenize{#1}}", '0')
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
%
% \begin{macro}{\minterms}
% The |\minterms| command fills the specified cells with ''1'' if they aren't already filled. Order of the cell numbers does not matter.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\minterms|} & \\
% \small{\marg{cells}} & \small{Comma separated list of cells to fill with ''1''} \\
% \end{tabularx}
%
% \textbf{Example:}
%
% Fill the top left and right cell with ''1''.
% \begin{verbatim}
%\begin{cartonaugh}
% \minterms{0,2}
%\end{cartonaugh}
% \end{verbatim}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\minterms}{m} {%
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
write_to_cell("\luaescapestring{\detokenize{#1}}", '1')
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
%
% \begin{macro}{\terms}
% The |\terms| command fills the specified cells with the specified content if they aren't already filled. Order of the cell numbers does not matter.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\terms|} & \\
% \small{\marg{cells}} & \small{Comma separated list of cells to fill with content} \\
% \small{\marg{content}} & \small{Content to fill the cells with} \\
% \end{tabularx}
%
% \textbf{Example:}
%
% Fill the top left and right cell with ''X''.
% \begin{verbatim}
%\begin{cartonaugh}
% \terms{0,2}{X}
%\end{cartonaugh}
% \end{verbatim}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\terms}{m m} {%
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
write_to_cell("\luaescapestring{\detokenize{#1}}",
"\luaescapestring{\detokenize{#2}}")
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
%
% \newpage
% \MakeShortVerb{\|}
% \subsection{Implicants}
% \begin{macro}{\implicant}
% The |\implicant| command draws quadratic implicants on one or multiple submaps. If the implicant shall be drawn on multiple submaps, \marg{northwest cell} and \marg{southeast cell} must be specified as if the implicant was to be drawn on the 0:th submap. When turned on, colorization is done automatically, following a global sequence of available colors.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\implicant|} & \\
% \small{\marg{northwest cell}} & \small{The most northwest cell in the implicant} \\
% \small{\marg{southeast cell}} & \small{The most southeast cell in the implicant} \\
% \small{\oarg{submaps}} & \small{Comma separated list of submaps the implicant should be drawn on. Default: ''0''} \\
% \end{tabularx}
%
% \textbf{Example:}
% \DeleteShortVerb{\|}
% \begin{multicols}{2}
% [Implicant around the four most inner cells.]
% \begin{verbatim}
%\begin{cartonaugh}
% \implicant{5}{15}
%\end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}
% \implicant{5}{15}
% \end{cartonaugh}
% }
% \end{multicols}
% \begin{multicols}{2}
% [Single cell implicant, 0:th cell, on all four submaps.]
% \begin{verbatim}
%\begin{cartonaugh}[4][4][4]
% [$BA$][$DC$][$FE$][1]
% \implicant{0}{0}[0,1,2,3]
%\end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}[4][4][4][$BA$][$DC$][$FE$][1]
% \implicant{0}{0}[0,1,2,3]
% \end{cartonaugh}
% }
% \end{multicols}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\implicant}{m m O{0}} {%
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
manual_draw_implicant(
"\luaescapestring{\detokenize{#1}}",
"\luaescapestring{\detokenize{#2}}",
"\luaescapestring{\detokenize{#3}}"
)
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
%
% \MakeShortVerb{\|}
% \begin{macro}{\implicantedge}
% The |\implicantedge| command draws quadratic implicants with the middle of the implicant facing the edge of a submap either horizontally or vertically. The function is able to draw the same implicant on one or multiple submaps. However if the implicant shall be drawn on multiple submaps, \marg{northwest part - northwest cell}, \marg{northwest part - southeast cell}, \marg{southeast part - northwest cell}, \marg{southeast part - southeast cell} must be specified as if the implicant was to be drawn on the 0:th submap. When turned on, colorization is done automatically, following a global sequence of available colors.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\implicantedge|} & \\
% \small{\marg{northwest part - northwest cell}} & \small{The most northwest cell in the northwest part of the implicant} \\
% \small{\marg{northwest part - southeast cell}} & \small{The most southeast cell in the northwest part of the implicant} \\
% \small{\marg{southeast part - northwest cell}} & \small{The most northwest cell in the southeast part of the implicant} \\
% \small{\marg{southeast part - southeast cell}} & \small{The most southeast cell in the southeast part of the implicant} \\
% \small{\oarg{submaps}} & \small{Comma separated list of submaps the implicant should be drawn on. Default: ''0''} \\
% \end{tabularx}
%
% \textbf{Example:}
% \DeleteShortVerb{\|}
%
% \begin{multicols}{2}
% [Horizontal implicant over the submap edge containing the cells 4, 6, 12, and 14.]
% \begin{verbatim}
%\begin{cartonaugh}
% \implicantedge{4}{12}{6}{14}
%\end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}
% \implicantedge{4}{12}{6}{14}
% \end{cartonaugh}
% }
% \end{multicols}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\implicantedge}{m m m m O{0}} {%
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
manual_draw_edge_implicant(
"\luaescapestring{\detokenize{#1}}",
"\luaescapestring{\detokenize{#2}}",
"\luaescapestring{\detokenize{#3}}",
"\luaescapestring{\detokenize{#4}}",
"\luaescapestring{\detokenize{#5}}"
)
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
% \MakeShortVerb{\|}
% \begin{macro}{\implicantcorner}
% The |\implicantcorner| command draws an implicant around only the four corner pieces on one or multiple four variable karnaugh submaps. When turned on, colorization is done automatically, following a global sequence of available colors.
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\implicantcorner|} & \\
% \small{\oarg{submaps}} & \small{Comma separated list of submaps the implicant should be drawn on. Default: ''0''} \\
% \end{tabularx}
%
% \textbf{Example:}
% \DeleteShortVerb{\|}
%
% \begin{multicols}{2}
% [Draw an implicant around all corners on 0th and 2nd submap of a six variable karnaugh map.]
% \begin{verbatim}
%\begin{cartonaugh}[4][4][4]
% \implicantcorner[0,2]
%\end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}[4][4][4]
% \implicantcorner[0,2]
% \end{cartonaugh}
% }
% \end{multicols}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\implicantcorner}{O{0}} {
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
manual_draw_corner_implicant(
"\luaescapestring{\detokenize{#1}}"
)
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
%
% \newpage
% \MakeShortVerb{\|}
% \subsection{Options}
% \begin{macro}{\implicantspread}
% The |\implicantspread| changed the implicant spread
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\implicantspread|} & \\
% \small{\marg{innerspread}} & \small{The inner spread's spread, from 0 to 0.5 (as >0.5 will go out of the implicant square)} \\
% \small{\marg{outerspread}} & \small{The outer spread's spread, from 0.5 and up} \\
% \end{tabularx}
%
% \textbf{Example:}
% \DeleteShortVerb{\|}
%
% \begin{multicols}{2}
% \begin{verbatim}
% \begin{cartonaugh}[4][4][2]
% \implicantedge{4}{12}{6}{14}[0]
% \implicantspread{0.25}{0.7}
% \implicantedge{4}{12}{6}{14}[1]
% \end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}[4][4][2]
% \implicantedge{4}{12}{6}{14}[0]
% \implicantspread{0.25}{0.7}
% \implicantedge{4}{12}{6}{14}[1]
% \end{cartonaugh}
% }
% \end{multicols}
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\implicantspread}{m m} {
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
change_implicant_inner_spread(\luaescapestring{\detokenize{#1}})
change_implicant_outer_spread(\luaescapestring{\detokenize{#2}})
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
%
% \MakeShortVerb{\|}
% \begin{macro}{\resetimplicantspread}
% The |\resetimplicantspread| resets the implicant spread if set by |\implicantspread| to default values
% \DeleteShortVerb{\|}
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\resetimplicantspread}{} {
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
change_implicant_inner_spread(0.35)
change_implicant_outer_spread(0.55)
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
% \MakeShortVerb{\|}
% \begin{macro}{\changecolor}
% The |\changecolor| changes the color for implicants
%
% \textbf{Usage:}
%
% \begin{tabularx}{\textwidth}{l X}
% \small{|\changecolor|} & \\
% \small{\marg{color}} & \small{The new color for implicants, in Tikz format} \\
% \end{tabularx}
% \DeleteShortVerb{\|}
% \textbf{Example:}
%
% \begin{multicols}{2}
% [Change the implicant color to pink, then green]
% \begin{verbatim}
% \begin{cartonaugh}
% \changecolor{pink}
% \implicant{0}{1}
% \changecolor{green}
% \implicant{8}{10}
% \end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}
% \changecolor{pink}
% \implicant{0}{1}
% \changecolor{green}
% \implicant{8}{10}
% \end{cartonaugh}
% }
% \end{multicols}
%
%
% \iffalse
% \begin{macrocode}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
\DeclareDocumentCommand{\changecolor}{m} {
% bail if outside environment cartonaugh
\@cartonaugh@func@bailoutsideenvironment@{}
%
\directlua{
customColor("\luaescapestring{\detokenize{#1}}")
}
}
% ^^A ##########################################################################
% ^^A ##########################################################################
% ^^A #### /CODE ####
% ^^A ##########################################################################
% ^^A ##########################################################################
% \end{macrocode}
%\fi
%
% \end{macro}
%
% \newpage
% \section{Examples}
% \begin{multicols}{2}
% [Draw a karnaugh map for \small{$f(a,b,c,d,e,f) =$\\$\Sigma(0,1,2,3,8,13,17,20,22,28,33,32,30,19,40,35,49,42,34,10,60,54,62,51,52)$\\$+d(15,45,47)$}.]
% \begin{verbatim}
%\begin{cartonaugh}[4][4][4][$ba$][$dc$][$fe$][1]
% \minterms{0,1,2,3,8,13,17,20,22,28,
% 33,32,30,19,40,35,49,42,34,10,60,
% 54,62,51,52}
% \indeterminants{15,45,47}
% \autoterms[0]
% \implicantcorner[0,2]
% \implicant{1}{3}[0,1,2,3]
% \implicantedge{4}{12}{6}{14}[1,3]
% \implicant{13}{15}[0,2]
%\end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}[4][4][4][$ba$][$dc$][$fe$][1]
% \minterms{0,1,2,3,8,13,17,20,22,28,33,32,30,19,40,35,49,42,34,10,60,54,62,51,52}
% \indeterminants{15,45,47}
% \autoterms[0]
% \implicantcorner[0,2]
% \implicant{1}{3}[0,1,2,3]
% \implicantedge{4}{12}{6}{14}[1,3]
% \implicant{13}{15}[0,2]
% \end{cartonaugh}
% }
% \end{multicols}
%
% \begin{multicols}{2}
% [Draw a karnaugh map for \small{$f(X_0,X_1) = \Pi(0,2,3)$} in black and white.]
% \begin{verbatim}
%\begin{cartonaugh}*[2][2][1][$X_0$][$X_1$]
% \maxterms{0,2,3}
% \autoterms[1]
% \implicant{1}{1}
%\end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}*[2][2][1][$X_0$][$X_1$]
% \maxterms{0,2,3}
% \autoterms[1]
% \implicant{1}{1}
% \end{cartonaugh}
% }
% \end{multicols}
%
% \newpage
% \begin{multicols}{2}
% [Draw a variable entered map.]
% \begin{verbatim}
%\begin{cartonaugh}[4][2][1][$ab$][$c$]
% \maxterms{0,2,4,5,6}
% \minterms{3}
% \terms{1}{$d$}
% \terms{7}{$d'$}
% \implicant{1}{3}
% \implicant{3}{7}
%\end{cartonaugh}
% \end{verbatim}
% \columnbreak
% \resizebox{\columnwidth}{!}{
% \begin{cartonaugh}[4][2][1][$ab$][$c$]
% \maxterms{0,2,4,5,6}
% \minterms{3}
% \terms{1}{$d$}
% \terms{7}{$d'$}
% \implicant{1}{3}
% \implicant{3}{7}
% \end{cartonaugh}
% }
% \end{multicols}
%
% \section{Dependencies}
% \begin{itemize}
% \item tikz
% \item xparse
% \item xstring
% \item lualatex
% \end{itemize}
%
% \newpage
% \section{Miscellaneous}
% \MakeShortVerb{\|}
% \subsection*{Resizing}
% The karnaugh maps produced with this package have a prespecified size which can not be changed. However you can resize the karnaugh map to your desired size. Resizing can be done using the |\resizebox| command from the graphicx package. Scaling the karnaugh map to fill the column width while preserving the aspect ratio can be done as follows.
% \begin{verbatim}
%\resizebox{\columnwidth}{!}{
% \DeleteShortVerb{\|}
% \begin{cartonaugh}
% \end{cartonaugh}
%}
% \end{verbatim}
%
% \subsection*{Comma separated lists}
% Anywhere in this package where a comma separated list is used data should only be comma separated. Therefore a comma and space separeated list will for example \textit{not} work properly.
%
% An example of errorious usage related to the \small{\marg{cells}} parameter in the terms related commands can result in multiple zeros, ones and other terms overlapping in the same cell in the outputted karnaugh map.
%
%\iffalse
%</package>
%<*luacode>
%
%
% This is the Luacode that is generated and put into cartonaugh.lua
%
%
%\begin{macrocode}
DEBUG_FLAG = 0
CARTONAUGH_COLORS = {'red', 'green', 'yellow', 'cyan', 'blue', 'magenta'}
CARTONAUGH_DEFAULT_COLOR = 'cyan'
cartonaugh_env_settings = {}
used_cells = {}
-- Function that is used to either print to LaTeX or to the console
-- Used for debugging mode
function localPrint(str)
if DEBUG_FLAG==1 then
print(str)
end
tex.sprint(str)
end
-- Function that takes a string and splits it be delimiter, then returns it back
-- From
https://stackoverflow.com/questions/19262761/lua-need-to-split-at-comma
function split(source, delimiters)
local elements = {}
local pattern = '([^'..delimiters..']+)'
string.gsub(source, pattern, function(value) elements[#elements + 1] = value; end);
return elements
end
-- Function that converts a decimal number to binary
function decimalToBin(num, numb_bits, return_concat)
if return_concat == nil then return_concat=true end
num = tonumber(num)
numb_bits = tonumber(numb_bits)
local t={}
for b=numb_bits,1,-1 do
rest=math.floor(math.fmod(num,2))
t[b]=rest
num=(num-rest)/2
end
if return_concat == true then
return table.concat(t)
else
return t
end
end
-- Function that converts a decimal number to grey code
function decimalToGreyBin(num, numb_bits)
-- Get the binary array
num = num ~ (num >> 1)
local t = decimalToBin(num, numb_bits, false)
return table.concat(t)
end
function greyBinToDecimal(num)
-- num = tonumber(num,2)
local mask = num
while mask > 0 do
mask = mask >> 1
num = num ~ mask
end
return tonumber(num)
end
-- Function to pad a string by a amount with b string
function padString(str, pad_to, pad_with)
local ret = str
for l=1, (pad_to-string.len(str)) do
ret = pad_with .. ret
end
return ret
end
function getColor(index)
if index <= 0 then return CARTONAUGH_DEFAULT_COLOR end
if CARTONAUGH_COLORS[index] ~= nil then
return CARTONAUGH_COLORS[index]
else
return CARTONAUGH_DEFAULT_COLOR
end
end
function customColor(color)
-- Some high number so it's not in the CARTONAUGH_COLORS array
cartonaugh_env_settings.color_index = 100
CARTONAUGH_DEFAULT_COLOR = color
end
-- Function to generate a kmap template
function generateKMap(column, row, grid_numb)
local outside_column_bits = 1
local outside_row_bits = 1
local outside_grid_numb_bits = 2
local return_str = ''
if row >= 4 then
outside_row_bits = 2
end
if column >= 4 then
outside_column_bits = 2
end
for c=1,column,1 do
for r=1,row,1 do
if r == 0 then
if c == 0 then
-- Do Nothing...
elseif c == (column+1) then
return_str = return_str .. ("\\phantom{" .. decimalToBin(0, outside_column_bits) .. "}")
else
return_str = return_str .. (decimalToGreyBin(c-1, outside_column_bits))
end
elseif r==(row+1) then
if c==0 then
return_str = return_str .. ("\\phantom{" .. decimalToBin(0, outside_column_bits) .. "}")
end
else
if c == 0 then
return_str = return_str .. (decimalToGreyBin(r-1, outside_row_bits))
elseif c == (column+1) then
else
return_str = return_str ..("|(" .. padString((decimalToGreyBin(grid_numb, outside_grid_numb_bits) .. decimalToGreyBin(c-1, outside_column_bits) .. decimalToGreyBin(r-1, outside_row_bits)), 6, 0) .. ")|" .. "\\phantom{0}")
--TODO: Look into why reversing c and r from where they should be makes it work
end
end
if r == (row) then
return_str = return_str .. ("\\\\")
else
return_str = return_str .. ("\\&")
end
end
end
return return_str
end
function init_cartonaught_env(numb_cols, numb_row, numb_submaps, is_bw, var12_str, var34_str, var56_str, is_submap_seperated)
-- Change the default texts depending on the number of submaps if not custom name has been given
-- TODO: Get this to actually work
if var12_str == 'X_1X_0' and var34_str == 'X_3X_2' and var56_str == 'X_5X_4' then
if numb_submaps == 1 then
var56_str = 'X_3'
end
if numb_cols == 1 then
var12_str = 'X_0'
end
end
cartonaugh_env_settings = {
cols = numb_cols,
rows = numb_row,
submaps = numb_submaps,
bw = tonumber(is_bw),
var_string = {
v12 = var12_str,
v34 = var34_str,
v56 = var56_str,
},
color_index = 1,
implicant_settings = {
inner_sep = 0.35,
outer_sep = 0.55,
}
}
used_cells = {}
if is_submap_seperated == 0 then
is_submap_seperated = false
else
is_submap_seperated = true
end
draw_pgf_kmap(numb_cols, numb_row, numb_submaps, var12_str, var34_str, var56_str, is_submap_seperated)
end
function change_implicant_inner_spread(new_amount)
cartonaugh_env_settings.implicant_settings.inner_sep = new_amount
end
function change_implicant_outer_spread(new_amount)
cartonaugh_env_settings.implicant_settings.outer_sep = new_amount
end
-- Function to generate the k-maps
-- NOTE: Each variable/cell in the k-map is 1cm. This is so that everything alings with each other just be adding
-- the number of row and column. It's a bit of hack, but for now it will stay this way. Resizing of the matrix
-- will be done with the scale option in the future
function draw_pgf_kmap(column, row, submaps_n, var1, var2, var3, is_submap_seperated)
submaps_n = submaps_n-1
-- TODO: Transform the following settings variables into arguments
local is_multitable_seperated = is_submap_seperated -- Setting to determine if the graphs are drawn with a sperator line or distanced out
local graph_seperator = 1.5 -- Seperation lenght between kmaps if is_multitable_seperated=false
local kmaplevel_seperator_lenght = 0.1 -- Setting to determine the seperator line's thickness if is_multitable_seperated=true
local line_width = 0.015 -- Set the line thickness of things here
local zero_var_line_lenght = 0.75 -- The lenght of the line at the top-left corner of the kmap where the implacants reside
local column_header_numb_bits = ((column-1) // 2)+1
local row_header_numb_bits = ((row-1) // 2)+1
if is_multitable_seperated then graph_seperator = 0 end
for d=0,submaps_n,1 do
-- Find the top-left corner of each grid (seperated by 1 unit)
local grid_x_loc = (d % 2)*(column+graph_seperator)
local grid_y_loc = -(d // 2)*(row+graph_seperator)
-- localPrint(string.format("\\node[above] at (%f,%f) {\\small{%s}};", 0, 0, abimplecant))
if is_multitable_seperated then
if (d % 2) == 1 then
local add_heigh = 0
if d >= 2 then add_heigh = kmaplevel_seperator_lenght end
localPrint(string.format("\\fill[black] (%f,%f) rectangle (%f,%f);", grid_x_loc, grid_y_loc, grid_x_loc+kmaplevel_seperator_lenght, grid_y_loc-row-line_width-add_heigh))
grid_x_loc = grid_x_loc + kmaplevel_seperator_lenght
end
if d >= 2 then
localPrint(string.format("\\fill[black] (%f,%f) rectangle (%f,%f);", grid_x_loc, grid_y_loc, grid_x_loc+column+line_width, grid_y_loc-kmaplevel_seperator_lenght))
grid_y_loc = grid_y_loc - kmaplevel_seperator_lenght
end
end
-- Print out the top-left line corner with the variables
if (is_multitable_seperated == false) or (d==0) then
localPrint(string.format("\\draw[inner sep=0pt, outer sep=0pt] (%f, %f) -- (%f, %f);", grid_x_loc+line_width, grid_y_loc-line_width, grid_x_loc-zero_var_line_lenght, grid_y_loc+zero_var_line_lenght))
localPrint(string.format("\\node[left] at (%f,%f) {\\small{%s}};", grid_x_loc-0.3, grid_y_loc+0.3, var2))
localPrint(string.format("\\node[right] at (%f,%f) {\\small{%s}};", grid_x_loc-0.6, grid_y_loc+0.6, var1))
end
-- Print out the top boolean column header
if (is_multitable_seperated == false) or (d < 2) then
localPrint(string.format("\\matrix[matrix of nodes, ampersand replacement=\\&, column sep={1cm,between origins}, nodes={align=center,text width=1cm,inner sep=0pt}, anchor=south west, inner sep=0pt, outer sep=0pt] at (%f, %f) {",grid_x_loc,grid_y_loc+0.05))
for c=0, column-1, 1 do
localPrint(string.format("%s", decimalToGreyBin(c, column_header_numb_bits)))
if c ~= (column-1) then localPrint("\\&") end
end
localPrint("\\\\};")
end
-- Print out the side boolean row header
if (is_multitable_seperated == false) or (d%2 == 0) then
localPrint(string.format("\\matrix[matrix of nodes, ampersand replacement=\\&, row sep={1cm,between origins}, nodes={minimum height=1cm,inner sep=0pt, text height=2ex, text depth=0.5ex}, anchor=north east, inner sep=0pt, outer sep=0pt] at (%f, %f) {",grid_x_loc-0.05,grid_y_loc))
for r=0, row-1, 1 do
localPrint(string.format("%s \\\\", decimalToGreyBin(r, row_header_numb_bits)))
end
localPrint("};")
end
-- Print out the matrix
localPrint(string.format("\\matrix[matrix of nodes, ampersand replacement=\\&, column sep={1cm,between origins}, row sep={1cm,between origins}, nodes={rectangle,draw,minimum height=1cm,align=center,text width=1cm,inner sep=0pt, text height=2ex, text depth=0.5ex, line width=0.015cm}, anchor=north west, inner sep=0pt, outer sep=0pt] at (%f, %f) {%s};",
grid_x_loc, grid_y_loc, generateKMap(row, column, d)
))
-- Print out the buttom text saying which matrix is which
if (submaps_n > 0) then
if (is_multitable_seperated == false) then
localPrint(string.format("\\node[below] at (%f, %f) {%s = %s};", grid_x_loc+(column//2),grid_y_loc-row,var3, decimalToBin(d, 2)))
elseif (is_multitable_seperated == true) then
if (d < 2) then
localPrint(string.format("\\node[] at (%f, %f) {%s = %s};", grid_x_loc+(column//2), grid_y_loc+1, var3, decimalToBin(d, 2)))
end
if (d % 2 == 0) and (submaps_n > 2) then
localPrint(string.format("\\node[rotate=90] at (%f, %f) {%s = %s};", grid_x_loc-1, grid_y_loc-(row//2), var3, decimalToBin(d, 2)))
end
end
end
end
end
-- Function for drawing an implicant manually (meaning to give the start and endpoint, as well as optional
-- submaps for different ones)
function manual_draw_implicant(st, en, submaps_str)
local color_index = cartonaugh_env_settings.color_index
local max_submaps = cartonaugh_env_settings.submaps
local inner_spread = cartonaugh_env_settings.implicant_settings.inner_sep
st = tonumber(st)
en = tonumber(en)
local submap_arr = split(submaps_str, ',')
-- Check if the implacent selection
for s=1,table.getn(submap_arr),1 do
current_submap = tonumber(submap_arr[s])
if current_submap < max_submaps then
local draw_str = string.format("($(%s.center)+(-%s,%s)$) rectangle ($(%s.center)+(%s,-%s)$)", decimalToGreyBin(current_submap, 2) .. decimalToBin(st,4), inner_spread, inner_spread, decimalToGreyBin(current_submap, 2) .. decimalToBin(en,4), inner_spread, inner_spread)
if cartonaugh_env_settings.bw == 0 then
localPrint(string.format("\\fill[rounded corners=3pt,fill=%s,fill opacity=0.25,] {%s};", getColor(color_index) , draw_str))
end
localPrint(string.format("\\draw[rounded corners=3pt,draw opacity=1.0,] {%s};", draw_str))
else
localPrint(string.format("\\PackageWarning{cartonaugh}{You can only draw on existing sub maps. Ignoring instruction to draw on non existing sub map number %d}", s))
end
end
cartonaugh_env_settings.color_index = cartonaugh_env_settings.color_index+1
end
-- Handler function for drawing edge implacants, figuring out orientation as well
function manual_draw_edge_implicant(corner1, corner2, corner3, corner4, submaps_str)
corner1 = tonumber(corner1)
corner2 = tonumber(corner2)
corner3 = tonumber(corner3)
corner4 = tonumber(corner4)
if corner1-corner2 > corner1-corner3 then
manual_draw_edge_implicant_orientation(corner1, corner2, submaps_str, 'n')
manual_draw_edge_implicant_orientation(corner3, corner4, submaps_str, 's')
else
manual_draw_edge_implicant_orientation(corner1, corner2, submaps_str, 'w')
manual_draw_edge_implicant_orientation(corner3, corner4, submaps_str, 'e')
end
cartonaugh_env_settings.color_index = cartonaugh_env_settings.color_index+1
end
-- Function to draw out a 1 edge implacant given 2 corners, the submaps, and the orientation (n, s, e, or w)
-- TODO: Perhaps find a way to repeat the code between n/s and e/w
-- TODO: For the mirror variable, have that apply to the lua var directly instead of having LaTeX handle it
-- TODO: Maybe add option for squigly lines for the end instead of nothing
-- TODO: Open up the internal inner_spread and outer_spead settings to the user
function manual_draw_edge_implicant_orientation(corner1, corner2, submaps_str, orientation)
local color_index = cartonaugh_env_settings.color_index
local max_submaps = cartonaugh_env_settings.submaps
corner1 = tonumber(corner1)
corner2 = tonumber(corner2)
local submap_arr = split(submaps_str, ',')
local inner_spread = cartonaugh_env_settings.implicant_settings.inner_sep
local outer_spead = cartonaugh_env_settings.implicant_settings.outer_sep
-- Check if the implacent selection
for s=1,table.getn(submap_arr),1 do
current_submap = tonumber(submap_arr[s])
if current_submap < max_submaps then
local draw_string = ""
local mirror = 1
local corner1_bin = decimalToGreyBin(current_submap, 2) .. decimalToBin(corner1,4)
local corner2_bin = decimalToGreyBin(current_submap, 2) .. decimalToBin(corner2,4)
if orientation == 'n' or orientation == 's' then
-- If the orientation is south, just mirror it
if orientation == 's' then mirror = -1 end
draw_string = string.format("($(%s.center)+(-%f,%f*%s)$)", corner1_bin, inner_spread, outer_spead, mirror)
draw_string = draw_string .. string.format("{[rounded corners=3pt] -- ($(%s.center)+(-%f,-%f*%s)$)}", corner1_bin, inner_spread, inner_spread, mirror)
draw_string = draw_string .. string.format("{[rounded corners=3pt] -- ($(%s.center)+(%f,-%f*%s)$)}", corner2_bin, inner_spread, inner_spread, mirror)
draw_string = draw_string .. string.format("-- ($(%s.center)+(%f,%f*%s)$)", corner2_bin, inner_spread, outer_spead, mirror)
else
if orientation == 'e' then mirror = -1 end
draw_string = string.format("($(%s.center)+(-%f*%s,%f)$)", corner1_bin, outer_spead, mirror, inner_spread)
draw_string = draw_string .. string.format("{[rounded corners=3pt] -- ($(%s.center)+(%f*%s,%f)$)}", corner1_bin, inner_spread, mirror, inner_spread)
draw_string = draw_string .. string.format("{[rounded corners=3pt] -- ($(%s.center)+(%f*%s,-%f)$)}", corner2_bin, inner_spread, mirror, inner_spread)
draw_string = draw_string .. string.format("-- ($(%s.center)+(-%f*%s,-%f)$)", corner2_bin, outer_spead, mirror, inner_spread)
end
if cartonaugh_env_settings.bw == 0 then
localPrint(string.format("\\fill[fill=%s,fill opacity=0.25,] {%s};", getColor(color_index), draw_string))
end
localPrint(string.format("\\draw[draw opacity=1.0] {%s};", draw_string))
else
localPrint(string.format("\\PackageWarning{cartonaugh}{You can only draw on existing sub maps. Ignoring instruction to draw on non existing sub map number %d}", s))
end
end
end
-- Function to draw the corner implicants. Only usable on 4x4 matrices
function manual_draw_corner_implicant(submaps_str)
local corner_arr = {0, 2, 8, 10}
local submap_arr = split(submaps_str, ',')
local max_submaps = cartonaugh_env_settings.submaps
local color = cartonaugh_env_settings.color_index
local inner_spread = cartonaugh_env_settings.implicant_settings.inner_sep
local outer_spread = cartonaugh_env_settings.implicant_settings.outer_sep
if cartonaugh_env_settings.cols ~= 4 or cartonaugh_env_settings.rows ~= 4 then
localPrint("\\PackageError{cartonaugh}{Cannot use a corner implicant on anything but a 4x4. Sorry!}")
return
end
for s=1,table.getn(submap_arr),1 do
current_submap = tonumber(submap_arr[s])
if current_submap < max_submaps then
for c=0,3,1 do
local x_mirror = 1-(2*(c%2))
local y_mirror = 1-(2*(c//2))
local corner = decimalToGreyBin(current_submap, 2) .. decimalToBin(corner_arr[c+1],4)
-- Create the string to draw the corners
local draw_string = string.format("($(%s.center)+(-%f*%d,%f*%d)$)--($(%s.center)+(%f*%d,%f*%d)$)", corner, outer_spread, x_mirror, outer_spread, y_mirror, corner, inner_spread, x_mirror, outer_spread, y_mirror)
draw_string = draw_string .. string.format("{ [rounded corners=3pt] --($(%s.center)+(%f*%d,-%f*%d)$) }", corner, inner_spread, x_mirror, inner_spread, y_mirror)
draw_string = draw_string .. string.format("--($(%s.center)+(-%f*%d,-%f*%d)$) -- cycle", corner, outer_spread, x_mirror, inner_spread, y_mirror)
if cartonaugh_env_settings.bw == 0 then
localPrint(string.format("\\fill[fill=%s,fill opacity=0.25,] {%s};", getColor(color), draw_string))
end
localPrint(string.format("\\draw[sharp corners, draw opacity=1.0] {%s};", draw_string))
end
else
localPrint(string.format("\\PackageWarning{cartonaugh}{You can only draw on existing sub maps. Ignoring instruction to draw on non existing sub map number %d}", s))
end
end
cartonaugh_env_settings.color_index = cartonaugh_env_settings.color_index+1
end
-- WORK IN PROGRESS/LONG TERM FUNCTION
-- Goals is to eventually give \implicant{1}{x}{0}{x} for example and have it draw it out for you.
-- May give up on this in favor of other things...don't know
function draw_implicant(var_list)
-- local var_list_arr = split(var_list, ',')
local color_index = cartonaugh_env_settings.color_index
local max_submaps = cartonaugh_env_settings.submaps
localPrint("\\PackageWarning{cartonaugh}{This is a UNSTABLE and WIP function. Procede on your own}")
-- Check argument for submaps greater than 1
-- TODO: before returning print out a package error
if max_submaps > 1 then
for s=0,max_submaps-1,1 do
if var_list[5+s] == '' then
-- TODO: Fix this
localPrint(string.format("\\PackageError{cartonaugh}{Please feed either 1, 0, or x for sub map number %d's variable boolean}", s+1))
return
end
end
end
local low_limit = 0
local high_limit = 0
for b=1,4,1 do
if var_list[b] == 'x' then
print('a',high_limit, greyBinToDecimal(high_limit), decimalToBin(greyBinToDecimal(high_limit), 4))
print('b',high_limit | (1 << (b-1)), greyBinToDecimal(high_limit | (1 << (b-1))), decimalToBin(greyBinToDecimal(high_limit | (1 << (b-1))), 4))
if greyBinToDecimal(high_limit) < greyBinToDecimal(high_limit | (1 << (b-1))) then
high_limit = high_limit | (1 << (b-1))
print(decimalToBin(greyBinToDecimal(high_limit),4), decimalToBin(greyBinToDecimal(high_limit & ~(1 << (b-2))),4))
if greyBinToDecimal(high_limit) < greyBinToDecimal(high_limit & ~(1 << (b-2))) then
high_limit = high_limit & ~(1 << (b-2))
end
end
elseif var_list[b] == '1' then
high_limit = high_limit | (1 << (b-1))
low_limit = low_limit | (1 << (b-1))
end
print('low_limit=', low_limit, 'high_limit=', high_limit)
end
local st = decimalToBin(low_limit,4)
local en = decimalToBin(high_limit,4)
print('low_limit', greyBinToDecimal(low_limit), 'high_limit', greyBinToDecimal(high_limit), 'st=', st, 'en=', en)
for s=1,1,1 do
current_submap = 0
if current_submap < max_submaps then
if cartonaugh_env_settings.bw == 0 then
localPrint(string.format("\\fill[rounded corners=3pt,fill=%s,fill opacity=0.25,] {($(%s.center)+(-0.3,0.3)$) rectangle ($(%s.center)+(0.3,-0.3)$)};", getColor(color_index) , decimalToGreyBin(current_submap, 2) .. st, decimalToGreyBin(current_submap, 2) .. en))
color_index = color_index+1
end
localPrint(string.format("\\draw[rounded corners=3pt,draw opacity=1.0,] {($(%s.center)+(-0.3,0.3)$)rectangle($(%s.center)+(0.3,-0.3)$)};", decimalToGreyBin(current_submap, 2) .. st, decimalToGreyBin(current_submap, 2) .. en))
else
localPrint(string.format("\\PackageWarning{cartonaugh}{You can only draw on existing sub maps. Ignoring instruction to draw on non existing sub map number %d}", s))
end
end
cartonaugh_env_settings.color_index = color_index
end
function autoterms(what_to_write)
local max_cells = cartonaugh_env_settings.submaps * cartonaugh_env_settings.cols * cartonaugh_env_settings.rows
for cell=0,max_cells-1,1 do
if used_cells[cell] == nil then
used_cells[cell] = true
localPrint(string.format("\\path (%s) node {%s};", decimalToBin(cell, 6), what_to_write))
end
end
end
function manualterms(what_to_write)
local what_to_write_arr = split(what_to_write, ',')
for cell=0,table.getn(what_to_write_arr)-1,1 do
if used_cells[cell] == nil then
used_cells[cell] = true
localPrint(string.format("\\path (%s) node {%s};", decimalToBin(cell, 6), what_to_write_arr[cell+1]))
end
end
end
function write_to_cell(cells, what_to_write)
local cells_arr = split(cells, ',')
for c=1,table.getn(cells_arr),1 do
local cell = tonumber(cells_arr[c])
if used_cells[cell] == nil then
used_cells[cell] = true
localPrint(string.format("\\path (%s) node {%s};", decimalToBin(cell, 6), what_to_write))
end
end
end
%\end{macrocode}
%</luacode>
%\fi
%
\endinput
