comando - ¿Es posible definir más de una función por archivo en MATLAB y acceder a ellas desde fuera de ese archivo?

como cargar un.mat en matlab

Question

Cuando estudiaba mi licenciatura en EE, MATLAB requería que cada función se definiera en su propio archivo, incluso si se trataba de una sola línea.

Estoy estudiando para obtener un título de posgrado ahora, y tengo que escribir un proyecto en MATLAB. ¿Sigue siendo esto un requisito para las nuevas versiones de MATLAB?

Si es posible poner más de una función en un archivo, ¿existen restricciones para esto? Por ejemplo, ¿se puede acceder a todas las funciones del archivo desde fuera del archivo, o solo a la función que tiene el mismo nombre que el archivo?

Nota: Estoy usando MATLAB versión R2007b.

Answer 1

A partir de R2017b, esto no es oficialmente posible. La documentación relevante establece que:

Los archivos de programa pueden contener múltiples funciones. Si el archivo contiene solo definiciones de funciones, la primera función es la función principal y es la función que MATLAB asocia con el nombre del archivo. Las funciones que siguen a la función principal o al código de script se denominan funciones locales. Las funciones locales solo están disponibles dentro del archivo.

Sin embargo, las soluciones alternativas sugeridas en otras respuestas pueden lograr algo similar.

Answer 2

Defino varias funciones en un archivo .m con Octave y luego uso el comando desde dentro del archivo .m donde necesito hacer uso de las funciones de ese archivo:

source("mycode.m");

No estoy seguro si esto está disponible con Matlab.

octave:8> help source
''source'' is a built-in function
-- Built-in Function: source (FILE)
Parse and execute the contents of FILE. This is equivalent to
executing commands from a script file, but without requiring the
file to be named `FILE.m''.

Answer 3

En general, la respuesta a su pregunta es no, no puede definir más de una función visible externamente por archivo. Sin embargo, puede devolver los manejadores de función a las funciones locales, y una forma conveniente de hacerlo es hacer que sean campos de una estructura. Aquí hay un ejemplo:

function funs = makefuns
funs.fun1=@fun1;
funs.fun2=@fun2;
end
function y=fun1(x)
y=x;
end
function z=fun2
z=1;
end

Y aquí es cómo podría ser utilizado:

>> myfuns = makefuns;
>> myfuns.fun1(5)
ans =
5
>> myfuns.fun2()
ans =
1

Answer 4

En la misma línea que la respuesta de SCFrench, pero con un giro más estilo C #.

Haría (y con frecuencia hago) una clase que contiene múltiples métodos estáticos. Por ejemplo:

classdef Statistics
methods(Static)
function val = MyMean(data)
val = mean(data);
end
function val = MyStd(data)
val = std(data);
end
end
end

Como los métodos son estáticos, no es necesario instansiar la clase. Llamas a las funciones de la siguiente manera:

data = 1:10;
mean = Statistics.MyMean(data);
std = Statistics.MyStd(data);

Answer 5

La única forma de tener múltiples funciones, accesibles por separado en un solo archivo, es definir MÉTODOS ESTÁTICOS usando programación orientada a objetos . myClass.static1() la función como myClass.static1() , myClass.static2() etc.

La funcionalidad de OOP solo se admite oficialmente desde R2008a, por lo que, a menos que desee utilizar la sintaxis de OOP antigua e indocumentada, la respuesta para usted es no, como lo explica @gnovice .

EDITAR

Una forma más de definir múltiples funciones dentro de un archivo que son accesibles desde el exterior es crear una función que devuelva múltiples manejadores de funciones . En otras palabras, llamaría a su función de definición como [fun1,fun2,fun3]=defineMyFunctions , después de lo cual podría usar out1=fun1(inputs) etc.

Answer 6

La primera función en un archivo-m (es decir, la función principal ), se invoca cuando se llama a ese archivo-m. No se requiere que la función principal tenga el mismo nombre que el archivo-m, pero para mayor claridad, debería . Cuando la función y el nombre del archivo difieren, el nombre del archivo debe usarse para llamar a la función principal.

Todas las funciones subsiguientes en el archivo-m, llamadas funciones locales (o "subfunciones" en la terminología anterior), solo pueden ser llamadas por la función principal y otras funciones locales en ese archivo-m. Las funciones en otros archivos m no pueden llamarlos. A partir de R2016b, también puede agregar funciones locales a los scripts , aunque el comportamiento de alcance sigue siendo el mismo (es decir, solo se pueden llamar desde el script).

Además, también puede declarar funciones dentro de otras funciones. Estas se denominan funciones anidadas y solo se pueden llamar desde dentro de la función en la que están anidadas. También pueden tener acceso a las variables en las funciones en las que están anidadas, lo que las hace bastante útiles, aunque un poco difíciles de trabajar.

Más alimento para el pensamiento ...

Hay algunas formas de evitar el funcionamiento normal del alcance de la función descrito anteriormente, como pasar los manejadores de función como argumentos de salida como se menciona en las respuestas de SCFrench y Jonas (que, a partir de R2013b, se facilita mediante la función de funciones localfunctions ). Sin embargo, no sugeriría convertirlo en un hábito de recurrir a tales trucos, ya que es probable que existan opciones mucho mejores para organizar sus funciones y archivos.

Por ejemplo, supongamos que tiene una función principal A en un archivo M, junto con las funciones locales D , E y F Ahora digamos que tiene otras dos funciones relacionadas B y C en los archivos m Bm y Cm , respectivamente, que también desea poder llamar D , E y F Aquí hay algunas opciones que tiene:

• Coloque D , E y F cada uno en sus propios archivos m separados, lo que permite que cualquier otra función los llame. El inconveniente es que el alcance de estas funciones es grande y no está restringido a solo A , B y C , pero la ventaja es que esto es bastante simple.

• Cree un defineMyFunctions m defineMyFunctions (como en el ejemplo de Jonas) con D , E y F como funciones locales y una función principal que simplemente les devuelve los controladores de función. Esto le permite mantener D , E y F en el mismo archivo, pero no hace nada con respecto al alcance de estas funciones, ya que cualquier función que pueda llamar a defineMyFunctions puede invocarlas. También debe preocuparse por pasar los manejadores de funciones como argumentos para asegurarse de tenerlos donde los necesita.

• Copie D , E y F en Bm y Cm como funciones locales. Esto limita el alcance de su uso a solo A , B y C , pero convierte la actualización y el mantenimiento de su código en una pesadilla porque tiene tres copias del mismo código en diferentes lugares.

• ¡Usa funciones privadas ! Si tiene A , B y C en el mismo directorio, puede crear un subdirectorio llamado private y colocar D , E y F allí, cada uno como un archivo m separado. Esto limita su alcance para que solo puedan ser llamadas por las funciones en el directorio inmediatamente anterior (es decir, A , B y C ) y las mantiene juntas en el mismo lugar (pero aún así diferentes archivos m):

  myDirectory/
  A.m
  B.m
  C.m
  private/
  D.m
  E.m
  F.m

Todo esto va más allá del alcance de su pregunta, y probablemente tenga más detalles de los que necesita, pero pensé que sería bueno abordar la preocupación más general de organizar todos sus archivos m. ;)

Answer 7

Realmente me gusta la respuesta de SCFrench: me gustaría señalar que se puede modificar fácilmente para importar las funciones directamente al área de trabajo usando la función asignar. (Hacerlo así me recuerda mucho a la manera de hacer las cosas "importar x de y" de Python)

function message = makefuns
assignin(''base'',''fun1'',@fun1);
assignin(''base'',''fun2'',@fun2);
message=''Done importing functions to workspace'';
end
function y=fun1(x)
y=x;
end
function z=fun2
z=1;
end

Y luego se utiliza así:

>> makefuns
ans =
Done importing functions to workspace
>> fun1(123)
ans =
123
>> fun2()
ans =
1

Answer 8

También puede agrupar funciones en un archivo principal junto con la función principal que se ve así:

function [varargout] = main( subfun, varargin )
[varargout{1:nargout}] = feval( subfun, varargin{:} );
% paste your subfunctions below ....
function str=subfun1
str=''hello''

Entonces, llamar a subfun1 se vería así: str = main (''subfun1'')