Я сейчас составляю тесты ориентируясь на книгу:
Мудров А.Е., Численные методы для ПЭВМ на языках Бейсик, Фортран и Паскаль.
Естественно не всё подряд.
Но хотелось бы посмотреть на задачи из жизни, т.е. использование численных методов для решения какой-то вполне конкретной задачи.

Это не ответ на ваш вопрос, в принципе, достаточно написать несколько вложенных циклов просто с длительным суммированием в пределах выбранного типа данных. Ну мы вот с одним учеником делали работу по оценке скорости выполнения любых алгоритмов (что в работе названо эффективностью, хотя в принципе это не совсем так), посмотрите.
презентация (4.41 Mб)
Если вам понадобится, то и файлы найду.
Мы использовали это для оценки скорости выполнения программ по заданиям ЕГЭ, но в такую программку, как в оболочку, можно вставить любой алгоритм.

Можете посчитать дайджесты чего-нибудь (md5, sha,..), кодировать аудио-видео (h.264, mp3,..)
Алгоритмы там, правда, непростые, зато есть готовые библиотеки.

Спасибо! Это хорошая мысль.

Искать магические квадраты n-го порядка.

Это там где суммы диагоналей, строк и столбцов одинаковы или я что-то путаю?

Они самые.

Для тестирования компиляторов не годятся готовые библиотеки
Необходимо компилировать один исходник, а не вызывать готовое!
Только вот что посоветовать, ничего такого, чтоб аж-аж, не идет в голову...
Только идея вызывать многократно что-то типа нахождения корня численным методом или
нахождения обратной матрицы...

Код теста я пишу сам (для разных языков программирования код делаю максимально универсальный) и, естественно, без привлечения сторонних вычислительных библиотек (типа там всяких BLAS, LAPACK и тому подобных, однако использую прилагаемые к компилятору модули типа MATH), потом его компилирую, а затем уже тестирую готовый бинарник.
Т.е. я хочу сделать обзор возможностей оптимизации бинарника у разных компиляторов. Основной упор - на скорость выполнения расчёта заданного алгоритма.

Компиляторы беру только OpenSource и только бесплатные. Для нашей страны это актуальная задача.

Ну и? Какой алгоритм приглянулся? Я бы, наверное, остановился на нахождении обратной матрицы....
С матрицей большой размерности может быть довольно много возни. Как раз то, что требуется...

Если надо, могу и исходник нарисовать...

Где-то так...
Для контроля производится умножение матриц...
Увеличивая размерность матриц, существенно увеличивается время
При N=9 считает 2 сек
При N=10 считает 12 сек
При N=11 считает 145 сек
Времена заданы для дебаговской версии. Релиз не пробовал...
Вот пусть компиляторы и оптимизируют программку
PS Обратная матрица находится с помощью союзной матрицы...
[code h=200]
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <malloc.h>

#define N 10
#define SIGN(i,j) (1-(((i+j)&1)<<1))

void Print(double *A, int max)
{
int i, j;

for(i=0; i<max; i++)
{
for(j=0; j<max; j++)
printf("%8.4f ",A[i*max+j]);
printf("\n");
}
printf("\n");
}

void FillArray(double *A, double *array, int max, int i, int j)
{
int iA,jA,iB,jB;

for(iA=iB=0; iA<max; iA++)
{
if (iA != i)
{
for(jA=jB=0; jA<max; jA++)
{
if (jA != j)
array[iB*(max-1)+jB++] = A[iA*max+jA];
}
iB++;
}
}
}

double GetDet(double *A, int max)
{
double det;
int j;
double *array;

if(max==1)
det = A[0];
else if(max==2)
det = A[0]*A[3]-A[1]*A[2];
else
{
det = 0;
array = (double*)malloc((max-1)*(max-1)*(sizeof(double)));
for(j=0; j<max; j++)
{
FillArray(A, array, max, 0, j);
det += SIGN(0,j)*A[j]*GetDet(array, max-1);
}
free(array);
}
return det;
}

bool ReverseArray(double *A, double *B, int max)
{
int i, j;
double det = GetDet(A, max);
double *array=NULL;

if (det == 0)
return false;

array = (double*)malloc((max-1)*(max-1)*(sizeof(double)));

for(i=0; i<max; i++)
{
for(j=0; j<max; j++)
{
FillArray(A, array, max, i, j);
B[j*max+i] = SIGN(i,j)*GetDet(array, max-1)/det;
}
}
free(array);
return true;
}

void MulArrays(double *A, double *B, double *C,int max)
{
int i, j, k;
double sum;

for(i=0; i<N; i++)
{
for(j=0; j<N; j++)
{
for(sum=k=0; k< max; k++)
sum += A[i*max+k]*B[k*max+j];
C[i*max+j] = sum;
}
}
}

int main()
{
int i, j;
srand(time(NULL));

double *A = (double*)malloc(N*N*sizeof(double));
double *B = (double*)malloc(N*N*sizeof(double));
double *C = (double*)malloc(N*N*sizeof(double));

for(i=0; i<N; i++)
for(j=0; j<N; j++)
A[i*N+j] = ((double)((rand() % 2000) - 1000))/17;

Print(A, N);
if (ReverseArray(A, B, N))
{
Print(B, N);
MulArrays(A, B, C, N);
Print(C, N);
}
else
printf("Singular array!\n");

_getch();

free(A);
free(B);
free(C);
return 0;
}[/code]

Если надо, могу и исходник нарисовать...

Спасибо, но у меня уже есть. Я как-то писал модуль по работе с матрицами, так что есть.

так что есть

Ну и славно. Можно будет сравнить

Можно будет сравнить

Ок. В выходные посмотрю. Правда я свой модуль писал специально для параллельных вычислений (использовал OpenMPI), так что Ваш тоже придётся доделать маленько, чтобы одинаково было.
Забыл сказать, у меня тесты в двух вариантах - просто так и для параллельных вычислений (OpenMP и OpenMPI). Правда кластер у меня задрипаный - всего-лишь четыре машины с процессорами i5 и 4ГБ памяти.

Ну как там, что-то получилось?
Могу дать lib-у на асме, чтобы сравнить. Не надо?
Матрицу размерности 11 считает за 37 секунд.