Matlab - Pasando código de Matlab a C

Hola!
Necesito unos principios o algún tipo de información para poder pasar correctamente a C un algoritmo que tengo hecho en Matlab.
Mi algoritmo en C no me da los resultados que me da en Matlab y no sé por qué, la verdad es que me resulta un algoritmo muy sencillo. Sospecho que el problema se debe a que mi algoritmo en Matlab trabaja con más decimales que los decimales que usa que mi algoritmo en c. Este algoritmo trabaja con números complejos pero puede separarse como dos algoritmos, uno que trabaja con la parte real y otro que trabaja con la parte imaginaria.
Pero en c solo hago un algoritmo que trabaja con la parte real.
Estoy un poco frustrado porque llevo más de una semana intentando pasarlo a C, no me sale y
no sé donde me puedo equivocar, la verdad es que me parece que hacer esto debe de ser fácil pero ahora mismo no se como.
Mi programa en c me funciona pero no me da los resultados que me da el Matlab.

Os agradezco cualquier ayuda.

De todas formas os dejo el el algoritmo en lenguaje de Matlab:

ii=1:256 %En c solo hago el algorimo para un valor, no para 256 valores.
salida_tmp_IT = exp(-((real(xoriginal(ii))*ones(1,10) - input_c_IT).^2)./(2*input_sigmas_IT.^2));
salida_tmp_QT = exp(-((imag(xoriginal(ii))*ones(1,10) - input_c_QT).^2)./(2*input_sigmas_QT.^2));
salida_tmp_IT_norm = salida_tmp_IT/sum(salida_tmp_IT);
salida_tmp_QT_norm = salida_tmp_QT/sum(salida_tmp_QT);
salida_tmp2_IT = salida_tmp_IT_norm.*output_c_IT + real(xoriginal(ii)).*ones(1,10).*output_sigmas_IT;
salida_tmp2_QT = salida_tmp_QT_norm.*output_c_QT + imag(xoriginal(ii)).*ones(1,10).*output_sigmas_QT;
salida(ii) = sum(salida_tmp2_IT)/7.257537 + sum(salida_tmp2_QT)/10.8391*j;

%Q hace referencia a la parte imaginaria
%input_c_IT,input_sigmas_IT,output_c_IT, output_sigmas_IT hace referencia a vectores de 10 %elementos cuyos valores son unos parámetros que he calculado previamente.

%Realmente solo sería el siguiente código
for ii=1:256
salida_tmp_IT = exp(-((real(xoriginal(ii))*ones(1,10) - input_c_IT).^2)./(2*input_sigmas_IT.^2));
salida_tmp_IT_norm = salida_tmp_IT/sum(salida_tmp_IT);
salida_tmp2_IT = salida_tmp_IT_norm.*output_c_IT + real(xoriginal(ii)).*ones(1,10).*output_sigmas_IT;
salida(ii) = sum(salida_tmp2_IT)/7.257537
end

--------------------------------------------------------
Este es mi algoritmo en C:
//'x' de este código corresponde a 'xoriginal 'del código en Matlab
for(i=0;i<10;i++)
{
yi[i] = pow(numero_e,((-1)*pow( x - input_c_IT[i],2))/(2*pow(input_sigma_IT[i],2)));
printf ("\n El valor de yi[%i] es %f \n", i+1, yi[i]);
sum_yi += yi[i];
}
for(i=0;i<10;i++)
{
yi_norm[i] = yi[i]/sum_yi;
yi_o[i] = yi_norm[i]*output_c_IT[i] + x*output_sigma_IT[i];
printf ("\n El valor de yi_o[%i] es %f \n", i+1, yi_o[i]);
sum_yi_o += yi_o[i];
//valor correcto
}
salida = sum_yi_o/7,257537;
printf ("\n El valor de salida es %f \n", &salida);
/*NOTA: Los printfs no son parte de mi algoritmo, los uso para ver los valores que van tomando algunas variables de mi algoritmo, Un pocop más abajo tengo mi programa en C entero*/

#include <math.h>

#define numero_e 2.718281828459046


/* Declaración de variables referidas al centro y al sigma*/
double input_c_IT[10] = {-0.294013347817412, -0.228, -0.1686, -0.0928, -0.0407, 0.0337, 0.0976, 0.1642, 0.2145, 0.2835};
double input_sigma_IT[10] = {0.0341, 0.0371, 0.034, 0.0317, 0.0275, 0.0225, 0.0321, 0.041, 0.0348, 0.0312};
double output_c_IT[10] = {0.2848, 0.1194, -0.032, -0.0055, -0.0001, 0.0003, -0.0002, 0.0746, 0.1573, 0.234};
double output_sigma_IT[10] = {1.5687, 1.248, 0.7579, 1.083, 1.1434, 1.1515, 1.1276, 0.384, -0.0179, -0.1542};
int main()
{
// Incialización de arrays y variables
double yi[10] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double yi_o[10] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double salida = 0;
double yi_norm[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
double sum_yi = 0;
double sum_yi_o = 0;
double x = 0.0549208568468319;
int i = 0;
printf ("\n El valor de x es %f \n", x);
/*printf ("\n Por favor, a continuación introduzca el valor de x \n");
scanf("%f", &x);*/
//Esto es algo que hice para depurar el programa
for(i=0;i<10;i++)
{
yi[i] = pow(numero_e,((-1)*pow( x - input_c_IT[i],2))/(2*pow(input_sigma_IT[i],2)));
printf ("\n El valor de yi[%i] es %f \n", i+1, yi[i]);
sum_yi += yi[i];
}
for(i=0;i<10;i++)
{
yi_norm[i] = yi[i]/sum_yi;
yi_o[i] = yi_norm[i]*output_c_IT[i] + x*output_sigma_IT[i];
printf ("\n El valor de yi_o[%i] es %f \n", i+1, yi_o[i]); //Si quito la sentencia del printf no me da la variable
sum_yi_o += yi_o[i];//salida el valor correcto, si incluyo esta sentencia, entonces si me da el va
//valor correcto
}
salida = sum_yi_o/7,257537;
printf ("\n El valor de salida es %f \n", &salida);
getchar();
getchar();
return 0;
}

Hola Peter;

No esta muy claro lo que efectivamente deseas implementar.

Si deseas podrias enviar tu codigo y una descripción, para ver que podemos nuestra central de servicios de programación.

Saludos
Dave

E-mail: [email protected]

Te agradezco mucho tu atención pero la verdad es que aunque me gustaria hacerlo no se me permite dar detalles, es parte de un PFC.
Realmente, la cuestión que estoy planteando en este foro no está en que mi modelo matemático sea correcto o no, si no en que el resultado numérico sea el mismo que me da en matlab. La cuestión a resolver es si existe algún problema con el coma flotante de Matlab que no se está haciendo del mismo modo en C.
El algoritmo matemático es sencillo:
Tengo 20 ecuaciones, pero realmente son dos una exponencial y otra lineal. Son dos ecuaciones cuyos parametros quedan recogidos en 4 vectores (Input_c_IT, Output_sigmas_IT,Output_c_IT, output_sigmas_IT) de 10 elementos cada uno (2 ec * 10 valores distintos para los parámetros de cada ecuación = 20 ecuaciones)
La ec. exponencial depende de una entrada, x. La ec. lineal depende de la salida de la ec. exponencial. Las salidas de ambas se tienen que normalizar.
¿Alguna vez en tu trabajo, has hecho un algoritmo en Matlab y luego lo has pasado a C de forma no automática?

He encontrado la solución a mi propio problema, ahí va lo que he aprendido:

Los principios para pasar algoritmos de Matlab a C de manera automática son los siguientes:
Asegurarse que los tipos de datos de C pueden contener el tamaño de los números con los que trabaja Matlab.
Asegurarse de que pasas correctamente todos los valores de Matlab a C. Para ello usa la función sprintf mostrando el máximo número de decimales.
¡Atención!, no copiar los valores de los parámetros directamente desde el workspace, ya que automáticamente Matlab te los redondea.

sprintf('%.nf',vectorj(i))
Donde 'n' es el número de decimales que quieres que salgan por pantalla e 'i' es el indice que señala al el elemento i del vector j.

Espero que esto le resulte útil a alguien más aparte de mi.