¿Cómo puedes escribir en C una función que devuelve el punto fijo de una función?

Estoy de acuerdo con la respuesta de Brian Bi a ¿Cómo puedes escribir en C una función que devuelve el punto fijo de una función? Una función es mucho más general que la respuesta del usuario de Quora. ¿Cómo puede escribir en C una función que devuelva el punto fijo de una función? a la hora de escribir asume. Una función puede devolver conjuntos, por ejemplo. En tales casos, la “tasa de cambio” (o pendiente, o derivada) no tiene mucho significado. Para funciones que devuelven un número, sí, uno probablemente puede hacer lo que hace Aparijata. Formas similares pueden ser válidas para algunas funciones específicas. Un caso especial es una función con puntos fijos atractivos .

La comparación de Brian con las ecuaciones de diofantina es bastante adecuada: una vez puede resolver ciertas ecuaciones de diofantina con bastante facilidad a través de la programación, pero no ninguna ecuación arbitraria. En general, no se puede escribir una función en C, ni tampoco una función en ningún lenguaje, para obtener el punto fijo de una función arbitraria.

Esto depende de si está dispuesto a conformarse con la precisión y el rango de entradas o flotadores de 32 bits. Si es así, generalmente es práctico simplemente iterar a través de todas las posibilidades 2 ^ 32 y verificar cuándo la salida coincide con la entrada (dentro de una tolerancia apropiada, en el caso flotante). De lo contrario, debe saber más sobre g (por ejemplo, ¿cumple las condiciones para la convergencia del método de Newton?) Antes de poder hacerlo de manera eficiente y correcta.

No puedes Tampoco puedes hacerlo en ningún otro idioma. Hay algunos lenguajes en los que puede definir combinadores de punto fijo, pero en general no devuelven valores explícitos; es simplemente la forma en que ocurre la evaluación en el lenguaje lo que permite que la definición tenga sentido. Calcular explícitamente un valor fijo de una función arbitraria es al menos tan difícil como, por ejemplo, resolver una ecuación arbitraria de diofantina (que sabemos que es imposible).

Una pequeña búsqueda en Google me llevó a esta Iteración de punto fijo … Se puede encontrar una descripción de las matemáticas Iteración de punto fijo, pero supongo que ya sabes que 🙂

Si eres demasiado vago para abrir el enlace, aquí está el programa, copiado y pegado del enlace

  doble función (doble x) // esta es la función para la que desea encontrar el punto fijo
     {
         retorno (1 + x - pow (x, 2) / 4);
     }

     vacío principal()
 {
         doble MaxPnew = 1E + 200;  / * valor absoluto más alto para Pnew * /
         doble Tol = 0.000001;  / * Criterio de terminación * /
         int Max = 200;  / * Número máximo de iteraciones * /
         doble pequeño = 0.000001;  / * Inicializa la variable * /
         int K = 0;  / * Inicializar el contador * /
         doble RelErr = 1;  / * Inicializa la variable * /
         doble Pterm;  / * ENTRADA: La aproximación inicial * /
         doble Pnew;  / * Resultado de una iteración * /
         doble pliegue, Dg, Delta, Dx, pendiente;
         int iwarn = 0;  / * Inicializar bandera de advertencia * /

         printf ("Ingrese el valor de INICIO para la iteración: \ n");
         scanf ("% lf", & Pterm);
         printf ("valor de INICIO para la iteración: Pterm =% lf \ n", Pterm);
         printf ("");

         Pnew = gfunction (Pterm);  / * Primera iteración * /

     while ((RelErr> = Tol) && (K <= Max)) {

          K ++;  / * Incrementar el contador * /
          Pliegue = Pterm;  / * Anterior iterar p_ (k + 1) * /
          Pterm = Pnew;  / * Actual iterate p_k * /
          Pnew = gfunction (Pterm);  / * Calcular nueva iteración p_ (k + 1) * /

        if (fabs (Pnew)> MaxPnew) {/ * Verifique +/- INF antes
                                             el final del ciclo while * /
             iwarn = 1;  / * establecer indicador para advertencia * /
             descanso;  / * salir del ciclo while * /
        }

          Dg = Pnew - Pterm;  / * Diferencia en la función g * /
          Delta = fabs (Dg);  /* Error absoluto */
          RelErr = 2 * Delta / (fabs (Pnew) + Small);  /* Error relativo */

     } / * Fin del ciclo 'while' * /

         Dx = Pterm - Pliegue;  / * Diferencia en x * /
         Pendiente = Dg / Dx;  / * g '(p_k) * /

     printf ("----------------------------------------------- \norte");

     if (iwarn) {/ * Dile que Pnew ha crecido dramáticamente y detén * /
          printf ("Número de iteraciones:% d \ n", K);
          printf ("¡La iteración sale del rango de precisión! \ n");
          printf ("Valor de x = Pnew =% G \ n", Pnew);
          printf ("¡La secuencia parece ser divergente! \ n");
          salida (0);
     }

     printf ("Número de iteraciones:% d \ n", K);
     printf ("El punto fijo calculado de g (x) es% lf \ n", Pnew);
     printf ("Las iteraciones consecutivas están dentro de% lf \ n", Delta);

    if (fabs (Slope)> 1) printf ("La secuencia parece ser divergente. \ n");
    else printf ("La secuencia parece converger. \ n");

 } / * Finalizar programa principal * 

Si puede saber que la función es continua y tiene un diferencial completamente positivo, probablemente podría usar el método de Newton.