Вы бы не могли вместо вывода GDB привести результат выполнения такого кода:

double d;

d=(double)getInt(routes,N,i,j);
printf("getInt -> %lf\n", d);
dvalue=d;

d=getDouble(tau,N,i,j);
printf("getDouble -> %lf\n", d);
dvalue=dvalue*d;

printf("old dvalue -> %lf\n", dvalue);
printf("old tau_ij -> %lf\n", tau_ij);

tau_ij+=dvalue;

printf("new dvalue -> %lf\n", dvalue);
printf("new tau_ij -> %lf\n", tau_ij);

Значение из функции записываю в отдельную переменную, смотрю в отладчике значение функции до и после отладки, каждый раз отладчик выдаёт адекватное значение, а в переменную пишется та самая НЁХ.

dvalue=(double)getInt(routes,N,i,j);
dvalue2=getDouble(tau,N,i,j);
dvalue=dvalue*dvalue2;

gdb fsfgds

(gdb) break 132 if k==0 && x==1 && y==5
Breakpoint 1 at 0x8048d35: file fsfgds.c, line 132.
(gdb) run first.map
Starting program: /home/northsoft/fsfgds/fsfgds first.map

Breakpoint 1, main (argc=2, argv=0xbf979784, env=0xbf979790) at fsfgds.c:132
132                                                             dvalue2=getDouble(tau,N,i,j);
(gdb) printf "%f\n", getDouble(tau,N,i,j)
22.062000
(gdb) next
133                                                             dvalue=dvalue*dvalue2;
(gdb) printf "%f\n", getDouble(tau,N,i,j)
22.062000
(gdb) printf "%f\n", dvalue2
159066936.000000
(gdb)

-lm есть?

Да, так как использую exp и log. #include <math.h> в комплекте.

double печатать надо через %lf, а не %f

GDB этого не понимает. =\

поставь printf'ы в самой программе

getInt -> 192.000000
getDouble -> 163744568.000000
old dvalue -> 31438957056.000000
old tau_ij -> 0.000000
new dvalue -> 31438957056.000000
new tau_ij -> 31438957056.000000

Что самое интересное, GDB опять-таки выводит годное значение, каждый раз. А вывод программы каждый раз разный (числа getDouble'ом возвращаются каждый раз разные).

double getDouble(double *array, int dimension, int x, int y){
        double *ret;
        if(array==NULL) return 0;
        ret=array;
        ret+=dimension*x+y;
        return *ret;
}

Доен (см.пост выше). Чем тогда printfы в GDB отличаются от printfов в либси?

Я не знаю как работает printf в gdb, ибо всегда пользовался просто 'p'. в программе поставь %lf обязательно, иначе мусор будет печататься. Еще прогони через valgrind.

Печаль в том, что программа это не выводит, а использует в расчётах дальше, в итоге получаю кучу NaNов.

выстави флаги fpu, тогда на первой же херне у тебя прога упадет и ты сможешь отловить

тут что-то очень не тек. что есть array? почему ты возвращаех поинтер на переменную со стека?

double
getDouble(double *array, int dimension, int x, int y)
{
        return *array + dimension*x+y;
}

Если флаги fpu грохнут прогу на генерации NaNа, то я уже отловил первый из них, экспериментально (k==0 && x==1 && y==5)

о_О что это?

Это выставляет флаги. При любой нежелательной работе с floating point прога рушится. Проверено на win32/win64, linux x86/x86_64

array - double* tau=malloc(N*N*sizeof(double)), memset(tau,0,N*N*sizeof(double))
Если бы я хотел вернуть указатель на переменную со стека, то я бы писал &(array+dimension*x+y). В Вашем коде, как я понимаю, происходит возврат первого элемента массива, к которому прибавлен dimension*x+y. В моём коде возвращается *(array+dimension*x+y), или, проще говоря, array[dimension*x+y]

Спасибо за исходник, прога рухнула по SIGFPE при обращении к exp(), конец немного предсказуем. :) и всё же, в чём может быть фишка, если GDB'вский printf выдаёт адекватное значение, но в переменную пишется бред?

а, тогда понятно

valgrind'ом смотрел?

Пока что ман ковыряю

Ругается только на утечки памяти, я пока не дописал до конца, чтоб можно было спокойно деаллокать память)

на неинициализированные данные не ругалось? по симптомам похоже

Вот в том-то и дело, что нет. Я очень тщательно работаю над данными, прежде чем их использовать. Мемсеты, несколькоэтажные циклы по инициализации матриц, всё как положено. Думаю, тут должна быть другая зацепка - вывод GDB.

Так вроде бы - правильный ответ получает программа! В этом выводе проблем нет!

И в этом выводе проблем тоже нет никаких! Все правильно!

> getDouble -> 163744568.000000
Там значение должно быть порядка двадцати (см. вывод GDB)

(gdb) printf «old dvalue=%f (%e), multiplier=%f (%e)\n», dvalue, dvalue, getDouble(tau,N,i,j), getDouble(tau,N,i,j)

old dvalue=192.000000 (1.920000e+02), multiplier=22.062000 (2.206200e+01)

Multiplier - значение от getDouble

Ну, теперь вы знаете где ошибка - некорректный метод getDouble! Каким бы он ни казался правильным, все же он неправильный в данном контексте :)

то, что getDouble в отладчике выдает верный ответ - случайность. Где-то что-то не перетерлось просто.

Вы это логически обосновать можете? Каждый раз (!) чтобы выдавался верный ответ в отладчике - не слишком ли крутая «случайность»? :)

Только что протестировал ваши методы работы с матрицами - у меня все работает правильно. Не могли бы вы запостить сюда весь код?

Просто получается - того, что вы запостили не достаточно для того, чтоб воспроизвести проблему.

Убей себя об стену - спаси мир: gcc -Wall

Всё оказалось очень тупо и уныло. Исходник состоит из двух файлов, злополучная getDouble объявлена в другом исходнике. По уму должна была быть записана в хеадер, но записана не была, по моей собственной тупости. Первая же компиляция со всеми предупреждениями меня ткнула мордой в то, что функция getDouble объявлена неявно.
Прости, ЛОР...
Reset, ты - сам знаешь кто :) спасибо за помощь,твой исходник схоронил. Добра тебе и удачи во всём. Вива ла Мандрива. :)
anonymous, ты, как всегда, неотразим и бесподобен. Спасибо за посильное участие, да пребудет с тобою Легион.

Да, бывает. Функции объявленные неявно объявляются как int func(...).