Mtodo de minimizacion Quine-McCluskey ElAlgoritmo QuineMcCluskeyes un mtodo de simplificacin defunciones booleanasdesarrollado porWillard Van Orman QuineyEdward J. McCluskey. Es funcionalmente idntico a la utilizacin delmapa de Karnaugh, pero su forma tabular lo hace ms eficiente para su implementacin en lenguajes computacionales, y provee un mtodo determinista de conseguir la mnima expresin de una funcin booleana.

El punto de partida para el algoritmo de minimizacin tratado, es la tabla de la verdad, o de manera equivalente la lista de mini trminos de una funcin. Se sabe que un mini trmino de una funcin lgica de n variables se representa por un entero de n bits, en cuyo caso particular podra indicar si una variable se encontraba negada o no con 0 y 1 respectivamente. Sin embargo, para un mtodo de minimizacin es tambin necesarito tomar en cuenta las variables que no aparecen en determinado mini trmino, representndola con una X.Generacin de los implicantes primos Se mencion anteriormente que el mtodo parte de la tabla de la verdad al igual que Mapas K, pero el primer paso real en el algoritmo es determinar todos los implicantes primos de la funcin lgica. Para la determinacin de dichos implicantes ser necesaria la agrupacin de mini trminos con mismas cantidades de unos en ellos, y posteriormente la realizacin de ciertas combinaciones entre ellos, y nuevamente colocarlos en una tabla en la que en cierto momento se notar que ciertos de los trminos obtenidos no se podrn combinar nuevamente, siendo estos los implicantes primos; luego se excluyen estos de la tabla y se sigue combinando el resto hasta que solo queden implicantes primos.Generacin de cobertura mnima Esto se logra mediante ciertas tablas en las que se usan como cierto tipo de palomitas. Estos son arreglos bidimensionales que se les conoce como tablas de implicantes primos, de los cuales se seleccionan los suficientes como para cubrir todos los unos de la funcin lgica dada..

En el arreglo hay una columna por cada mini termin de la funcin y un rengln (fila) por cada implicante primo. Cada entrada es un bit que es 1, si y solo si, el implicante primo para ese rengln cubre el mini trmino correspondiente a la columna, lo cual en otras palabras se refiere a una celda 1 distinguida, columna con un solo uno o paloma en este caso, concepto que ira referido a la dominancia de columnas. El regln que contenga este uno perteneciente a una celda 1 distinguida, referir al concepto de dominancia de filas.

As, estos implicantes determinarn la forma de la expresin mnima de esta funcin como suma de mini trminos.

Se proceder con un ejemplo: Sea la funcin:

F(A, B, C, D) = Sm (1, 3, 4, 5, 7, 9, 10, 11, 15) (Sm: Sumatoria).

La TABLA 1 presenta la lista de los mini trminos, expresados en forma binaria eindica el nmero de UNOS que estos contienen:

En la TABLA 2, se agrupan los mini trminos con el mismo nmero de UNOS

De la TABLA 2, se combinan los trminos que tienen un solo UNO con los que tienen dos UNOS, los que tienen dos UNOS con los que tienen tres UNOS y as sucesivamente.Dos trminos se podrn combinar siempre y cuando exista un solo cambio entre ellos; es decir, cuando el lugar en que estn colocados los UNOS coincidan.

Por ejemplo, los trminos 1 y 3 se combinan debido a lo siguiente:

Lo que quiere decir que entre los trminos 1 y 3 se elimin la variable C. Haciendo lo mismo con los dems trminos, se obtiene la TABLA 3.

Los trminos que en su fila tienen palomitas, son los que se combinaron. Los trminos con *, son los que no pudieron combinarse; es decir, aquellos que en su fila no tienen palomitas. A estos trminos se les denomina IMPLICANTES PRIMOS.

Para la TABLA 4, se combinan los niveles de agrupacin 1-2 con 2-3 y 2-3 con 3-4, tomando en cuenta que coincidan tanto las x como los UNOS.

Como ya se indic, los implicantes primos son trminos que no se combinan con ningn otro, por tanto pueden formar parte de la funcin reducida. Para determinar cules de los implicantes primos forman parte de la funcin reducida, se hace la siguiente tabla, llamada de implicantes primos.

Obsrvese que en la tabla anterior, se encerraron entre parntesis las palomitas que se encontraron solas en una columna y su fila se proyect en la parte inferior de la tabla. Si en los cuatro penltimos renglones se llenan todas las columnas (ltima fila), entonces se ha llegado a la solucin mnima.

Ntese que c no tuvo ninguna palomita sola dentro de sus columnas, lo que significa que este implicante primo est contenido en los dems; es decir, no forma parte de la funcin reducida.Por tanto, la funcin reducida es:F(A, B, C, D) = a + b + d + e

Dnde:

Finalmente, la funcin reducida es: F(A,B,C,D) = CD+ BD + ABC + ABC

Para concluir, en general se puede decir en funcin de lo observado que este mtodo de minimizacin tiende a ser de mayor complejidad que el de Mapas K, ms sin embargo, posee una inmensa ventaja al momento de poder implementarse en la programacin con la finalidad de la realizacin de un programa capaz de la minimizacin de funciones lgicas, pues es ms sencillo de tratar en ese aspecto.

Un programa que se utiliza para aplicar este mtodo, es el MinBool.m, creado por Andrey Popov. Este programa funciona de tal manera que al introducirle una funcin lgica de la misma forma que fue especificada inicialmente como en el ejemplo anterior, (con ciertas modificaciones), este arroja el resultado de la minimizacin en forma de matriz, donde -1 indicaria una variable negada, 1 una normal, y NaN o 0 va referido a las variables que no se usan al momento. Podemos usar como ejemplo la misma funcin explicada en el ejemplo anterior:

F(A, B, C, D) = Sm (1, 3, 4, 5, 7, 9, 10, 11, 15) (Sm: Sumatoria).

R = minBool([1, 3, 4, 5, 7, 9, 10, 11, 15]) (se inserta de esta manera en Matlab teniendo el programa abierto)

R =

1 2 3 4 0 -1 0 1 -1 1 -1 0 0 0 1 1 1 -1 1 0 (y esta matriz es el resultado que arroja, siendo en este caso particular, 1, 2 ,3 y 4 correspondientes a las variables A, B, C y D).

F(A,B,C,D) = CD+ BD + ABC + ABC

Ese sera bsicamente el funcionamiento genrico.

Otro ejemplo podra ser:

En cuyo caso se tendra: R = minBool([4, 8, 10, 11, 12, 15],[9, 14])

R =

1 2 3 4NaN 1 -1 -11 -1 NaN -11 NaN 1 1

Siendo el resultado interpretado el siguiente: F(A,B,C,D) = BCD + ABD + ACD

El cdigo del programa incluyendo comentarios del creador es el siguiente:

function result = minBool(numbers, resulttype)% MINBOOL Quine-McCluskey method for boolean function minimization%% R = minBool( N, V )%% R - result matrix% N - input arguments. N should be vector with integers% V - visualization type% 1) 1=normal; -1=inverse; NaN = not used% 2) 1=normal; -1=inverse; 0 = not used%% Example% R = minBool([5 13 14 26 30],1)% R =% 1 2 3 4 5% -1 NaN 1 -1 1% NaN 1 1 1 -1% 1 1 NaN 1 -1%% This function is distributed under GPL license (see code for details).% Original authors information: Andrey Popov www.automatics.hit.bg%% minBool ver. 1.3, release Sept 2002, Last update: 14 Feb 2010 % Copyright 2002-2010 Andrey Popov andrey.popov@gmx.net%% This program is free software: you can redistribute it and/or modify% it under the terms of the GNU General Public License as published by% the Free Software Foundation, either version 3 of the License, or% (at your option) any later version.%% This program is distributed in the hope that it will be useful,% but WITHOUT ANY WARRANTY; without even the implied warranty of% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the% GNU General Public License for more details.%% You should have received a copy of the GNU General Public License% along with this program. If not, see . %% Input arguments checkif (nargin==0) error('minBool:noinput','No input data');end % The input argument is integer numbers, so the minimization is% independant on the size of the boolean variables, i.e. we are not% interested whether the real boolean variables are represented with 3 or% 30 bits numbers = round(abs(numbers));v = size(numbers,2);numbers = numbers(:); %% Remove repeated input numbers ------------------------------------------S = numbers(1);for g = 2:v if ~any(S == numbers(g)) S = [S numbers(g)]; endend numbers = sort(S);v = length(numbers); % Determine the number of involved boolean variablesn = max(1,ceil(log2(max(numbers)+1))); % Create empty disjunction matrix sW = zeros(v,n); %% Convert the input numbers to binary ------------------------------------for i = 1:v % cycle over the numbers k = numbers(i); for j = 1:n % cycle over the bits p = 2^(n-j); if k >= p k = k - p; W(i,j) = 1; end endend %% Arange the numbers according to the number of '1' they have ------------w1 = [1:v; sum(W,2)']; % [no; num 1's]w1 = sortrows(w1',2); % sort by num 1'sw = w1(:,1);G = [W(w,:) numbers(w)'];% arrange by num 1's %% Joining the numbers close in a boolean sence ---------------------------extend=1; %stitched=1; % to be able to enter 'while' if v == 1 F = G;else while (stitched~=0) F = []; stitched = 0; G = [G zeros(v,1)]; ncomb = 0; for i=1:v % loop over all combinations if ~isinf(G(i,1)) % Inf on first position can appear only if we have 2 % combinations which are identical. Since this is covered % for the initial input variables, such case can only % occure after combining several variables and having % invariant bits. joined=0; for j=(i+1):v % compare with all other combinations if ~isinf(G(j,1)) % allowed k = sum(abs(G(i,1:n)-G(j,1:n))); if k == 1 % difference by exactely 1 bit L = G(i,1:(n+extend)); % copy the combination p = find(G(i,1:n)-G(j,1:n)); % find the differing bit L(1,p) = -1; % mark it with -1 L = [L G(j,(n+1):(n+extend))]; % add the other combination F = [F; L]; % store in the pass matrix F ncomb = ncomb + 1; stitched = stitched + 1;% mark that there was stitch joined = joined + 1; % G(i,n+extend+1) = 1; % mark the combinations as used G(j,n+extend+1) = 1; elseif k == 0 % could be only by 2 identical combinations % at later stage of stitching G(j,1)=inf; end end end if joined == 0 && G(i,n+extend+1) == 0 % the current combination cannot be joined with any % other L = G(i,1:(n+extend)); L = [L Inf*ones(1,extend)]; F = [F; L]; ncomb = ncomb + 1; % however this is a combination end end end % end of the cycle over the combinations if stitched == 0 % not a single combination pare found F = F(:,1:(n+extend)); % this removes the extra combination columns else extend = 2*extend; % the number of spaces to mark combinations is doubled end G = F; % not the combinations are written again in G v = ncomb; endend % end of the while cycle %% Create the table -------------------------------------------------------% extend - max number of the involved input variables in the output% n - number of boolean variables% v - number of derived combinations% y - number input combinationsy = length(numbers); E = zeros(v+2,y+3); % create empty table of the form% 0 0 0 i i i i i i i i input combinations% 0 0 0 t t t t t t t t is this variable included% x n u ; ; ; ; ; ; ; x output combination% x n u ; ; ; ; ; ; ; n number of the included base variables% x n u ; ; ; ; ; ; ; u is this output combination used% x n u ; ; ; ; ; ; ; ; - 1/0 depending on whether the output combination uses the corresponding input combination E(1,3+(1:y)) = numbers;E(2+(1:v),1) = [1:v]'; % Fill with 1/0 depending on the variables involvedfor g = 1:v for j = n+(1:extend) if ~isnan(F(g,j)) for i = 1:y if E(1,i+3) == F(g,j) E(g+2,i+3) = 1; end end end endend %% Mark the base input variables (those involved in only 1 output)---------marked=0;for j = 3+(1:y) if E(2,j) ~= 1 % the input variable is not yet involved in an output one if sum(E(2+(1:v),j)==1) == 1 % this is a base variable E(2,j) = 1; marked = marked + 1; p = find(E(2+(1:v),j)==1); E(2+p,3) = 1; % mark the output variable as used for h = 1:y if E(2+p,h+3) == 1 % this output var. includes also other input if E(2,h+3) == 0 % not yet marked input E(2,h+3) = 1; marked = marked + 1; end end end end endend %% Mark the non-base variables --------------------------------------------while marked < y E(2+(1:v),2) = zeros(v,1); for g=1:v if E(g+2,3)==0 p=0; % num included, but non-marked non-base variables for j=3+(1:y) if E(g+2,j)==1 && E(2,j)==0 % output combination, containing the % non-marked, non-base boolean combination p=p+1; end end % Calculate extra weighing coef. based on the % number of boolean combination describing the particular % combination (q) and number of inverted (negated) boolean % variables (c) q = sum(F(g,1:n)