2Antichrist:

Спасибо за ответ. В Master Beta2 имеется. Еще раз спасибо.

А в общем-то как, все затихли?

:))))

2lenin (*) (2002-04-26 22:24:35.485):

Перезакинь, отключив TeX Paragraphs, пожалуйста. Не могу я так посмотреть, что ты там написал, а хочется.

А/Х вышел покурить/за пивом/воздухом подышать. И тишина....

P.S. Еще одна ступенька хит-парада позади ;)

Результаты :

M$VC, W98 -         28 сек
icc, Linux 2.4.17 - 21 сек
gcc, Linux 2.4.17 - 20 сек

Мой CPU - Cel-1000Mhz 128k cache

И это на числодробилке, которыми так кичится Интель.
Позор !

icc -O3 test.c

gcc test.c -O2 -Wall -Wno-unused -funroll-loops -fstrength-reduce -fomit-frame-pointer 
-ffast-math -malign-functions=4 -malign-jumps=4 -malign-loops=4

Сделал тест более портабельным :
=================================================================

#include <stdlib.h> 
#include <stdio.h> 
#include <math.h> 
#include <sys/timeb.h> 

int minv(double *a,int n);


/* Period parameters */  
#define N 624
#define M 397
#define MATRIX_A 0x9908b0df   /* constant vector a */
#define UPPER_MASK 0x80000000 /* most significant w-r bits */
#define LOWER_MASK 0x7fffffff /* least significant r bits */

/* Tempering parameters */   
#define TEMPERING_MASK_B 0x9d2c5680
#define TEMPERING_MASK_C 0xefc60000
#define TEMPERING_SHIFT_U(y)  (y >> 11)
#define TEMPERING_SHIFT_S(y)  (y << 7)
#define TEMPERING_SHIFT_T(y)  (y << 15)
#define TEMPERING_SHIFT_L(y)  (y >> 18)

static unsigned long mt[N]; /* the array for the state vector  */
static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */

/* initializing the array with a NONZERO seed */
void
sgenrand(seed)
    unsigned long seed;	
{
    /* setting initial seeds to mt[N] using         */
    /* the generator Line 25 of Table 1 in          */
    /* [KNUTH 1981, The Art of Computer Programming */
    /*    Vol. 2 (2nd Ed.), pp102]                  */
    mt[0]= seed & 0xffffffff;
    for (mti=1; mti<N; mti++)
        mt[mti] = (69069 * mt[mti-1]) & 0xffffffff;
}

double /* generating reals */
/* unsigned long */ /* for integer generation */
genrand()
{
    unsigned long y;
    static unsigned long mag01[2]={0x0, MATRIX_A};
    /* mag01[x] = x * MATRIX_A  for x=0,1 */

    if (mti >= N) { /* generate N words at one time */
        int kk;

        if (mti == N+1)   /* if sgenrand() has not been called, */
            sgenrand(4357); /* a default initial seed is used   */

        for (kk=0;kk<N-M;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1];
        }
        for (;kk<N-1;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1];
        }
        y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
        mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1];

        mti = 0;
    }
  
    y = mt[mti++];
    y ^= TEMPERING_SHIFT_U(y);
    y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
    y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C;
    y ^= TEMPERING_SHIFT_L(y);

    return ( (double)y / (unsigned long)0xffffffff ); /* reals */
    /* return y; */ /* for integer generation */
}

#define DIMENSION 1000 
int main(void) 
{ 
double *matrix; 
int i,j; 
struct timeb ti1, ti2; 

sgenrand(6912);

matrix = (double*) malloc(DIMENSION*DIMENSION*sizeof(double)); 
for (i=0;i<DIMENSION;i++){ 
for (j=0;j<DIMENSION;j++){ 
matrix[i*DIMENSION+j] =  genrand(); 
} 
} 
ftime(&ti1); 
minv(matrix,DIMENSION); 
ftime(&ti2); 
fprintf(stderr,"time = %d seconds\n", ti2.time-ti1.time); 
return 0; 
} 
/* minv.c CCMATH mathematics library source code. 
* 
* Copyright (C) 2000 Daniel A. Atkinson All rights reserved. 
* This code may be redistributed under the terms of the GNU library 
* public license (LGPL). ( See the lgpl.license file for details.) 
* ------------------------------------------------------------------------ 
*/ 
int minv(double *a,int n) 
{ int lc,*le; double s,t,tq=0.,zr=1.e-15; 
double *pa,*pd,*ps,*p,*q,*q0; 
int i,j,k,m; 
le=(int *)malloc(n*sizeof(int)); 
q0=(double *)malloc(n*sizeof(double)); 
for(j=0,pa=pd=a; j<n ;++j,++pa,pd+=n+1){ 
if(j>0){ 
for(i=0,q=q0,p=pa; i<n ;++i,p+=n) *q++ = *p; 
for(i=1; i<n ;++i){ lc=i<j?i:j; 
for(k=0,p=pa+i*n-j,q=q0,t=0.; k<lc ;++k) t+= *p++ * *q++; 
q0[i]-=t; 
} 
for(i=0,q=q0,p=pa; i<n ;++i,p+=n) *p= *q++; 
} 
s=fabs(*pd); lc=j; 
for(k=j+1,ps=pd; k<n ;++k){ 
if((t=fabs(*(ps+=n)))>s){ s=t; lc=k;} 
} 
tq=tq>s?tq:s; if(s<zr*tq){ free(le-j); free(q0); return -1;} 
*le++ =lc; 
if(lc!=j){ 
for(k=0,p=a+n*j,q=a+n*lc; k<n ;++k){ 
t= *p; *p++ = *q; *q++ =t; 
} 
} 
for(k=j+1,ps=pd,t=1./ *pd; k<n ;++k) *(ps+=n)*=t; 
*pd=t; 
} 
for(j=1,pd=ps=a; j<n ;++j){ 
for(k=0,pd+=n+1,q= ++ps; k<j ;++k,q+=n) *q*= *pd; 
} 
for(j=1,pa=a; j<n ;++j){ ++pa; 
for(i=0,q=q0,p=pa; i<j ;++i,p+=n) *q++ = *p; 
for(k=0; k<j ;++k){ t=0.; 
for(i=k,p=pa+k*n+k-j,q=q0+k; i<j ;++i) t-= *p++ * *q++; 
q0[k]=t; 
} 
for(i=0,q=q0,p=pa; i<j ;++i,p+=n) *p= *q++; 
} 
for(j=n-2,pd=pa=a+n*n-1; j>=0 ;--j){ --pa; pd-=n+1; 
for(i=0,m=n-j-1,q=q0,p=pd+n; i<m ;++i,p+=n) *q++ = *p; 
for(k=n-1,ps=pa; k>j ;--k,ps-=n){ t= -(*ps); 
for(i=j+1,p=ps,q=q0; i<k ;++i) t-= *++p * *q++; 
q0[--m]=t; 
} 
for(i=0,m=n-j-1,q=q0,p=pd+n; i<m ;++i,p+=n) *p= *q++; 
} 
for(k=0,pa=a; k<n-1 ;++k,++pa){ 
for(i=0,q=q0,p=pa; i<n ;++i,p+=n) *q++ = *p; 
for(j=0,ps=a; j<n ;++j,ps+=n){ 
if(j>k){ t=0.; p=ps+j; i=j;} 
else{ t=q0[j]; p=ps+k+1; i=k+1;} 
for(; i<n ;) t+= *p++ *q0[i++]; 
q0[j]=t; 
} 
for(i=0,q=q0,p=pa; i<n ;++i,p+=n) *p= *q++; 
} 
for(j=n-2,le--; j>=0 ;--j){ 
for(k=0,p=a+j,q=a+ *(--le); k<n ;++k,p+=n,q+=n){ 
t=*p; *p=*q; *q=t; 
} 
} 
free(le); free(q0); 
return 0; 
} 

К черту, я тут понаписал всякой чуши, постингов 20-ть. Где модератор??? К завтрему ведь постингов 10 останется!

2lenin: "M$VC, W98 - 28 сек"
Я не знаю как ты компилировал, на на моем PII-400 под W2K время составило 32 секунды. Не будешь же ты утверждать что С1000 быстрее PII-400 всего на 12%? Да строка компиляции такая: cl /Ox /G6 (компилятор версии 12.00.8186)

Я вот опять же про хит-парад :)): вот интересно, там считаются все комментсы (включая удаленные) или только "чистые" (которые не удалил модератор)?

2 lenin: немного некорректно, но мне удалось заставить интел обогнать gcc.
icc -o comp -O3 -ip -unroll10 -tpp6 -xK comp.c
gcc, linux 2.4.10: 20 sec
icc, linux 2.4.10: 19 sec
в среднем.
плюс -- известное дело -- компилятору надо помогать, циклы писать так, чтобы он легко мог их векторизовать, в мануале к интелу говорится, как это делать.

да, забыл, камень -- PIII 733 МГц.

> К черту, я тут понаписал всякой чуши, постингов 20-ть. Где модератор???

Надеюсь, это был не А/Х??!! :)

2anonymous ([46]*) (2002-04-26 23:21:33.845)

имхо легко может и меньше... только надо данных столько, чтоб в целероновский кэш не влазили, а в твой влазили... твой еще быстрей целерона-1000 получится :)

лучше всего это конечно на ксеонах наблюдать :)

Был когда-то язык PL1, жутко универсальный. Помер от своей универсальности, ибо не нашлось маниака, прочитавшего все его описание. Иногда жаль его(PL), местами был весьма не плох. Большие проекты надо на ADA писать ( знаю-знаю, многословно ), и те контроль, и шаблоны, и тд, и тп, и всего по-немножку. Токмо компилер правильный нужон. А C - эт вообще не ЯВУ, это SuperMacroAssembler PDP-11, по какому-то недоразумению попавший на x86.

2anonymous (*) (2002-04-26 23:25:32.23): Это надо будет еще очень постаратся потому как у меня точно не Xeon :)

О кстати просто с /Ox результат 31 секунда... Теперь вообще Селерон быстрее всего 9.7% может и комп не надо менять... :)

код запощенный лениным на athlon xp 1400MHz, на дефолтовых таймингах памяти 13секунд с копейками.

gcc 2.95.4 (debian/woody), ядро 2.4.17

хотя это конечно пузомерка... gcc толком под атлоны оптимизировать не могет, да и надо не одно число, а график от размера матрицы... да и код не помешало-бы переписать... а в целом все сходится, только к kai этот код не имеет никакого отношения, kai на сильно шаблонированном коде надо пользовать, вон АС спросите, он грамотный человек, просветит :)

На самом деле эта пузомерка мереет скорость доступа к памяти, а не математику.

Результаты:

MSVC Windows XP, ATHLON 1ghz:

код от lenina - 39 sec.

PII-350 W2K - 30секунд

PII-350 RH6.2 - 36секунд

MSVC Windows XP, ATHLON 1ghz: код от lenina - 39 sec.

ээээ а это точно атлон? thunderbird хоть? wcpuid вывод хоть запость? и чипсет какой? типа не ленись --- истина дороже...

либо с ХП и MSVC что-то не так либо как компиляли?... что-то не вяжется с моим 1.4ГГц и 13-14секунд...

конечно он память меряет, но не только, иначе получилось бы почти ровно 2 раза между PC133 и DDR266 :)

говорю, график надо строить, от размера... там должна быть забавная картинка для разницы между атлоном и P3...

эх жалко под рукой P4 нету, так, для интереса померил бы кто-нить :)

Для тех кто не видел что такое Фортран-90 - это тот же старый добрый фотран + фичи типо pointers + структуры + уже не помню че.. Короче не стоить думать что в этом фортране-90 появилось что-то такое супер-пупер.

Забавно. Особенно занятно пишет анонимус, упорно зовущий Луговского, как "А/Х". Спасибо Вам.

4Antichrist:

плюс C/C++ в настоящее время (не как языка, конечно) в его распространённости и обкатанности. Т.е. сейчас оно каждой бочке затычка, как тут уже говорили. Для половины продуктов он является нейтивным языком, ко второй половине одновременно с выпуском их самих клепают C-биндинги. Миллиард леммингов вымостили телами валяющиеся грабельки. Змея, кусающая собственный хвост, в-общем. Масса апологетов плодит ещё большую массу последователей. В-общем я конца экспансии не вижу.

сам себе анонимус.

To Antichrist: >Я вот давно и безнадёжно пытался выпытать у любителей C++ >определение ниши этого языка. Увы, так ничего и не добился, кроме >невнятного лживого бормотания про якобы абсолютную универсальность >C++ и про нежелание переучиваться самому или >переучивать дешёвых обезьянок-кодеров.

Эпиграфы: "... И поспорили Каин с Авелем, что лучше С или паскаль..." "... 100000 лемингов не могут быть неправы..." "... прибавляя малое к малому, получишь большую кучу..."

Я не собираюсь защищать равно как и осуждать C++. Для моих задач он, как бы, и не нужен. Но как Вам такой аргумент. Отсутсвие специализированной ниши для С++ рак раз и является аргументом в пользу его универсальности. А обижать Страуструпа, как-то невежливо. Хотя-бы из уважения к сединам. Сколько языков придумали, а сколько из них оказалось хороших?

Effel - хорош, да больно дорог. Насколько я понял, достойной доступной по деньгам Eiffel-системы нет. А то, что делают сейчас под видом проекта smalleiffel... Вот дойдет он до версии -20, тогда поглядим. Smalltalk - умер. Совсем.

Функциональная парадигма - хороша для своего. Да, сортировать списки - замечательно. Но каков оверхед? В конце концов, вычислительно, работы делается ровно столько же. Здесь природу не обманешь. Но, в памяти приходится держать интеллектуальный сборщик мусора, (возможно) интерпретатор байт-кода того же OCaml'a... Но, найдите мне для какого-либо функционального языка библиотеку, сравнимую с той, что делает тот-же NAG (www.nag.com)?

В нежелании переучивать кодеров есть своя серьмяга. Переучивать - дорого и без всякой надежды на успех. По себе знаю. Я сейчас читаю книжки про OCaml, просто так, в плане самообразования. Так вот, после 12 лет программирования сначала не фортране, а потом на С перейти к функциональному стилю мышления _крайне_трудно_. Если у вас есть многолетний проект на поддержке и уже написанная система классов - то вам и деваться некуда. Зачастую выходит, что время жизни проекта >> времени контракта кодировщика.

А что остается - Ada? И где она? В пентагоне и космосе?

В результате можно сделать дорого, долго, надежно и правильно, на Аде. Можно коротко, не понятно и так, что исполнителей не найдешь (lisp, ocaml и иже с ними). Можно быстро, но неэффективно (perl, python, java, VBasic).

Что остается?

Ну и я не откажу себе в удовольствии.
Система - K7-650, freebsd 4.5-S
gcc2.95.3 20010315 (штатный) - 34 c
gcc3.1 20020415 (пререлиз) - 24 c
В винду перегружаться лениво, мне и тут хорошо :-)

P.S.

GCC2.95.3 компилил с -O3 -ffast-math -malign-double и еще кучей всего
GCC 3.1 компилил с -O3 -ffast-math -malign-double -march=athlon

Так где же автор теста? Какие ключи были у gcc на самом деле? -O0?

Автор теста наверное разгоном занимался и в итоге из-за рассинхранизации частоты процессора и частоты шины/памяти большую часть тактов проц работает в хлостую.

ух :) gcc2.95.3 20010315 (штатный) - 34 c gcc3.1 20020415 (пререлиз) - 24 c неплохо :) это 3.1.x научился под атлоны точить хорошо, или весь оптимизатор поумнел? на 3.0.x как-то по моим измерениям скромнее разница была :(

а если 30 процентов так это совсем здорово :)

athlon 1.33GHz

gcc flags : -O2 -Wall -Wno-unused -funroll-loops -fstrength-reduce -fomit-frame-pointer -ffast-math -malign-functions=4 -malign-jumps=4 -malign-loops=4

icc flags : -O3

gcc 2.95.3 : 15 sec

gcc 2.96 : 19 sec

icc : 19 sec

2anonymous (*) (2002-04-27 03:11:44.666)

Дык я сам в шоке был (до сих пор в осадке пребываю), о чем и написал
в треде, где сообщалось о GCC-3.1 pre. Типа захотел проверить - а как оно?
И выпал в осадок.

2anonymous (*) (2002-04-27 03:11:44.666)

А на gcc 3.0.x по моим подсчетам разница была очень часно не в его пользу.
Эльфы-гиганты (150-200к после стрипа на прогу чуть сложнее hello-world)
Жаль, что им пока не все компилится (нечто типа гнома), но теперь я уверен,
что и это скоро исправят. gcc 3.0.x не компилил и кое-что проще.

вот она народная заинтересованность... ирси и рядом не лежал с такой флеймопроизводительностью... и главное почти все по теме :)

это вам не вгеты с павуками обсуждать :)

anonymous ([118]*) (2002-04-27 03:15:52.721) супер... становлюсь активным тестером в надежде что на одного человеко-тестера быстрей выпустят :) особенно -march=athlon мне нравится :) да и вообще на шаблонированном числодробильном коде 2.95. не лучшим образом себя вел :(

вот еще вуди к первомаю обещали... сплошной праздник :)

Тестирование C++ компиляторов — Shocking Results!

Я тут, в свете тестов lenin'а, смерти KAI и выхода новой версии ICC потестировал эти компиляторы, как раз на сильно templated числодробильном коде. Я взял простой пример LU-декомпозиции небольшой матрицы (8x8). Декомпозиция и подстановка выполняются для одной и той же матрицы в цикле по 1000000 раз. Для представления матриц и базовых операций я использовал библиотечку MTL, очень активно использующую темплэйты и заточенную на хорошо оптимизирующий компилятор. Результаты, хотя я и достаточно хорошо знаю KAI, меня вполне поразили. Итак,
-------------------------------------------------------------------
KCC 4.0f
ключи:
KCC -o klu +K3 --inline_keyword_space_time=10000 -I/home/ac/pr/cpplibs/mtl-kai -I/home/ac/pr/cpplibs/boost lu.cpp
результаты:
./klu
lu_factorize:1000000 factorizations:14.8 s
lu_substitute:1000000 substitutions:1.69 s
--------------------------------------------------------------------
GCC 3.0.3
ключи:
g++ -o glu -O2 -Wno-unused -funroll-loops -fstrength-reduce -fomit-frame-pointer -ffast-math -I/home/ac/pr/cpplibs/mtl-gcc -I/home/ac/pr/cpplibs/boost lu.cpp -DMTL_CMPLR_HAS_LIMITS
результаты:
lu_factorize:1000000 factorizations:81.2 s (!!)
lu_substitute:1000000 substitutions:6.1 s (!!)
-------------------------------------------------------------------
ICC 6.0
ключи:
icc -o ilu -O3 -ipo -unroll10 -tpp6 -xK -I/home/ac/pr/cpplibs/mtl-icc -I/home/ac/pr/cpplibs/boost lu.cpp -DMTL_CMPLR_HAS_LIMITS
результаты:
./ilu
lu_factorize:1000000 factorizations:199.84 s (!!!)
lu_substitute:1000000 substitutions:4.7 s (!!!)
--------------------------------------------------------------------
Видно, что и g++, и ICC генерируют код, уступающий по производительности _в_разы_. Более того, разрекламированный супер-пупер оптимизирующий компилятор Intel, да еще и генерирующий код, строго заточенный под платформу и использующий все ее фичи, сливает как раз на сильно templated факторизации больше чем _в_два_раза_ бесплатному g++, и в 14(!) раз KAI.
И что Intel убивает, а взамен будет впихивать нам?

конкурента купили и бросили... а сами неторопясь будут что-нить подправлять... чтоб за конкурентом гнаться не надо было... на МС насмотрелись похоже

2AC
Как бы .. это... говорили и не раз - забудь про 3.0.3, так нет, везде его за уши притянут.
Типа кинь исходник свой сильно темплатизированный, ежели не военная тайна, а там
посмотрим. Только я сегодня ужо пас. Спать пора :-))

а gcc-3.0.х во многих местах хуже/медленней код генерит даже чем 2.95. я вот и удивляюсь прыти 3.1. ветки... выкачается вот, соберется, буду мучать...

кстати, уважаемый АС не поделится ли с публикой какими-нить небольшими отдельно функционирующими кусками кода для тестирования? :) или пойдемте в девел-форум? хотя тут уже в топ10, а там за 2 дня смоет в историю :(

2anonymous: да, gcc 2.95.3 дает лучшие результаты.
----------------------------------------------------------------------
G++ 2.95.3
ключи:
/usr/bin/g++ -o glu2 -O2 -Wno-unused -funroll-loops -fstrength-reduce -fomit-frame-pointer -ffast-math -malign-functions=4 -malign-jumps=4 -malign-loops=4 -I/home/ac/pr/cpplibs/mtl-gcc -I/home/ac/pr/cpplibs/boost mtl_lu.cpp -DMTL_CMPLR_HAS_LIMITS -DAC_BOOST_LIMITS
результаты:
./glu2
lu_factorize:1000000 factorizations:32.33 s
lu_substitute:1000000 substitutions:3.52 s
---------------------------------------------------------------------
Все равно сливает KAI в два с лишним раза. Но поразительно не это -- поразительно, насколько сливает Intel.

Можно и код, только его много. И ему для компиляции потребна MTL (http://www.osl.iu.edu/research/mtl/) и boost (www.boost.org). Чтобы компилять с MTL и g++ 2.95.3, ее нужно компилять с STL или boost на предмет <limits>.
------------------------------------------------------------------
#include <iostream>
#include <vector>
#include "mtl/mtl.h"
#include "mtl/matrix.h"
#include "mtl/utils.h"
#include "boost/timer.hpp"

static const double tiny_c=1.0e-20;
static const double eps_c=1.0e-10;

struct mtraits {
typedef mtl::matrix<double,mtl::rectangle<>,mtl::dense<>,mtl::row_major&g t;::type t_matrix;
typedef mtl::dense1D<double> t_vector;
};

template<unsigned int N>
struct meta_max_choose_and_copy {
template<class t_it1,class t_it2> static inline double max_elem_and_copy(t_it1 it_curr,t_it2 it_to) {
double curr_element=*it_curr;
*it_to=curr_element;
double curr_max=fabs(curr_element);
double prev_max=meta_max_choose_and_copy<N-1>::max_elem_and_copy(++it_curr,++it_t o);
return (curr_max > prev_max ? curr_max : prev_max);
}
};

template<>
struct meta_max_choose_and_copy<0> {
template<class t_it1,class t_it2> static inline double max_elem_and_copy(t_it1 it_curr,t_it2 it_to) {
double curr_element=*it_curr;
*it_to=*it_curr;
return fabs(curr_element);
}
};

template<class t_matrix,class t_vector1,class t_vector2>
inline void lu_matrix_update(t_matrix& A,const t_vector1& X,const t_vector2& Y)
{
typename t_vector1::const_iterator x=X.begin();
typename t_vector2::const_iterator y=Y.begin();
unsigned int row_offset=0;
unsigned int col_offset=0;

typename t_matrix::iterator i=A.begin();
typename t_matrix::iterator iend=A.end();
for(;i!=iend;++i,++row_offset) {
typename t_matrix::OneD::iterator j=(*i).begin(),jend=(*i).end();
col_offset=0;
for(;j!=jend;++j,++col_offset) {
*j-= x[row_offset] * y[col_offset];
}
}
}

template<unsigned int PS>
int lu_factorize(const mtraits::t_matrix& A,mtraits::t_matrix& LU,std::vector<unsigned int>& PermutationS,mtraits::t_vector& HintScaleS)
{
unsigned int N=A.ncols();
unsigned int n_permutations=0;

mtraits::t_matrix::const_iterator it_row=A.begin();
mtraits::t_matrix::iterator it_lu_row=LU.begin();
for(unsigned int curr_row=0;curr_row<N;++curr_row,++it_row,++it_lu_row) {
HintScaleS[curr_row]=1/meta_max_choose_and_copy<PS-1>::max_elem_and_copy( (*it_row).begin(),(*it_lu_row).begin());
PermutationS[curr_row]=curr_row;
}

typedef mtl::triangle_view<mtl::columns_type<mtraits::t_matrix>::type,mtl::unit _lower>::type t_unit_lower;
typedef mtl::triangle_view<mtraits::t_matrix,mtl::unit_upper>::type t_unit_upper;
typedef mtl::triangle_view<mtl::columns_type<mtraits::t_matrix>::type,mtl::lowe r>::type t_lower;

t_lower D(mtl::columns(LU));
t_unit_lower L(mtl::columns(LU));
t_unit_upper U(LU);
mtraits::t_matrix::submatrix_type sub_LU;

//now matrix is already copied to lu, thus we can process with LU

t_lower::iterator it_col=D.begin();
t_unit_lower::iterator it_l_col=L.begin();
t_unit_upper::iterator it_u_row=U.begin();
for(unsigned int j=0;j<N;++j,++it_col,++it_l_col,++it_u_row) {
t_lower::OneD::iterator itel=(*it_col).begin(),itelend=(*it_col).end();
unsigned int imax=j;
double biggest=0.0;
double dum=0.0;
unsigned int curr_row=j;
for(;itel!=itelend;++itel,++curr_row) {
if((dum=HintScaleS[curr_row]*fabs(*itel))>=biggest) {
biggest=dum;
imax=curr_row;
}
}

if(j!=imax) {
std::swap(PermutationS[j],PermutationS[imax]);
mtl::swap(LU[j],LU[imax]);
HintScaleS[imax]=HintScaleS[j];
++n_permutations;
}

t_lower::OneD::iterator it_diag=(*it_col).begin();

if(fabs(*it_diag) < eps_c) {
*it_diag=tiny_c;
}

if(j<(N-1)) {
mtl::scale(*it_l_col,1/(*it_diag));

sub_LU=LU.sub_matrix(j+1,N,j+1,N);
lu_matrix_update(sub_LU,*it_l_col,*it_u_row);
}
}

return n_permutations;
}

void lu_substitute(const mtraits::t_matrix& LU,const std::vector<unsigned int>& PermutationS,const mtraits::t_vector& B,mtraits::t_vector& X)
{
unsigned int N=LU.ncols();

//forward substitution
mtraits::t_matrix::const_iterator it_l_row=LU.begin();
mtraits::t_matrix::const_iterator it_l_row_end=LU.end();
mtraits::t_vector::iterator it_y=X.begin();
mtraits::t_vector::iterator it_y_start=X.begin();
//two first elements are calculated using simple formulaes
*it_y = B[PermutationS[0]];
++it_l_row;
++it_y;
*it_y = B[PermutationS[1]] - *((*it_l_row).begin()) * *it_y_start;
++it_l_row;
++it_y;
for(;it_l_row!=it_l_row_end;++it_l_row,++it_y) {
unsigned int curr_row=it_l_row.index();
mtraits::t_matrix::OneD::const_iterator it_el=(*it_l_row).begin();
mtraits::t_vector::iterator it_y_el=it_y_start;
double sum=B[PermutationS[curr_row]];
for(unsigned int j=0;j<curr_row;++j,++it_el,++it_y_el) {
sum -= *it_el * *it_y_el;
}
*it_y = sum;
}

//backward substitution
mtraits::t_matrix::const_iterator it_u_row=LU.end()-1;
mtraits::t_vector::iterator it_x=X.end()-1;
mtraits::t_vector::iterator it_x_end=X.end();
//two first elements are calculated using simple formulaes
*it_x = *it_x / (*it_u_row)[N-1];
--it_u_row;
double sum = (*it_u_row)[N-1] * *it_x;
--it_x;
*it_x = (*it_x - sum) / (*it_u_row)[N-2];
--it_u_row;
for(int curr_row=it_u_row.index();curr_row>=0;--curr_row,--it_u_row) {
mtraits::t_vector::iterator it_x_el=it_x;
double sum=0.0;
for(unsigned j=curr_row+1;j<N;++j,++it_x_el) {
sum += (*it_u_row)[j] * *it_x_el;
}
--it_x;
*it_x = (*it_x - sum) / (*it_u_row)[curr_row];
}
}

int main(int argc,char* argv[])
{
const unsigned int n_tests=1000000;

double test_data[8*8]={1, 0, 0, 0, 0, 0, -145, 11,
0, 1, 0, 0, 0, 0, 55, 55,
0, 0, 1, 0, 0, 0, 145, 145,
0, 0, 0, 1, 0, 0, -55, -121,
0, 0, 0, 0, 1, 0, -11, -11,
0, 0, 0, 0, 0, 1, -121, -55,
-145, 55, 145, -55, -11, -121, 0, 0,
11, 55, 145, -121, -11, -55, 0, 0};
typedef mtl::matrix<double,mtl::rectangle<>,mtl::dense<mtl::external>,mtl ::row_major>::type t_test_matrix;
t_test_matrix tm(test_data,8,8);

mtraits::t_matrix a(8,8);
mtraits::t_matrix factorized_a(8,8);
std::vector<unsigned int> permutationS(8,0);
mtraits::t_vector hint_scaleS(8,0.0);

mtl::copy(tm,a);

//factorization
boost::timer ft;
for(unsigned int i=0;i<n_tests;++i) {
lu_factorize<8>(a,factorized_a,permutationS,hint_scaleS);
}
double felapsed=ft.elapsed();
std::cout << "lu_factorize:" << n_tests << " factorizations:" << felapsed << " s" << std::endl;


double test_right_side[8]={0.0,0.0,0.0,0.0,0.0,0.0,5060.0,5060.0};
mtraits::t_vector b(8);
mtraits::t_vector x(8);
std::copy(test_right_side,test_right_side+8,b.begin());
//substitution
boost::timer st;
for(unsigned int i=0;i<n_tests;++i) {
lu_substitute(factorized_a,permutationS,b,x);
}
double selapsed=st.elapsed();
std::cout << "lu_substitute:" << n_tests << " substitutions:" << selapsed << " s" << std::endl;

std::cout << "solution:" << std::endl;
mtl::print_vector(x);

return 0;
}
---------------------------------------------------------------------

А в чём проблема-то? Кто покупал KAI, точно так же будет покупать Intel. По-моему, не хуже стало, а лучше.

Что касается альтернатив g++ по части близости к стандарту: g++ - это один из самых аккуратных по этой части, если не самый стандартный вообще компилятор. Что касается export: export не умеет никто, и это вообще большая лужа, в которую сели изобретатели стандарта. Это жопа, в которую они сами себя загнали. Про хорошие альтернативы: судя по всему, хороший (коммерческий) компилятор - Comeau C++, www.comeaucomputing.com.

Ну и дичь развели - C++ отстой видите ли по сравнению с C :))) Это что - линуховый маразм на почве gcc? Да тот же старус вам говорит что сpp не есть 100% OOП язык. Мда.. вы что только под консоль эти убогие тесты пишите по жизни. Попробуйте наследование оконных классов в любом GUI приложении и почувствуетет разницу.. Да где угодно.. Без определения типов, наследования и перегрузки операторов imho трудно представить серьезный проект.. Нет конечно можно обойтись и без этого, но зачем же так грубо вгонять себя в каменный век.. :)

К стати, на вопрос прозвучавший в начале так и не ответили. Есть ли приличный компилятор кроме g++ под линухом (не считая сабжевого)?

Что же касается IDE - после VC++ кодировать в линухе это как пересеть с мерседеса в горбатый вонючий запор, сорри :) Покажите мне пальцем на что-то сравнимое по удобству и простоте с древним борланд турбо си для дос - чтобы работал в консоли как mc - и я буду счастлив. Это конечно, касается уже средств разработки, а не компилятора самого, но даже знаменитый кдевелоп угнетает своими уродскими неалиасными шрифтами. Люди! - в чем вы пишите реально, если не под тормознутыми иксами - неужели строгаетее в vi или том же mc и компилите в командной строке? 8[ ] Если да - это не круто - это просто убого..

>Про хорошие альтернативы: судя по всему, хороший (коммерческий) компилятор - Comeau C++, www.comeaucomputing.com.

Пока писал свой пост - прошло сообщение по теме :) Tnx

А вообще, действительно - какая разница KAI или Intel - они же собираются в своем компиляторе использовать все наработки.. значит будем юзать интел.. ;)

to anonymous (*) (2002-04-27 01:03:27.579)

Athlon _нормальный_ на 1ghz (не твиканый), wcpuid нет под рукой, XP English Corporate, MSVC 6.0, Ram ddr 256mb и даёт 39 sec, код от lenina. =)

> Такое ощущение, что тут только физики-ядерщики собрались

:-)

> ROOT/GEANT на C++ написаны и ведь прекрасно написаны (ведь никого из здесь присутствующих не тянет улучшать их.

Енто почему :) багфиксов в ROOT я немало законтрибьютил :)

ROOT меня вообще сам по себе прет. Редко когда приходится видеть такую изящную внутреннюю организацию проекта, да еще и проблемы роста учтены заранее.

С++ - действительно отстой, что там говорить.

Попрограммируйте на том же Smalltalk - и поймете, что такое ООП. А С++.. это франкенштейн.

> Что же касается IDE - после VC++ кодировать в линухе это как пересеть с мерседеса в горбатый вонючий запор, сорри.

Очередной кретин сравнивает прогу с операционкой.

> Покажите мне пальцем на что-то сравнимое по удобству и простоте с древним борланд турбо си для дос - чтобы работал в консоли как mc - и я буду счастлив

Ты просто ничего кроме турбо-оболочек в консоли не видел. Тебе подход vi или emacs кажется убогим? А ты много работал хотя бы в vi? Че-нить кроме :q! знаешь?

И чем тебе X-ы не нравятся? Уж точно не тупят как виндовый гуй, тягая за собой операционку. А под иксами я юзаю visual slick, до которому твоему vc++ как до луны по удобству и функциональности.

Люди говорят: С++ - плохо. Им отвечают - идиоты, это же гораздо лучше Си - для больших проектов, GUI, etc!

Пусть Си++ лучше Си. Но фишка-то в другом - есть ООП языки, гораздо более удобные и эффективные для применений, под которые позиционируется Си++.