C++, Java и Python - кто быстрее?

Ну под явой не все ровно, но таких пиков нет.

50 73 ms
60 18 ms
70 83 ms
80 5 ms
90 8 ms
100 9 ms
110 12 ms
120 15 ms
130 19 ms
140 23 ms
150 27 ms
160 34 ms
170 40 ms
180 55 ms
190 69 ms
200 81 ms
210 94 ms
220 108 ms
230 125 ms
240 143 ms
250 171 ms
260 185 ms
270 208 ms
280 239 ms
290 262 ms
300 306 ms
310 350 ms
320 357 ms
330 435 ms
340 480 ms
350 550 ms
360 566 ms
370 689 ms
380 1285 ms
390 888 ms
400 912 ms
410 1049 ms
420 1013 ms
430 1239 ms
440 1120 ms
450 1446 ms
460 1378 ms
470 1668 ms
480 1409 ms
490 1967 ms
500 1903 ms
510 2176 ms
520 1918 ms
530 2430 ms
540 2317 ms
550 3094 ms
560 2723 ms
570 3019 ms
580 2799 ms
590 3325 ms
600 2931 ms
610 3688 ms
620 3412 ms
630 4062 ms
640 6115 ms
650 4599 ms
660 4104 ms
670 4867 ms
680 4287 ms
690 5329 ms
700 4899 ms
710 5793 ms
720 5185 ms
730 6313 ms
740 5999 ms
750 7225 ms
760 6747 ms
770 7427 ms
780 6947 ms
790 8066 ms
800 7171 ms
810 8626 ms
820 7870 ms
830 9932 ms
840 8686 ms
850 10722 ms
860 9498 ms
870 11020 ms
880 9872 ms
890 12494 ms
900 10528 ms

.. mult(*C,*A,*B); - это из какой библиотеки?
мил человек
написать такую функцию проще простого :))
моя она моя
сейчас набросал
:)

> мил человек написать такую функцию проще простого :))

А почему ВЕСЬ код не показал? Стесняешься? Как я проверю твои результаты?

>> А почему ВЕСЬ код не показал? Стесняешься? Как я проверю твои результаты?

за деньги :))))))))))))))

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

Хм. А ведь интересно. На другой машине, с Athlon 900 (до этого был P4-1700), пик в том же самом месте:

500  9.840000
510  10.700000
520  11.870000
530  12.820000
540  13.530000
550  14.530000
560  15.610000
570  16.220000
580  17.010000
590  18.210000
600  19.030000
610  21.580000
620  21.190000
630  24.020000
640  74.500000
650  25.500000
660  26.300000
670  27.570000
680  28.350000
690  30.480000
700  31.900000
710  35.440000
720  36.380000
730  38.500000
740  37.280000
750  41.370000
760  41.080000
770  43.830000
780  45.540000
790  47.340000
800  52.230000

> за деньги :))))))))))))))

> просто вы поправде используете совсем хреновый алгоритм

По приведённой Вами выше причине, уважаемый. :) Мне нет никакого смысла выкладывать тут что-то ценное. Так что Ваш голос, увы, не засчитывается. Единственное, чего Вы добились, - это продемонстрировали свою мнимую круть, да и то под вопросом - проверить-то никто не может :)

хорошо :)))
уговорили :)))


template<class _Value, int n>
class Vector
{
public:
_Value _v[n];
_Value& operator[] (int x) { return _v[x];}
const _Value& operator[] (int x) const { return _v[x];}

template<class _Filler>
void fill(_Filler f)
{
for (int i=0; i < n; ++i)
_v[i]=f();
}

};

template<class _Value, int n, int m>
class Matrix
{
public:
Vector<_Value, n> _v[m];

template<class _Filler>
void fill(_Filler f)
{
for (int i=0; i < m; ++i)
_v[i].fill(f);
}
void trans (Matrix<_Value, m,n>& to) const
{
for (int i=0; i < m; ++i) {
for (int j=0; j < n; ++j) {
to._v[j][i] = _v[i][j];
}
}
}
};

template<class _Value, int n, int m, int p>
void mult(Matrix<_Value, n,p>& result, const Matrix<_Value, n,m>& a, const Matrix<_Value, m,p>& b)
{
Matrix<_Value, p, m> bx;
b.trans(bx);
for (int i=0; i < n; ++i) {
for (int j=0; j < p; ++j) {
result._v[i][j] = 0;
for (int k=0;k<m; ++k) {
result._v[i][j] += a._v[i][k]*bx._v[j][k];
}
}
}
}

int main(int argc, char* argv[])
{
clock_t start =clock();
Matrix<double, 400,700>* A = new Matrix<double, 400,700>;
Matrix<double, 700,700>* B = new Matrix<double, 700,700>;
Matrix<double, 400,700>* C = new Matrix<double, 400,700>;
A->fill(rand);
B->fill(rand);
mult(*C,*A,*B);
clock_t end =clock();
printf("Calculation time: %f\n",(end-start)/(double)CLOCKS_PER_SEC);
return 0;
}

так что истина
осталось верной
алгоритмы а не языки решают все

> На P3-800 Python 2.4 при использовании Psyco, при n = m = p = 500 расчёт занял 122 секунды :) Ессно я не использова функции Numeric для работы с массивами.

>А что на этой машине при этих же размерах массивов говорит C?

А Си говорит 4.286 секунды :)

ХЗ, скорее всего связано с выделением памяти и костылями х86.

Вот пример на оптероне:

50 0.010000
60 0.000000
70 0.000000
80 0.010000
90 0.000000
100 0.010000
110 0.020000
120 0.010000
130 0.030000
140 0.020000
150 0.040000
160 0.040000
170 0.050000
180 0.060000
190 0.060000
200 0.080000
210 0.110000
220 0.110000
230 0.120000
240 0.140000
250 0.150000
260 0.180000
270 0.190000
280 0.220000
290 0.280000
300 0.310000
310 0.310000
320 0.480000
330 0.400000
340 0.440000
350 0.500000
360 0.540000
370 0.680000
380 0.720000
390 0.970000
400 0.780000
410 1.020000
420 1.000000
430 1.150000
440 1.030000
450 1.330000
460 1.340000
470 1.740000
480 1.740000
490 1.740000
500 1.720000
510 2.000000
520 1.770000
530 2.320000
540 2.290000
550 2.700000
560 2.810000
570 3.180000
580 3.350000
590 3.530000
600 3.160000
610 4.550000
620 3.760000
630 5.630000
640 6.070000
650 4.990000
660 4.910000
670 5.510000
680 5.270000
690 7.260000
700 6.150000
710 7.830000
720 8.840000
730 8.610000
740 7.660000
750 9.530000
760 8.250000
770 9.320000
780 10.680000
790 10.540000
800 11.840000
810 11.280000
820 11.590000
830 12.460000
840 13.690000
850 13.520000
860 13.560000
870 14.740000
880 16.500000
890 16.220000
900 15.790000

set@hoover:~> uname -a
Linux hoover 2.4.21-215-smp #1 SMP Tue Apr 27 16:26:32 UTC 2004 x86_64 x86_64 x86_64 GNU/Linux

> так что истина осталось верной алгоритмы а не языки решают все 

Пожалуй, да. Аналог на C выглядит так:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, char* argv[])
{
  double *A=NULL;
  double *B=NULL;
  double *C=NULL;
  double *BX=NULL;
  int i,j,k,n,m,p;
  clock_t start,end;

  n=1000;
  m=1000;
  p=1000;
  start=clock();
  A=(double *)malloc(n*m*sizeof(double));
  B=(double *)malloc(m*p*sizeof(double));
  C=(double *)malloc(n*p*sizeof(double));
  BX=(double *)malloc(m*p*sizeof(double));
  for (i=0;i<n;i++)
    for (j=0;j<m;j++)
      A[i*m+j]=rand();
  for (i=0;i<m;i++)
    for (j=0;j<p;j++)
      B[i*p+j]=rand();
  for (i=0;i<m;i++)
    for (j=0;j<n;j++)
      BX[j*p+i]=B[i*p+j];
  for (i=0;i<n;i++)
    for (j=0;j<p;j++) {
      C[i*p+j]=0;
      for (k=0;k<m;k++)
        C[i*p+j]+=A[i*m+k]*BX[j*p+k];
    }

  end=clock();
  printf("Calculation time: %f\n",(end-start)/(double)CLOCKS_PER_SEC);
  free(BX);
  free(C);
  free(B);
  free(A);
  return 0;
}

(я вернулся к n=m=p=1000) и считает чуть медленнее:
bash-3.00$ g++ -O2 -o mmult1 mmult1.cpp
bash-3.00$ ./mmult1
Calculation time: 17.190000
bash-3.00$ ./mmult1
Calculation time: 17.190000
bash-3.00$ ./mmult1
Calculation time: 17.190000
bash-3.00$ gcc -O2 -o mmult1 mmult1.c
bash-3.00$ ./mmult1
Calculation time: 17.210000
bash-3.00$ ./mmult1
Calculation time: 17.210000
bash-3.00$ ./mmult1
Calculation time: 17.200000 

>>(я вернулся к n=m=p=1000) и считает чуть медленнее:

медленнее скорее всего потому что ты всегда
пересчитываешь индексы
в плюсовом варианте не так

в добавок ко всему
можно согранять ссылки на текущие строки во внутреннем
цикле
за счет этого получить еще прирост скорости

Это уже мелочи, которые в данном случае существенно ничего не изменят. Такой тонкой оптимизацией имеет смысл заниматься, если оно того стОит :) Меня же интересовало другое - будет ли СУЩЕСТВЕННАЯ разница в скорости. Вывод однозначен: если разумно программить на C/C++/Java, то её в рассматриваемых случаях не будет. Ну и OK.

ok

Мне лишь кажется, что скорость выполнения подобных задач будет приблизительно одинакова. Хотя если учитывать время загрузки JVM, расходы памяти и т.д., то Java не рулит.

>Мне лишь кажется, что скорость выполнения подобных задач будет приблизительно одинакова. Хотя если учитывать время загрузки JVM, расходы памяти и т.д., то Java не рулит.

А если учитывать, что на в написанных на java программах меньше ошибок, а скорость их разработки быстрее? Это не говоря о промышленных стандартах, удобных IDE, etc...

>> C под линуксом считает 21.73 секунды, delphi - 22.61.

Очень интересно.

Я попробовал твой код (только убрал uses windows и messagebox) в linux fc3 с freepascal и borland kylix 3

Результаты: freepascal: test]# time ./test3 real 0m27.947s user 0m25.581s sys 0m0.101s kylix: test3]# time ./Project2 real 0m14.675s user 0m14.245s sys 0m0.055s

Правда, все это отдаленно имеет отношение к теме ;)

На той же машинке сишная программа от yozhhhh-а test]# time ./a.out Calculation time: 128.06

real 2m17.257s user 2m7.875s sys 0m0.202s