Saltar al contenido principal
LibreTexts Español

6.4: Sintaxis - Entradas (Parámetros) y Salidas

  • Page ID
    87619
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    \( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

    ( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\id}{\mathrm{id}}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\kernel}{\mathrm{null}\,}\)

    \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\)

    \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\)

    \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    \( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

    \( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

    \( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vectorC}[1]{\textbf{#1}} \)

    \( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

    \( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

    \( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

    \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    Diferentes lenguajes requieren una sintaxis diferente para la definición y uso (call) de una función. Primero consideramos el primero y luego el segundo. A modo de ejemplo, presentamos a continuación la función\(\mathrm{x}_{2}\) to_el_\(2 \mathrm{p}\) que dada\(x\) evalúa la función (en este caso, literalmente una función matemática)\(x^{2 p}\).

    function [ value ] = x_to_the_2p( x, p ) 
    value = x.^(2*p); 
    end
    

    La primera línea declara que este script es una función, que la salida se devolverá en un valor variable, que el nombre de la función -y también el nombre del\(m\) archivo en el que se almacena la función- es x_to_el_2p, y que la función toma dos argumentos,\(x\) y \(p\). A continuación sigue el cuerpo de la función que produce la salida, valor. La función se cierra con una sentencia end.

    Observamos que nuestra pequeña función toma una matriz de índice único (o incluso multi-índice) como entrada. En general, como se describió anteriormente, las llamadas a funciones pueden ser costosas y, por lo tanto, lo mejor es generar la mayor cantidad de datos posible con cada llamada para minimizar el número de llamadas requeridas. Por esa razón, a menudo es ventajoso definir funciones de tal manera que las entradas y salidas (apropiadas) sean matrices en lugar de escalares. (En nuestro ejemplo anterior, el valor será del mismo tamaño que\(x\). Esto se realiza automáticamente a través de la declaración de asignación.) Por supuesto, los escalares serán un caso especial de matrices y, por lo tanto, la función aún puede llamarse con argumentos escalares.

    De manera más general, la sintaxis para una función con\(\mathrm{J}\) entradas y K salidas es

    function [output 1, output 2, . . . , output K] = function name(input 1, input 2, ..., input J ) 
    BODY of FUNCTION 
    end
    

    Tenga en cuenta que es posible que no solo tengamos múltiples entradas sino también múltiples salidas. Todas las salidas deben definirse dentro del CUERPO de FUNCIÓN o MATLAB se quejará.

    El funcionamiento de la función es bastante claro. Primero nuestro pequeño ejemplo (al que llamamos aquí desde la ventana de comandos, pero por supuesto también podría llamarse desde un programa “principal” u otro programa de función):

    >> clear all 
    >> y = x_to_the_2p( [1,2], 2) 
    y = 
        1 16 
    >> value ??? Undefined function or variable 'value'.
    >>
    

    Nota en lo anterior nuestra función es evaluada y la salida asignada a la variable y. El valor de la variable es interno a la función y al programa llamante - en este caso se llama a la función desde el modo de línea de comandos y por lo tanto las variables del programa llamante son simplemente el espacio de trabajo - no tiene conocimiento de esto Variable “ficticia”.

    De manera más general, llamamos a una función con\(\mathrm{J}\) salidas y\(\mathrm{K}\) entradas como [output_1, output_2\(2 . \ldots\), output_\(J]=\) function_name (input_ 1, input_\(2, \ldots\), input_\(J\));. (Tenga en cuenta que si omitimos el punto y coma entonces nuestras salidas se mostrarán todas en la ventana de comandos). Al ser llamado por el programa llamante, nombre_función ejecuta BODY de FUNCCIÓN para los valores de los argumentos de entrada pasados a nombre_función y luego al llegar a la sentencia end nombre_función devuelve las salidas - y control - al programa llamante. Nota es posible forzar un retorno temprano de una función (al programa que llama) antes de que la sentencia end se encuentre con una sentencia return dentro del BODY de FUNCCIÓN.

    Es posible solicitar únicamente las primeras\(K^{\prime}\) salidas como [output_ 1, output_\(2, \ldots\), output_\(K^{\prime}\)] = nombre_función (input_1, input_2,..., input_\(J\));. Particularmente útil es el caso en el que solo requieres la primera salida, ya que en este caso puedes usar directamente la función a través de la composición dentro de una expresión mayor con el intermediario de asignación. Hasta este punto, con la excepción de min, hemos considerado solo funciones de salida única (o en cualquier caso solo solicitadas por la primera salida) en nuestros ejemplos -y precisamente por esta razón de composición. Otro ejemplo aquí:

    >> z = x_to_the_2p( [1,2], 2) + [2,3] 
    z = 
        3 19 
    >>
    

    Tenga en cuenta que es importante distinguir entre múltiples salidas y matrices. Una matriz corresponde a una salida particular, no a múltiples salidas; en nuestro ejemplo anterior, hay una salida única, que resulta ser una matriz de índice único de longitud\(2 .\)

    También es posible llamar a una función sin todas las entradas especificadas, ya sea con entradas [] (nulas) o simplemente con una lista truncada, las primeras\(J^{\prime}\) entradas. No obstante, en este caso, es importante que dentro de la función se definan todas las entradas que se encontrarán. En este sentido, la función de MATLAB isempty es útil (para nulos) y el nargin MATLAB es útil (para listas de argumentos truncados) para detectar cualquier entrada “unset” que deba asignarse a valores predeterminados. (Tenga en cuenta que los diferentes lenguajes de programación tienen diferentes mecanismos para lidiar con los valores predeterminados). También hay una función de nargout MATLAB útil en la confección de las salidas proporcionadas.


    This page titled 6.4: Sintaxis - Entradas (Parámetros) y Salidas is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by Masayuki Yano, James Douglass Penn, George Konidaris, & Anthony T Patera (MIT OpenCourseWare) via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.