¿Cómo creo tipos enumerados en MATLAB?

enums matlab-class

Question

¿Hay tipos enumerados en MATLAB? si no, cuales son las alternativas?

Answer 1

A partir de R2010b, MATLAB admite enumeraciones.

Ejemplo de la documentation :

classdef Colors
   properties
      R = 0;
      G = 0;
      B = 0;
   end

   methods
      function c = Colors(r, g, b)
         c.R = r; c.G = g; c.B = b;
      end
   end

   enumeration
      Red   (1, 0, 0)
      Green (0, 1, 0)
      Blue  (0, 0, 1)
   end
end

Answer 2

Después de probar las otras sugerencias en esta página, llegué al enfoque totalmente orientado a objetos de Andrew. Muy bien, gracias Andrew.

En caso de que alguien esté interesado, sin embargo, hice (lo que creo que son) algunas mejoras. En particular, eliminé la necesidad de especificar dos veces el nombre del objeto enum. Los nombres ahora se derivan usando la reflexión y el sistema de metaclase. Además, las funciones eq () y ismember () se volvieron a escribir para devolver valores de retorno con la forma adecuada para matrices de objetos enum. Y finalmente, se modificó la función check_type_safety () para que sea compatible con los directorios de paquetes (por ejemplo, espacios de nombres).

Parece que funciona bien, pero déjame saber lo que piensas:

classdef (Sealed) Color
%COLOR Example of Java-style typesafe enum for Matlab

properties (Constant)
    RED = Color(1);
    GREEN = Color(2);
    BLUE = Color(3);
end
methods (Access = private) % private so that you can''''t instatiate directly
    function out = Color(InCode)
        out.Code = InCode;
    end       
end


% ============================================================================
% Everything from here down is completely boilerplate - no need to change anything.
% ============================================================================
properties (SetAccess=private) % All these properties are immutable.
    Code;
end
properties (Dependent, SetAccess=private)
    Name;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
methods
    function out = eq(a, b) %EQ Basic "type-safe" eq
        check_type_safety(a, b);
        out = reshape([a.Code],size(a)) == reshape([b.Code],size(b));
    end
    function [tf,loc] = ismember(a, b)
        check_type_safety(a, b);
        [tf,loc] = ismember(reshape([a.Code],size(a)), [b.Code]);
    end
    function check_type_safety(varargin) %CHECK_TYPE_SAFETY Check that all inputs are of this enum type
        theClass = class(varargin{1});
        for ii = 2:nargin
            if ~isa(varargin{ii}, theClass)
                error(''Non-typesafe comparison of %s vs. %s'', theClass, class(varargin{ii}));
            end
        end
    end

    % Display stuff:
    function display(obj)
        disp([inputname(1) '' ='']);
        disp(obj);
    end
    function disp(obj)
        if isscalar(obj)
            fprintf(''%s: %s (%d)/n'', class(obj), obj.Name, obj.Code);
        else
            fprintf(''%s array: size %s/n'', class(obj), mat2str(size(obj)));
        end
    end    
    function name=get.Name(obj)
        mc=metaclass(obj);
        mp=mc.Properties;
        for ii=1:length(mp)
            if (mp{ii}.Constant && isequal(obj.(mp{ii}.Name).Code,obj.Code))
                name = mp{ii}.Name;
                return;
            end;
        end;
        error(''Unable to find a %s value of %d'',class(obj),obj.Code);
    end;
end
end

Gracias, Mason

Answer 3

En realidad, hay una palabra clave en MATLAB R2009b llamada ''enumeración'' . Parece que no está documentado, y no puedo decir que sé cómo usarlo, pero la funcionalidad probablemente esté allí.

Puede encontrarlo en matlabroot/toolbox/distcomp/examples/+examples

classdef(Enumeration) DmatFileMode < int32

    enumeration
        ReadMode(0)
        ReadCompatibilityMode(1)
        WriteMode(2)
    end
<snip>
end

Answer 4

Podrías crear una clase de Matlab que se comporte como un antiguo modelo de enumeración seguro de Java . Una modificación de la solución de Marc podría llevarlo desde los typedefs tipo C a más como enum de tipo tipo Java. En esta versión, los valores en las constantes son objetos de Color tipeados.

Las ventajas:

• El tipo puede ser verificado (en tiempo de ejecución) por == y otras operaciones para evitar la comparación accidental con los valores numéricos en bruto u otros tipos de enumeraciones.
• Puede verificar explícitamente el tipo de sus variables (en tiempo de ejecución).
• Los valores se muestran con nombres legibles en lugar de los códigos opacos.
• Las operaciones como mean () y std () que no tienen sentido en las enumeraciones no están permitidas.

Desventajas:

• Definición de clase más larga. Pero, esto es todo repetitivo, y puede reutilizarse para cualquier otra clase enum, cambiando solo el nombre de la clase y las propiedades de Constante.
• Estas enumeraciones no se pueden usar directamente en bloques de interruptores. Necesitas sacar el código, lo que pierde algún tipo de seguridad.
• Los objetos serán más lentos que los primitivos. Pertinente si está usando constantes dentro de los bucles.

En general, no sé qué enfoque es mejor. No lo he usado en la práctica.

classdef (Sealed) Color
%COLOR Example of Java-style typesafe enum for Matlab

properties (Constant)
    RED = Color(1, ''RED'');
    GREEN = Color(2, ''GREEN'');
    BLUE = Color(3, ''BLUE'');
end
properties (SetAccess=private)
    % All these properties are immutable.
    Code;
    Name;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
methods (Access = private)
%private so that you can''t instatiate directly
    function out = Color(InCode, InName)
        out.Code = InCode;
        out.Name = InName;
    end       
end
methods (Static = true)
    function needa(obj)
    %NEEDA Asserts that obj must be a Color
        if ~isa(obj, mfilename)
            error(''Input must be a %s; got a %s'', mfilename, class(obj));
        end
    end
end
methods (Access = public)
    function display(obj)
      disp([inputname(1) '' ='']);
      disp(obj);
    end
    function disp(obj)
        if isscalar(obj)
            disp(sprintf(''%s: %s (%d)'', class(obj), obj.Name, obj.Code));
        else
            disp(sprintf(''%s array: size %s'', class(obj), mat2str(size(obj))));
        end
    end    
    function out = eq(a, b)
        %EQ Basic "type-safe" eq
        check_type_safety(a, b);
        out = [a.Code] == [b.Code];
    end
    function [tf,loc] = ismember(a, b)
        check_type_safety(a, b);
        [tf,loc] = ismember([a.Code], [b.Code]);
    end
    function check_type_safety(varargin)
        %CHECK_TYPE_SAFETY Check that all inputs are of this enum type
        for i = 1:nargin
            if ~isa(varargin{i}, mfilename)
                error(''Non-typesafe comparison of %s vs. %s'', mfilename, class(varargin{i}));
            end
        end
    end
end
end

Aquí hay una función para ejercitarlo.

function do_stuff_with_color(c)
%DO_STUFF_WITH_COLOR Demo use of the Color typesafe enum

Color.needa(c); % Make sure input was a color
if (c == Color.BLUE)
    disp(''color was blue'');
else
    disp(''color was not blue'');
end

% To work with switch statements, you have to explicitly pop the code out 
switch c.Code
    case Color.BLUE.Code
        disp(''blue'');
    otherwise
        disp(sprintf(''some other color: %s'', c.Name));
end

Ejemplo de uso:

>> Color.RED == Color.RED
ans =
     1
>> Color.RED == 1
??? Error using ==> Color>Color.check_type_safety at 55
Non-typesafe comparison of Color vs. double

Error in ==> Color>Color.eq at 44
        check_type_safety(a, b);

>> do_stuff_with_color(Color.BLUE)
color was blue
blue
>> do_stuff_with_color(Color.GREEN)
color was not blue
some other color: GREEN
>> do_stuff_with_color(1+1) % oops - passing the wrong type, should error
??? Error using ==> Color>Color.needa at 26
Input must be a Color; got a double

Error in ==> do_stuff_with_color at 4
Color.needa(c); % Make sure input was a color

>> 

Una peculiaridad menor en ambos enfoques: la convención C de poner la constante en la mano izquierda del "==" para evitar una mala asignación no ayuda mucho aquí. En Matlab, si accidentalmente usas "=" con esta constante en el LHS, en lugar de un error, creará una nueva variable de estructura local llamada Colors, y enmascarará la clase enum.

>> Colors.BLUE = 42
Colors = 
    BLUE: 42
>> Color.BLUE = 42
Color = 
    BLUE: 42
>> Color.RED
??? Reference to non-existent field ''RED''.

Answer 5

Puede obtener algunas de las funcionalidades con las nuevas clases de MATLAB:

classdef (Sealed) Colors
    properties (Constant)
        RED = 1;
        GREEN = 2;
        BLUE = 3;
    end

    methods (Access = private)    % private so that you cant instantiate
        function out = Colors
        end
    end
end

Esto no es realmente un tipo, pero como MATLAB está tipeado libremente, si usas números enteros, puedes hacer cosas que se aproximen a él:

line1 = Colors.RED;
...
if Colors.BLUE == line1
end

En este caso, las "enumeraciones" de MATLAB están cerca de enums de estilo C: sintaxis sustituta para enteros.

Con el uso cuidadoso de métodos estáticos, incluso puede hacer que las enumeraciones de MATLAB se acerquen a la sofisticación de Ada, pero desafortunadamente con una sintaxis más torpe.

Answer 6

Si desea hacer algo similar a lo sugerido por Marc , simplemente podría hacer una structure para representar sus tipos enumerados en lugar de una clase completamente nueva:

colors = struct(''RED'',1,''GREEN'',2,''BLUE'',3);

Un beneficio es que puede acceder fácilmente a las estructuras de dos maneras diferentes. Puede especificar un campo directamente usando el nombre del campo:

a = colors.RED;

o puede usar nombres de campo dinámicos si tiene el nombre del campo en una cadena:

a = colors.(''RED'');

En verdad, hay algunos beneficios de hacer lo que Marc sugirió y crear una clase completamente nueva para representar un objeto "enum":

• Puedes controlar cómo se modifica el objeto.
• Puede mantener la definición en un solo lugar y usarla fácilmente en múltiples lugares.
• Puede controlar las fallas y hacerlas más "elegantes", como devolver una matriz vacía si intenta acceder a un campo inexistente (en lugar de arrojar un error).

Sin embargo, si no necesita ese tipo de complejidad y solo necesita hacer algo rápido, una estructura es probablemente la implementación más sencilla y directa. También funcionará con versiones anteriores de MATLAB que no usan el marco de OOP más nuevo.

Answer 7

Si necesita los tipos enumerados solo para pasar al ensamblado C # o .NET, puede construir y pasar las enumeraciones con MATLAB 2010:

A = NET.addAssembly(MyName.dll)
% suppose you have enum called "MyAlerts" in your assembly
myvar = MyName.MyAlerts.(''value_1'');

también puede verificar la respuesta oficial de MathWorks en

¿Cómo uso los valores enumerados de .NET en MATLAB 7.8 (R2009a)?

// the enum "MyAlerts" in c# will look something like this
public enum MyAlerts
{
    value_1 = 0,
    value_2 = 1,
    MyAlerts_Count = 2,
}

Answer 8

Si tiene acceso a Statistics Toolbox, puede considerar el uso de un objeto categórico .

Answer 9

También puede usar las clases enum de Java desde su código Matlab. Defínelos en Java y colóquelos en el javaclasspath de Matlab.

// Java class definition
package test;
public enum ColorEnum {
    RED, GREEN, BLUE
}

Puede hacer referencia a ellos por su nombre en M-code.

mycolor = test.ColorEnum.RED
if mycolor == test.ColorEnum.RED
    disp(''got red'');
else
    disp(''got other color'');
end

% Use ordinal() to get a primitive you can use in a switch statement
switch mycolor.ordinal
    case test.ColorEnum.BLUE.ordinal
        disp(''blue'');
    otherwise
        disp(sprintf(''other color: %s'', char(mycolor.toString())))
end

Sin embargo, no tomará comparaciones con otros tipos. Y la comparación con la cadena tiene un tamaño de retorno impar.

>> test.ColorEnum.RED == ''GREEN''
ans =
     0
>> test.ColorEnum.RED == ''RED''
ans =
     1     1     1

Answer 10

Toys = {''Buzz'', ''Woody'', ''Rex'', ''Hamm''};

Toys{3}
  ans = ''Rex''