Archivo de la etiqueta: matlab

Lo que he aprendido: formato y exportación de figuras de Matlab

Matlab me está tocando la moral. Qué sorpresa. Me tiene tan sumamente cansada tener que programar en semejante entorno hostil (pun intended) que he decidido adoptar prácticas defensivas. Una de ellas es guardar las imágenes en el formato fig de Matlab y darles el formato que me parezca más tarde con una función. Aprovecho, además, para exportarlas a svg porque mi Matlab está borracho y no me exporta las fuentes correctamente cuando uso eps. Esto implica, claro, que necesito un paso posterior de pasar de svg a eps porque a las revistas no les gusta el svg. Ya veis, hacemos nosotras el currelo pero ellos se ponen exquisitos con los formatos. pero no importa porque viene el software libre al rescata, en este caso Inkscape.

En fin, que os dejo aquí la función que uso para cambiar el estilo de los gráficos y exportarlos y un script de muestra. No funciona bien si la figura tiene subfiguras, pero iremos mejorando.

Cambiar el estilo de una figura en Matlab

Para ello he escrito esta función, que se puede mejorar pero más o menos funciona:

function layout(h, fontSize, font, markerSize, lineWidth, gridOn, sizes)
% Change layout of graphic
%
% LAYOUT(h, fontSize, font, markerSize, lineWidth, gridOn, sizes)
% 
% where:
% - h: figure handle
% - fontSize: fontsize in points
% - font: name of font
% - markerSize: size of markers
% - lineWidth: line width 
% - gridOn: true set the grid to on
% - sizes: [width, height] of output

box on
set(gca,'FontSize', fontSize)
set(gca,'FontName', font)

% Change sizes of all elements
alldatacursors = findall(gcf,'type','hggroup');
set(alldatacursors,'FontSize', fontSize)
set(findall(gcf,'type','text'),'FontSize', fontSize)

% Change line width of all lines and markers
allLines = findall(gcf,'type','line');
set(allLines,'LineWidth', lineWidth)

% Set size of marker
if isprop(gca,'MarkerSize')
    set(h,'MarkerSize', markerSize)
end

% Grid
if gridOn
    grid on
end

x0 = 10;
y0 = 10;
set(gcf,'position',[x0,y0,sizes(1),sizes(2)])

Cambiar el estilo de todas las figuras de una carpeta

Uso la función layout en el archivo figStyle para dar formato y exportar a svg todas los gráficos de una carpeta. Supongo la siguiente estructura de archivos:

.
├── fig
│   ├── fig1.fig
│   └── fig2.fig
├── figStyle.m
├── layout.m
└── svg
    ├── fig1.svg
    └── fig2.svg

Es decir, cogeré las figuras de la carpeta fig y las guardaré en la carpeta svg después de transformadas. He escrito este script para la figuras del paper en el que estoy trabajando:

clear
clc

folder = 'fig';
addpath(genpath(pwd)) % Add subfolder to path
files = ls(folder);
files = files(3:end, 1:end); % delete first two entries (. and ..)
files = cellstr(files); % convert to cell to ease manipulation

number = size(files,1);

% Output names = names without extension
outName = cellfun(@(x) x(1:(end-4)), files, 'UniformOutput', false); 

for f = 1:number

    h = openfig(files{f},'new','invisible'); % open fig without showing
    layout(h, 24, 'Century Schoolbook', 14, 1.5, true, [800,600])

    % Save modified figure
    name = [folder '\..\svg\' outName{f}]; % saves figures in eps folder
    saveas(h,name,'svg')

    close(h);
end

Pasar de svg a eps

Una vez obtenidas las figuras en svg, uso un bucle en la terminal (de Windows) para pasarlas a eps con Inkscape. Aquí tuve líos petardos porque si pongo la carpeta de Inkscape en el Path, tengo un Python extra. Finalmente decidí que lo más práctico era llamar a Inkscape con la ruta completa. Por lo tanto, tiro esta línea en la carpeta donde están los svgs:

for %i in (*.svg) do "C:\Program Files\Inkscape\inkscape" -E %~ni.eps  %i

Aprendí gracias a esta historia que %~n es el nombre del archivo sin extensión. Ya os podéis imaginar la necesidad que tengo yo de saber mierdas cosas de la terminal de Windows. Ah, lo he guardado como svg2eps.cmd para futuro uso.

Y hala, cada día me vuelvo más robótica.


Suena:

Lo que he aprendido: tests en Matlab

He contado más veces que programo a diario sin saber programar. Esto me lleva a situaciones absurdas y unas pérdidas de tiempo sin igual a las que me gustaría poner remedio. Por ese motivo, estoy intentando aprender tácticas que me aligeren el trabajo. Los tests son una de ellas, así que he estado jugando un poco con los tests de Matlab.

Os cuento lo que he hecho y provecho para hacer propaganda de mi campo de estudio: las vibraciones.

Definir la función

Imaginemos que queremos comprobar que una determinada función se comporta de una determinada manera. Voy a usar como ejemplo el MAC (Modal Assurance Criterion), un número que nosotros los ingenieros mecánicos usamos para ver cuánto se parecen dos modos. Dicho así suena muy complejo, pero simplemente es una multiplicación escalar entre dos vectores que previamente hemos normalizado, es decir, que hemos dividido entre su magnitud. Visto en dos dimensiones consiste simplemente en calcular la sombra que un vector proyectará sobre el otro cuando situamos ambos en el mismo origen.

En fin, para dos vectores cualquiera (¡que pueden ser hasta complejos!) se puede calcular el MAC mediante la siguiente función:

function MAC = mac(a,b)
% Calcula el MAC entre los modos a y b
%
% MAC = MAC(a,b)
%
% donde a y b son vectores columna de tamaño Nx1

MAC = abs(a'*b)^2/((a'*a)*(b'*b));

end

Definir los tests

Hemos dicho que el MAC indica cuánto se parecen dos vectores y que representa la sombra de uno sobre el otro. Así, se me ocurren dos manera de comprobar si la función hace lo que debe:

  • Cuando los dos vectores son perpendiculares, el MAC tiene que ser cero porque la longitud de la proyección de uno sobre el otro (la sombra) es cero.

  • Cuando los dos vectores son iguales, el MAC tiene que ser uno porque son lo máximo de parecidos que pueden ser y al ser unitarios la máxima proyección solo puede medir uno.

Ahora toca definir esas condiciones en lenguaje matlabiano. Yo he ido por lo sencillo y he usado vectores bidimensionales:

% TESTS
% Vectores perpendiculares --> MAC = 0
aOrt = [1 0]';
bOrt = [0 1]';

% Vectores iguales --> MAC = 1
aSame = [1 1]';
bSame = [1 1]';

%% Test 1: vectores perpendiculares
assert(mac(aOrt, bOrt) == 0)

%% Test 2: vectores iguales
assert(mac(aSame, bSame) == 1)

El primer trocico son las definiciones, luego viene cada test en una celda de Matlab, un trozo que comienza por dos porcentajes. Este cachito de código lo he guardado como testMac.m y será el archivo que Matlab usará para poner a prueba mi función.

Testar la función

Para lanzar los tests ejecutamos runtest dándole como argumento el ficherillo donde hemos definido los tests:

result = runtests('testMac');

que nos dirá si han fallado los test o no y nos guardará la información que luego podemos ver en una simpática tabla haciendo:

rt = table(result)

Y, hala, ya sé testar. Ahora me falta aprender a definir tests con un mínimo de lógica. Lo próximo será investigar esto mismo en Julia. Os contaré.

Referencias

Testing Frameworks en la documentación de Matlab

Write Script-Based Unit Tests en la documentación de Matlab

Modal space articles de Pete Avitabile

Lo que he aprendido: dibujar cubos en Matlab

Como ando jugando con elementos finitos en el curro, me vi en la circunstancia de tener que pintar un modelo mallado con cubos en Matlab. Esto, que parece una tontería a simple vista es una locura total porque el buen Matlab hace solo superficies. Esto significa que para pintar un mísero cubo hay que pintar 6 superficies, cosa que tampoco es especialmente sencilla.

Después de probar varias alternativas, me he quedado con la función fill3 que pinta polígonos en tres dimensiones. Hay que meterle los datos de manera completamente antiintuitiva (es Matlab, recordemos), pero consigue el objetivo de crear cubetes.

Así que escribí esta función con la idea de usarla de base para pintar todo el modelo:

function cubo(coord)
% Pintar un cubos a partir de las coordenadas definidas según el siguiente
% orden para cada cubo:
%
%    7-------8
%   /|      /|
%  / |     / |
% 5--|----6  |
% |  3----|--4
% | /     | /
% 1-------2

for k = 1:length(coord)/8

  X = coord(8*(k-1)+1:8*(k-1)+8,1);
  Y = coord(8*(k-1)+1:8*(k-1)+8,2);
  Z = coord(8*(k-1)+1:8*(k-1)+8,3);

  % Los puntos de cada cara se ordenan según el sentido antihorario
  caras = [1 2 4 3; 5 6 8 7; 1 3 7 5; 2 4 8 6; 1 2 6 5; 3 4 8 7];

  % size(X) = [4 6]
  % - cada columna hace referencia a los puntos de un plano
  % - hay 4 elementos en cada columna que se refieren a las coordenadas x de
  % cada punto del plano

  X = [X(caras(1,:)) X(caras(2,:)) X(caras(3,:)) X(caras(4,:)) X(caras(5,:)) X(caras(6,:))];
  Y = [Y(caras(1,:)) Y(caras(2,:)) Y(caras(3,:)) Y(caras(4,:)) Y(caras(5,:)) Y(caras(6,:))];
  Z = [Z(caras(1,:)) Z(caras(2,:)) Z(caras(3,:)) Z(caras(4,:)) Z(caras(5,:)) Z(caras(6,:))];

  alpha = 0.6; % transparencia de la cara
  colour ='blue'; % color de la cara

  fill3(X,Y,Z,colour,'FaceAlpha',alpha); % dibujar los cubos
  axis equal

  hold on

end

end

Se usa de la siguiente manera:

P = [1 0 0; 1 1 0; 0 0 0; 0 1 0; 1 0 1; 1 1 1; 0 0 1; 0 1 1];

cubo(P)

Y nos pinta este simpático cubo:

cubo

Seguir leyendo

Lo que he aprendido: una mejor ayuda en Matlab

A estas alturas de la película sabemos todos ya que documentar nuestro código es una buena idea. También sabemos que Matlab asume que un comentario que se inicie en la primera línea de un script o justo debajo de la definición de una función es la documentación del archivo en cuestión.

Refresquémonos la memoria. Por ejemplo, si definimos una función así (he cogido una que tenía yo por ahí):

function x = euler_1gdl(data, ci, N, h)

% Computes time response of 1dof system using forward Euler

end

Y hacemos:

>>> help FUNCIÓN

Nos apacerá lo siguiente:

>> help euler_1gdl
Computes time response of 1dof system using forward Euler

Fácil y eficaz. ¡Pues hoy he aprendido tres cosas que no sabía sobre esta historia!

Seguir leyendo →

Lo que he aprendido: git y Matlab

Acabo de descubrir de una manera tontísima que Matlab se da cuenta de que el contenido de una carpeta está bajo control de versiones. Abrí una carpeta con mi código octaviano en Matlab y vi que junto a cada archivo salían chirimbolillos de colores:

git

El punto verde significa que estamos vigilando el archivo y no ha sufrido modificaciones (tracked and unmodified en la jerga) y el cuadradito azul que lo tenemos controlado pero que ha cambiado (tracked and modified). También nos puede aparecer un punto blanco que quiere decir que no tenemos el archivo bajo control (untracked).

Estos simbolitos los veremos a pesar de que no tengamos git instalado, si lo tenemos instalado podremos además añadir y commitear desde la propia interfaz de Matlab. Si hacemos click derecho en algún punto de la ventanita de los archivos veremos que tenemos una opción de Source control desde la que tenemos acceso a las acciones típicas que solemos hacer desde la terminal en versión visual.

matlab

Una cosa importante es decirle a git que archivos de Matlab como los fig y los mat son binarios para que no nos hurgue en ellos y nos los estropee. Para eso tenemos el archivo .gitattibutes, que situamos (generalmente) en la raíz del proyecto y que nos sirve para decirle a git como manejar sus asuntos. Matlab recomienda nuestro .gitattributes tenga esta pinta:

# Marcar como binario
*.mat -crlf -diff -merge
*.fig -crlf -diff -merge
*.p -crlf -diff -merge

Esto le indica a git que no haga ni diff ni merge en esos tipos de archivo y que no toque el final de línea. También podrían marcarse directamente con binary que es equivalente a -text -diff -merge, donde -text es a su vez equivalente a -crlf, es decir, a no tocar el final de línea.

En resumen, no creo que vaya a hacer commits desde la interfaz de Matlab, pero me parece útil ver el estado de cada archivo con un simbolito. También lo veo interesante para acercar a los ingenieros de la piedra y el palo (como yo) al mágico mundo del control de versiones. Conozco a muchísimos que programan en Matlab cosas grandes y serias y a casi ninguno que tenga su código controlado.

Referencias

Set Up Git Source Control en la página de MathWorks

Git for Windows

Git Attributes

Compilación: Matlab

Voy a hacer un repaso de mis artículos sobre Matlab, el software privativo que los ingenieros nos vemos obligados a utilizar y que algunos acaban amando. ¿Por qué ahora? me diréis y yo os responderé es una treta para que mis futuros empleadores sepan que manejo las herramientas de la industria. Igual hago otra compilación de Abaqus, soy un genio del mal.

Van en orden cronológico de más antigua a más moderna, se nota que en las primeras era joven e inexperta:

  • Expresiones regulares: aquí di comienzo a mi famosa saga sobre lo que he ido aprendiendo. Hablé de expresiones regulares en general y sobre cómo usarlas en Matlab en particular.

  • Filtro de Wiener: me creí experta en señal por un rato y estuve jugando a quitar el ruido a mis datos experimentales con un filtro de Wiener. Con bastante éxito, todo sea dicho.

  • Funciones anónimas: me dio el vicio funcional y aprendí un poco sobre funciones anónimas. El vicio se acrecentó en el futuro y aprendí un poco de Haskell.

  • Documentación HTML: como no puedo dejar ningún palo por tocar, también me puse a crear una documentación elegante.

  • Archivo de geometría UNV: un programa me obligaba a introducir cientos de puntos a mano así que escribí una función que lo hiciera por mí.

  • Archivo de modos UNV: como un archivo de geometría solo me parecía poco, también me puse a fabricar modos. Con estas dos funciones y un poco más de esfuerzo se puede hacer un programa de análisis modal. Igual algún día lo hago.

  • Leer matrices de subestructura de Abaqus: estuve intentando reducir un cálculo enorme que tenía y aprendí sobre subestruturas. Para ello jugué con matrices en Matlab, fue divertido.

  • Leer matrices de globales de Abaqus: me vine arriba y programé una historieta para leer también matrices globales. Aprendí sobre matrices dispersas y tal, me sentí muy lista.

  • Exportar imágenes a pdf: una ayuda para cuando escribí la tesis y necesitaba las imágenes en pdf para Pandoc.

  • Zoom en todos los subplots: otra función con la misma idea que la anterior, ayudarme a que la tesis quedara decente.

  • Leer datos de archivos de texto: a los que realizamos mediciones experimentales nos suele pasar que tenemos archivos de texto gigantes que tenemos que tratar. Aquí cuento una manera. Escribí esta entrada después de que me vinieran a pedir ayuda con Matlab por vez número 7895.

  • Especificar opciones de inicio: de cuando Matlab cambió el estilo de los gráficos y tuve que investigar cómo activar los nuevos para que todas las figuras fueran coherentes. También averigüe otras cosas de paso.

  • Extraer datos de una figura fig: un truco rápido aprovechar al máximo las cualidades de las figuras con extensión fig.

  • Pintar matrices MAC: otra entrada para que la tesis quedase cuca, esta vez sobre pintar las matrices de MAC para comparar mis análisis modales con mis simulaciones. Le pasé este código a otro doctorando y lo mejoró pero se lo quedó para sí mismo, el muy egoísta1.

  • Git en Matlab: descubrí que Matlab sabe cuándo un archivo está bajo control de versiones y que podemos hacer las típicas operaciones de manejo del repo desde la interfaz.

  • Trucos para la documentación: sobre enlazar la documentación de otras funciones o recursos externos en la ayuda de las nuestras funciones.

  • Dibujar cubos: necesitaba visualizar lo que hacía mi modelo de elementos finitos y para eso necesitaba pintar unos cubos. Luego ya me dediqué a hacer el anormal con ellos.

  • Tests: me da a veces por querer mejorar mis hábitos programáticos y pensé que aprender a testar con cierto criterio era buena idea.

  • Formato y exportación de figuras: un poco de código para dar formato coherente a figuras.

Todo esto que he ido contando aquí ha sido en general parte de un proyecto mayor, algunos públicos y que están en GitHub como el repo para entender fenómenos de ingeniería, el que recopila mis pruebas de fricción y receptancia con Abaqus y Matlab o el que contiene las funciones para tratar gráficos de las que hablaba.

Tened en cuenta que nadie me ha enseñado a programar en Matlab y casi todo mi código es para entender cosas así que no os esperéis nada especialmente eficiente ni bonito. Lo comparto en compensación a la miles de veces que un blog aleatorio de Internet me ha ayudado en mi trabajo.


Voy a eliminar todas las ganas que un futuro empleador tenga en contratarme mostrando mi naturaleza interior:


  1. Espero que lea esto y se avergüence 😘 

Lo que he aprendido: extraer las notas de beamer con una regex

¡Hoy he puesto a prueba mis habilidades informáticas! Quería extraer
las notas del tex de la presentación de la tesis para tener todo el
guión junto y poder prepararlo mejor y, evidentemente, no quería copiarlas a mano. Así que inicié mi investigación. Os la cuento.


Las notas tienen este formato:

\note{Contenido} % Sin overlay
\note<N>{Contenido} % Con overlay

Así que pensé en escribir una expresión regular que captara ambos
casos. Me salió una cosa así:

\\note(<\S+>)*\{(?<nota>[^}]+)\}

que hace lo siguiente:

  • Localiza \note

  • Busca una fila de caracteres sin espacios entre <>. Como esto solo
    aparece para el caso de los overlays, uso el * después del grupo
    para decirle que busque o bien uno o ninguno

  • Busca dos llaves y captura lo del interior con
    (?<nota>[^}]+), es decir, coge cualquier cosa que no sea una llave

Hice este miniprogramilla en Matlab para extraer las notas y
escribirlas en un fichero:

% Leer todo el archivo como string gigante

texto = fileread('presentation.tex');
exp = '\\note(<\S+>)*\{(?<nota>[^}]+)\}';

datos = regexp(texto,exp,'names');

notas = {datos.nota};

clear texto datos

% Escribir los datos en un md

fid = fopen('notas.md','w'); 
fprintf(fid,'%s \n\n', notas{:}); % línea blanca entre notas
fclose(fid); 

Luego tocó ir Emacs a corregir las chapuzas:

  • Corregí el ancho con autofill (M-q)
  • Quité la tabulación variable que tenía con C-u -4 C-x TAB, que
    permite reducir en 4 espacios la tabulación del texto seleccionado
  • Quité los saltos de línea (^M) con M-x replace-string buscando
    C-q C-m tal y como explican aquí

¡Listo! Ya están las notas preparadas, siete hojacas de texto que son :O

Referencias

Extract all \note tags from beamer as a simple text file en
StackExchange

Print a cell array as .txt in Matlab en
StackOverflow

Lo que he aprendido: pintar matrices de MAC en Matlab

Hoy vengo con una cosa megaespecífica para lo que yo hago en la vida: comparar cosas de simulación y experimentales. Concretamente comparo ruido y vibración y en este caso (más concretamente) comparo modos de vibración. ¿Por qué os voy a contar esto? Pues por varios motivos, hermanos míos. El primero es que alguien en el vasto mundo del Interneto puede querer hacer lo mismo que yo y así no tendría que empezar de cero. El segundo es que algún día no muy lejano tendré que buscar currelo y si mis futuros empleadores buscan mi nombre y lo ven relacionado con cosas técnicas dirán ¡oh! esta pava sabe lo que hace y me darán trabajo y me pagarán bien de dinero. Luego está el tercero y más importante: al explicar cosas a los demás es cuando entiendes si tú mismo las captas o no1. Dejémonos de rollos y vamos al lío: pintemos una matriz de MAC todo colorinesca en Matlab.


Primero y para los neófitos en el tema ingeniería mecánica, el MAC o Modal Assurance Criterion es un número entre 0 y 1 que nosotros los ingenieros de la piedra y el palo usamos para decir si dos modos de vibración (ignorar esto y leed vectores) son parecidos o no. Si el MAC es 0 pues son totalmente diferentes y si es 1 pues son iguales. ¿Cómo hacemos esto? Pues dividiéndolos entre su módulo y multiplicándolos escalarmente:

\mathrm{MAC}(\varphi_1, \varphi_2) = \frac{|{\varphi_1}^\intercal{\varphi_2}^*|}{({\varphi_1}^\intercal{\varphi_1}^*) ({\varphi_2}^\intercal{\varphi_2}^*)}

Las Ts y los asteriscos son porque son vectores complejos y verticales.

La particularidad de esto es que nos sirve para ver cómo de parecido es nuestro modelo de simulación a la realidad. Básicamente le damos a un programa nuestros modos de simulación y nuestros modos experimentales le decimos que compare todos con todos y nos haga una matriz rellena de MACs. Si tenemos muchos MACs grandes pues decimos que nuestro modelo es la repera y vamos por ahí muy ufanos. Así de simples somos, ya veis.

Después de esta miniintro teórica para que todo el mundo aprenda algo vamos a centrarnos en la gente que tiene una matriz de MAC en un xls exportada de algún programa y vamos a pintarla.

Seguir leyendo →

Lo que he aprendido: extraer datos de una figura fig en Matlab

Vuelta al curro y vuelta a las entradas técnicas del blog. Esta vez el problema consiste en extraer los datos de una figura de Matlab, de las que tienen extensión fig, para graficar los datos de otra manera. Podría volver a cargar los datos y pintar diferente, sí, pero en este caso el gráfico se hizo leyendo diferentes archivos y añadiendo puntos al gráfico sobre la marcha, así que cargar todos los datos, tratarlos y tal es mucho más lío.

Bien, la primera pista para ello la encontré aquí y la segunda aquí. Lo único que tenemos que saber es que para Matlab los gráficos son objetos que a su vez contienen otros objetos hijos. Los datos, por ejemplo, son hijos de los ejes (objeto axes). Lo tenéis mucho mejor explicado en el enlace de abajo.

Por lo tanto para extraer los datos tendríamos que hacer algo del estilo de esto:

% Cargar la figura sin que se muestre 

openfig('figura.fig','invisible');

% Acceder a los objetos hijos del los ejes actuales (current axes)

D = get(gca,'Children');

% Los datos están dentro de los ejes en XData, YData y ZData

XData = get(D,'XData'); 
YData = get(D,'YData'); 
ZData = get(D,'ZData'); 

Es un truquillo rápido, pero espero que os resulte útil 😀

Más

Sobre objetos y gráficos

Lo que he aprendido: especificar opciones de inicio en Matlab

Hoy he aprendido dos maneras para cambiar el comportamiento de Matlab en el arranque: añadir opciones al iniciar y crear un archivo de inicio. Os cuento.

Opciones al iniciar

Si lanzamos Matlab desde el terminal, podemos pasarle opciones, si usáis GNU/Linux estaréis acostumbrados a esto. Un ejemplo típico es decirle que se inicie sin Splash Screen:

matlab -nosplash

Es especialmente útil si tenemos un Matlab un poco antiguo y no utiliza los nuevos gráficos molones, podemos hacer que los use con:

matlab -hgVersion 2

Y podemos ir más allá, cambiar el acceso directo y hacer que se inicie siempre con las opciones que queramos. En Windows, si vamos a las propiedades del acceso directo, hay una pestaña que se llama Acceso directo con un campo Destino. Ahí pondrá algo similar a esto:

"C:\Program Files\MATLAB\R2014a\bin\matlab.exe"

Podemos cambiarlo y añadirle nuestras opciones, por ejemplo, para el caso de los gráficos haríamos:

"C:\Program Files\MATLAB\R2014a\bin\matlab.exe" -hgVersion 2

Así siempre se iniciará con los gráficos HG2 (o con lo que sea que le hayamos añadido).

El archivo de inicio

Por otra parte podemos crear un archivo startup.m y ponerlo en una carpeta en la que Matlab busque al arrancar. Lo más fácil es añadirlo en la carpeta de inicio, la que está justo debajo del campo Destino del acceso directo.

Este archivo nos sirve para decirle a Matlab qué carpetas añadir al path, definir variables, establecer opciones personalizadas para los gráficos… Lo veo especialmente útil para definir un estilo para todos los gráficos, sobre todo si luego van a usarse para un artículo o algo así que exija un formato concreto. Esto lo estoy investigando, espero poder hablar pronto de ello.

Un ejemplo sería añadir carpetas al path:

% Add path to startup

addpath PATH

Pero ya sabéis, esto podemos complicarlo hasta el infinito.

Bueno, nada más por hoy ¡Espero que os sea útil!

Fuentes

MathWorks: Specify Startup Options

MathWorks: Commonly Used Startup Options

Undocumented Matlab: HG2 update

What’s in your startup.m?