Rust 1.34

Кто занимался отладкой нетривиальных и запутанных приложений на тех же Си++ - тот меня поймет

Только если ты имеешь в виду копание в исходниках в блокноте.

Ваще-то в Раст тоже есть классы типов...

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

Ну и хаскель не для повседневных задач.

Спасибо, оно.

Очередное трепло сломалось.

и тут-же «о нём вообще нет смысла рассуждеать»

Зачем ты врёшь, трепло нелепое? Я сообщил почему он говно, но так же сообщил - что о нём вообще нет смысла рассуждать и причины тому просты. На нём написаны одни хелворды/перепаста, а пишут на нём одни фантики.

Из этого следует то, что а) фанатики будут жрать любое дерьмо и никогда даже не подумают о какой-то мало-мальски объективной оценке. б) говно может проявить реальное применение, но его нет.

Давай попроще. Есть некий условный Вася. Пусть Вася будет столяром. И вот этот Вася, сидя в яме, говорит «мои инструменты хороши», но его инструменты - это кривой молоток, отвёртка вместо стамески и кухонная тёрка вместо рубанка. Вася нищий, убогий и безрукий. Но Вася никогда не признает и будет всем и всегда доказывать, что его инструмент идеал. И Васю в ином ты не убедишь.

И казалось бы - говяным инструментов ничего нельзя сделано(нормально), но нет. Вася живёт в своём мире. Он собирает алкашам шкафы из дерьма и кое как. Он таким же алкашам сколачивает забор.

И потом этот герой прибегает, не имея возможно ответить и начинает нести шаблонную херню, которое он услышал в школе:

АААА, «сперва добейся» - это плохо. Как ты можешь рассуждать о «ровных шкафах не из говна».

Какая мимимишная няшечка, какой розовощёкий засранчик: ну давай сюда свои тысячелетние нетленки.

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

Я тебе могу назвать такие проекты. linux, llvm, chromium - дальше сам. Давай, оправдывайся.

Фу!

Вас там таких аж четверо, против 245. Как обычно с лисперами :D

Главное чтобы implicit conversion не было, а то получим адок уровня C++.

Главное чтобы implicit conversion не было, а то получим адок уровня C++.

Во-первых это никакой не implicit, а во-вторых не волнуйся - это сложно. К тому же - обоснования адка в студию. Или ты балабол?

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

еще один клонун, давай уже покажи что ты написал на своем расте

«Мы не смогли, не осилил, сделали говно» - нет, по мнению адептов всё не так. Воняет говном - это достоинство. Её(вони) отсутвие говорит об ошибке в проектировании.

Кто занимался отладкой нетривиальных и запутанных приложений на тех же Си++ - тот меня поймет.

Покажи эти приложения? А так же покажи нетривиальные, запутанные приложения на расте. Ой, методичка сломалась? Всё так круто, а приложений за 10лет не появилось.

Ссылка в профиле.

Очередное трепло сломалось.

Ах ты ж сладенький мой, опять выплюнул говно соску и начал орать....

Я сообщил почему он говно, но так же сообщил - что о нём вообще нет смысла рассуждать и причины тому просты.

Ты себя слышишь? «Я тут хуйни нагородил, но смысла в этом нет...» Чукча писатель, чукча не читатель?

Из этого следует...

...что ты продолжаешь нести пургу без смысла. Не надоело?

ты первое должно показать

Аллё, ты адекватен? Я тебе что-то должен? Ты порешь херню, а на замечание «на каком основании?» лепечешь детское «нет ты!» Дитятко, перестань метать своё добро из подгузника, возле тебя и так находиться невозможно - одно раскиданное тобой говно вокруг...

я вообще ничего не должен показывать

если «спердобейся» не аргумент, то какого рожна ты требуешь здесь и сейчас нетленок на расте? Двойные стандарты? Хотя о чём я, какие стандарты у такого неадеквата без царя в голове...

Я тебе могу назвать такие проекты. linux, llvm, chromium - дальше сам.

как минимум ник в придачу, чтоб отследить твой вклад, а то на заборе тоже много чего написано...

Давай, оправдывайся.

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

попытка тебя хоть немного в чувство привести

Первый раз царя видишь?

Ах ты ж сладенький мой, опять выплюнул говно соску и начал орать....

Это так мило, когда малолетка пытается что-то там кукарекать про «мой», «„соску“ и прочее. Нелепый клоун.

Ты себя слышишь? «Я тут хуйни нагородил, но смысла в этом нет...» Чукча писатель, чукча не читатель?

Ну дак беги обосновывать на „нагородил“? Или что, своё место осознаёшь, но продолжаешь играть в идиота? Пока ты не обосновал свои потуги - они ничего не значат и меня не волнуют.

...что ты продолжаешь нести пургу без смысла. Не надоело?

...что ты продолжаешь нести пургу без смысла. Не надоело?

Аллё, ты адекватен? Я тебе что-то должен? Ты порешь херню, а на замечание «на каком основании?» лепечешь детское «нет ты!» Дитятко, перестань метать своё добро из подгузника, возле тебя и так находиться невозможно - одно раскиданное тобой говно вокруг...

Аллё, ты адекватен? Я тебе что-то должен? Ты порешь херню, а на замечание «на каком основании?» лепечешь детское «нет ты!» Дитятко, перестань метать своё добро из подгузника, возле тебя и так находиться невозможно - одно раскиданное тобой говно вокруг...

Кстати, убогий. Я понимаю, что ты пытаешься подражать мне, но всё же. Где вопросы на тему „основания“ и чего основания ты пытался получить?

если «спердобейся» не аргумент, то какого рожна ты требуешь здесь и сейчас нетленок на расте? Двойные стандарты? Хотя о чём я, какие стандарты у такого неадеквата без царя в голове...

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

Тебе уже сказали. Возможности языка и тех, кто пишут на языке - определяют то, что они написали.

как минимум ник в придачу, чтоб отследить твой вклад, а то на заборе тоже много чего написано...

Бегом побежал обосновывать а) то, что я тебе что-то там должен доказывать. б) что я вообще должен в это делать какой-то вклад?

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

До того момента пока ты не обоснуешь необходимости моей причастности к линуксу для того, чтобы он считался за аргумент к моим тезисам - ты просто трепло, малоразвитое убогое трепло, повторяющие за кем-то херню.

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

Опять очередной балабол обосрался. Да, ты утверждал, клоун. Ты пытался оспорить оппонировать мне, отрицая мои суждения, опровергая(в своих фантазиях) их. Ты обязан за это оправдываться.

Зачем тут царь? И где анон с задачками по расту?

Он понял, что адепты раста, даже заплутав в двух соснах любимого языка, не готовы согласиться с тем, что раст неоправданно сложен и накладывает существенные ограничения, увеличивает время разработки и пр., при этом не давая существенного профита.

Раз уж тема про Rust, а ты на нём пишешь, то заодно спрошу у знающего человека, как будет выглядеть на Rust вот этот код?

!-------------------------------------------------------------------------------
! Программа представляет собой немного модифицированный пример из книги
! Артёмова И.Л. "Fortran. Основы программирования. 2007"
! Внесены изменения:
! 1. В цикле вычисления TNEW внешний цикл по i перенесён внутрь цикла по j,
! для ускорения выполнения кода, т.к. первый индекс меняется быстрее.
! 2. Добавлен (закомментирован) блок вывода координат и значений температуры.
! 3. Добавлено использование динамического массива для значений температуры.
!-------------------------------------------------------------------------------
! Для сборки программы использовалась команда 
! gfortran -std=f95 -Ofast -ffast-math stat_temp_fld.f95
!-------------------------------------------------------------------------------

! Mi, Mj - размеры сетки
! TW, TS, TN, TE - температура на границах
! T - массив для хранения значений сеточной функции T(x,y)
! TNEW - значение температуры на k+1 итерации
! TZV - значение, расчитанное по методу Гаусса-Зейдлеля
! delta - ошибка вычислений (контроль сходимости)
! osst - величина из разностного уравнения
! relax - коэффициент релаксации, 1.0 <= relax < 2.0
! eps - допустимая ошибка численного расчёта
! X0, Y0, dx, dy - границы области, шаги интегрирования
! i, j - переменные цикла
! it - текущая итерация
! res - дополнительная переменна

program stat_temp_fld

    implicit none

    integer, parameter :: Mi = 501, Mj = 251
    real(8), parameter :: TW = 0.0, TS = 0.0, TN = 400.0, TE = 400.0
    real(8), dimension(:, :), allocatable :: T 
    real(8) :: TNEW, TZV, delta, ostt
    real(8), parameter :: relax = 1.9, eps = 0.000001
    real(8) :: X0 = 2.0, Y0 = 1.0, dx, dy
    integer :: i, j, it

    allocate(T(Mi, Mj))

    write (*, *) "# Solving numerical Laplace equation. Please wait ..."
    dx = X0/(Mi - 1); dy = Y0/(Mj -1)  ! Построение расчётной сетки
    ostt = 2.0/dx**2 + 2.0/dy**2

    T = 0.0
    !! Ось X направлена вдоль i, Y - вдоль j,
    !! так, что (0, 0) соответствует элементу массива T(1, 1).
    T(1,:)=TW; T(Mi,:)=TE; T(:,1)=TS; T(:,Mj)=TN ! Граничные условия 1-го рода

    delta = 1.0; it = 1

    do while (delta > eps)
        delta = 0.0
        do j = 2,Mj-1  ! Расчёт поля температур во внутренних точках (j вынесено наружу для ускорения счёта)
            do i = 2,Mi-1
                TZV = ((T(i+1,j) + T(i-1,j))/dx**2 + (T(i,j+1)+T(i,j-1))/dy**2)/ostt            
                TNEW = TZV*relax + (1.0 - relax)*T(i, j)
                delta = delta + abs(T(i, j) - TNEW)
                T(i, j) = TNEW
            end do
        end do

        delta = delta/Mi/Mj
        it = it + 1

        if (mod(it, 200)==0) write(*, '(A10, I6,  A10, F8.6)') "# iterat = ", it, "oxt = ", delta
    end do

    write (*, '(A10, I6)') "# it_fin = ", it

    ! do j=1,Mj
      ! do i=1,Mi
        ! write (*, '(F8.2 F8.2 F8.2)') X0*(i-1)/(Mi - 1), Y0*(j-1)/(Mj - 1), T(i,j)
      ! end do
      ! print *, " "
    ! end do

end program stat_temp_fld

set pm3d
set hidden3d
set palette rgb 7,5,15
splot "p_test.txt" using 1:2:3 with lines
set pm3d at b
set pm3d map

Царь приди и порядок наведи. Поясни пацпанам за Rust.

странные у тебя просьбы. Перепиши что-ли на нормальный язык, который понимает весь мир - это си. Кому охота разбираться с этим неведомым нечто.

А есть пример вывода? Или он сильно большой?

Я фортран не знаю, поэтому многие конструкции мне не понятны.

1. write (*, *) - что это за сова?
2. T(1,:)=TW; - что это за магия?
3. T(i, j) - это типа двумерный массив? Я привык, что T - это шаблонный тип.

Вот и выросло поколение, которое простую запись формулы понять не может. Чего тут непонятно то? Ну лови на C++

/*
    ! Для сборки программы использовалась команда 
    ! g++ -Ofast -ffast-math main.cpp
*/

/*
    ! Mi, Mj - размеры сетки
    ! TW, TS, TN, TE - температура на границах
    ! T - массив для хранения значений сеточной функции T(x,y)
    ! TNEW - значение температуры на k+1 итерации
    ! TZV - значение, расчитанное по методу Гаусса-Зейдлеля
    ! delta - ошибка вычислений (контроль сходимости)
    ! osst - величина из разностного уравнения
    ! relax - коэффициент релаксации, 1.0 <= relax < 2.0
    ! eps - допустимая ошибка численного расчёта
    ! X0, Y0, dx, dy - границы области, шаги интегрирования
    ! i, j - переменные цикла
    ! it - текущая итерация
    ! res - дополнительная переменна
*/

#include <iostream>
#include <cmath>
#include <cstdio>

int main () {
    
    const int Mi = 501, Mj = 251;
    const double TW = 0.0, TN = 0.0, TS = 400.0, TE = 400.0;
    double* pT = new double[Mi*Mj];
    double TNEW, TZV, delta, ostt;
    const double relax = 1.9, eps = 0.000001;
    double X0 = 2.0, Y0 = 1.0, dx, dy;
    int it;
    
    
    std::cout << "# Solving numerical Laplace equation. Please wait ..." << std::endl;
    dx = X0/((double)(Mi - 1)); dy = Y0/((double)(Mj -1));  // Creating a Mesh
    ostt = 2.0/(dx*dx) + 2.0/(dy*dy);
    
    for(int i = 0; i < Mi; ++i)
        for(int j = 0; j < Mj; ++j)
            pT[Mj*i+j] = 0.0;
    
    // Граничные условия 1-го рода
    // Ось X направлена вдоль i, Y - вдоль j,
    for(int j = 0; j < Mj; ++j) {
        pT[Mj*0+j]=TW;
        pT[Mj*(Mi-1)+j]=TE;
    }
    
    for(int i = 0; i < Mi; ++i) {
        pT[Mj*i+(Mj-1)]=TS;
        pT[Mj*i+0]=TN;
    }
    
    
    delta = 1.0; it = 1;
    
    while (delta > eps) {
        delta = 0.0;
        
        for(int i = 1; i < Mi-1; ++i) {
            for(int j = 1; j < Mj-1; ++j) {
                TZV = ((pT[Mj*(i+1)+j] + pT[Mj*(i-1)+j])/(dx*dx) + (pT[Mj*i+(j+1)] + pT[Mj*i+(j-1)])/(dy*dy))/ostt;
                TNEW = TZV*relax + (1.0 - relax)*pT[Mj*i+j];
                delta = delta + std::fabs(pT[Mj*i+j] - TNEW);
                pT[Mj*i+j] = TNEW;
            }
        }
        
        delta = delta/((double)(Mi*Mj));
        it += 1;
        
        if ((it%200)==0) {
            std::cout << "iterat = " << it << "  oxt = " << delta << std::endl;
        }
    }
    
    std::cout << "it_fin = " << it << std::endl;
    
    //    for(int i = 0; i < Mi; ++i) {
    //        for(int j = 0; j < Mj; ++j) {
    //            //std::cout <<  X0*i/(Mi - 1) << "  " << Y0*j/(Mj - 1) << "  " << pT[Mj*i+j] << std::endl;
    //            printf("%8.2f%8.2f%8.2f\n", X0*i/(Mi - 1),  Y0*j/(Mj - 1), pT[Mj*i+j]);
    //        }  
    //    }
    
    delete [] pT;
    
    return 0;
}

Теперь-то всё стало понятно. И это С, а не С++.

простую запись формулы понять не может

Лично мне непонятна была магия самого фортрана.

Дальше тот же пример на C++

1. write (*, *) - вывод в формате по умолчанию в устройство по умолчанию (терминал);
2. T(1,:)=TW; - инициализация всех элементов первого столбца массива (фактически срез массива);
3. T(i,j) - да, двумерный массив.

И обход массива в фортране по столбцу идёт, а не по строке.

а как же std::cout и new/delete?
std::vector или array можно запихнуть. Это не тот пример, чтобы сильно извращаться.

Вот и выросло поколение, которое простую запись формулы понять не может. Чего тут непонятно то? Ну лови на C++

Всё. Ни я, ни адепты раста не понимают твой язык. Все знают си и понимают си, хотя-бы на базовом уровне. Я же о тебе забочусь, чтобы тебе дали ответ.

И это С, а не С++.

Это C++, просто очень плохой.

Надеюсь это говно хоть тестами покрыто на проде.

Дальше тот же пример на C++

Вот что всегда поражало в программирующих математиках, так это их терпение в повторении одного и того же. Не надоедает вот это вот все: pT[Mj*(i+1)+j] + pT[Mj*(i-1)+j]

А ведь ничего же сложного...

#include <iostream>
#include <cmath>
#include <cstdio>
#include <vector>

int main () {
    
    constexpr int Mi = 501, Mj = 251;
    constexpr double TW = 0.0, TN = 0.0, TS = 400.0, TE = 400.0;
    std::vector<double> T(Mi*Mj, 0.0);
    double TNEW, TZV, delta, ostt;
    constexpr double relax = 1.9, eps = 0.000001;
    double X0 = 2.0, Y0 = 1.0, dx, dy;
    int it;
    
    const auto pT = [&T](auto i, auto j) -> auto & { return T[Mj*i+j]; };
    
    std::cout << "# Solving numerical Laplace equation. Please wait ..." << std::endl;
    dx = X0/((double)(Mi - 1)); dy = Y0/((double)(Mj -1));  // Creating a Mesh
    ostt = 2.0/(dx*dx) + 2.0/(dy*dy);
    
    for(int j = 0; j < Mj; ++j) {
        pT(0,j)=TW;
        pT(Mi-1,j)=TE;
    }
    
    for(int i = 0; i < Mi; ++i) {
        pT(i,(Mj-1))=TS;
        pT(i,0)=TN;
    }
    
    delta = 1.0; it = 1;
    
    while (delta > eps) {
        delta = 0.0;
        
        for(int i = 1; i < Mi-1; ++i) {
            for(int j = 1; j < Mj-1; ++j) {
                TZV = ((pT(i+1,j) + pT(i-1,j))/(dx*dx) + (pT(i,j+1) + pT(i,j-1))/(dy*dy))/ostt;
                TNEW = TZV*relax + (1.0 - relax)*pT(i,j);
                delta = delta + std::fabs(pT(i,j) - TNEW);
                pT(i,j) = TNEW;
            }
        }
        
        delta = delta/((double)(Mi*Mj));
        it += 1;
        
        if ((it%200)==0) {
            std::cout << "iterat = " << it << "  oxt = " << delta << std::endl;
        }
    }
    
    std::cout << "it_fin = " << it << std::endl;
    
    return 0;
}

Нет. Потому что незачем.

Спасибо. Запомню.
С вектором то понятно (как вариант std::array<double, Mi*Mj> T; можно запихнуть), а вот
const auto pT = [&T](auto i, auto j) -> auto & { return T[Mj*i+j]; };
уже интереснее.

А инициализация вектора нулями в таком виде это тоже фича C++14?


Просто хотелось увидеть как выглядит какая-нибудь реализация на Rust.

RazrFalcon

А есть пример вывода? Или он сильно большой?

Сойтись должно за 6650 итераций, вывод примерно такой:

# Solving numerical Laplace equation. Please wait ...
iterat = 200  oxt = 0.223673
iterat = 400  oxt = 0.135283
iterat = 600  oxt = 0.0917682
iterat = 800  oxt = 0.0627636
iterat = 1000  oxt = 0.0429629
...
iterat = 6000  oxt = 3.41943e-06
iterat = 6200  oxt = 2.34212e-06
iterat = 6400  oxt = 1.60422e-06
iterat = 6600  oxt = 1.09879e-06
it_fin = 6650

А инициализация вектора нулями в таком виде это тоже фича C++14?

Если не ошибаюсь, конструктор у std::vector с параметрами size и initial присутствует с C++98.

Как бы решил я:

use ndarray::Array2;

// const COLUMNS: usize = 501;

fn main() {
    // Наверное лучше глобальными константами, как показано выше.
    // Но тогда нужно тип указывать.
    // Зависит от того, что нужно.
    let columns = 501;
    let rows = 251;

    let west = 0.0;
    let north = 0.0;
    let south = 400.0;
    let east = 400.0;

    let relax = 1.9;
    let eps = 0.000001;
    let x0 = 2.0;
    let y0 = 1.0;

    println!("# Solving numerical Laplace equation. Please wait...");

    // Нет смысла перемножать каждый раз. А что бы не засорять локальное пространство,
    // расчёт dx и dy вынесем в отдельный блок.
    let (dx2, dy2) = {
        let dx = x0 / (columns - 1) as f64;
        let dy = y0 / (rows - 1) as f64;
        (dx * dx, dy * dy)
    };

    let ostt = 2.0 / dx2 + 2.0 / dy2;

    let mut matrix = Array2::<f64>::zeros((columns, rows));

    // Возможно есть готовые методы, но я с ndarray не работал.
    for v in matrix.row_mut(0) {
        *v = north;
    }

    for v in matrix.row_mut(columns - 1) {
        *v = south;
    }

    for v in matrix.column_mut(0) {
        *v = west;
    }

    for v in matrix.column_mut(rows - 1) {
        *v = east;
    }

    // Выводит матрицу таблицой.
    // println!("{}", matrix);

    let mut delta = 1.0;
    let mut it = 1;
    while delta > eps {
        delta = 0.0;

        for c in 1..(columns-1) {
            for r in 1..(rows-1) {
                let left    = matrix[[c - 1, r    ]];
                let right   = matrix[[c + 1, r    ]];
                let top     = matrix[[c,     r - 1]];
                let bottom  = matrix[[c,     r + 1]];
                let center  = matrix[[c,     r    ]];

                let tzv = ((right + left) / dx2 + (bottom + top) / dy2) / ostt;
                let result = tzv * relax + (1.0 - relax) * center;
                delta = delta + (center - result).abs();
                matrix[[c, r]] = result;
            }
        }

        delta = delta / (columns * rows) as f64;
        it += 1;

        if it % 200 == 0 {
            println!("iterat = {} oxt = {}", it, delta);
        }
    }

    println!("it_fin = {}", it);
}

Производительность:

• C++ - 0:12.59 (тут я тоже вынес перемножение dx/dy из цикла)
• Rust - 0:14.84

Вот что всегда поражало в программирующих математиках, так это их терпение в повторении одного и того же. Не надоедает вот это вот все: pT[Mj*(i+1)+j] + pT[Mj*(i-1)+j]

А ведь ничего же сложного...

Да, прикол обычно в том (не в данном случае, конечно), что если код написан давно (10-20 лет назад), то он протестирован и его трогать не будут, т.к. это трата времени, учитывая, что не то что за переписывание, но и за сам код никто не платит и не платил на самом деле.

Далее начинаются следующие приколы:
- Если код пишет хотя бы 2 человека, то у одного обязательно будет версия icc, msvs, c++ builder, pgi (нужное подчеркнуть), которая даже c++11 не поддерживает.
- Даже если в один прекрасный момент у всех окажутся новые версии компиляторов, всё захотят начать использовать новые фичи языка, то, в не менее прекрасный момент выяснится, что в рамках очередного проекта нужно будет собрать код на каком-нибудь удалённом компе, с использованием именно того окружения, которое там стоит. И при этом там будет GCC 4.7.2, не новее.

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

C++ - 0:12.59 (тут я тоже вынес перемножение dx/dy из цикла)
Rust - 0:14.84

Нет, ну обосраться на хелворде - это нужно уметь. Причём имея халявный llvm, который из говна может собрать конфетку. Уровень убогости недоязычка просто поражает.

// Нет смысла перемножать каждый раз. А что бы не засорять локальное пространство,
// расчёт dx и dy вынесем в отдельный блок.

Это само собой, если они постоянны и сетка равномерная. Но дело в том, что какая-то старая версия icc этот кусок не оптимизировала, а в новых версиях gcc он никак не влиял, видимо, за счёт оптимизации компилятором.

Спасибо.

Производительность:

Какие ключи сборки были?
Это с выводом значений температуры в ячейках? Если без,то многовато в обоих случаях. Какой проц? У меня на старом core i3 550 3.2GHz секунд 5.5 занимает.

Чтобы показать ущербность языков без нормальных систем управления зависимостями. Ну и удобно - велосипеды писать не надо, хэдер-онли библиотеки копипастить тоже не надо.

Какие ключи сборки были?

clang++ -O2

С -ffast-math: 0:02.74

Какой проц?

i5-3570k.

Это с выводом значений температуры в ячейках?

Без.

Что характерно, ndarray фактически бесплатен по размеру бинаря:

File  .text     Size Name
4.6%  74.1% 111.1KiB std
1.5%  23.6%  35.4KiB [Unknown]
0.1%   1.8%   2.7KiB ftest
0.0%   0.5%     748B ndarray
6.2% 100.0% 149.9KiB .text section size

С -ffast-math: 0:02.74

Вот это больше похоже на правду, учитывая, что clang этот код лучше оптимизирует чем gcc.

Чтобы показать ущербность языков без нормальных систем управления зависимостями.

Нет, потому что ламерки знают, что иначе их ждёт полное разочарование.

К тому же, твоя методичка говно. Во-первых в любом недоязычка есть система управления зависимостями. Это мусор уровня начальной школы.

Во-вторых нормальному языку это ненужно - нормальный код на нормальном языке не имеет ни рантайм, ни линктайм зависимостей.

Ну и удобно - велосипеды писать не надо, хэдер-онли библиотеки копипастить тоже не надо.

Эти нелепые оправдания. В целом можно читать как «моя недоязычок говно - я ничего не могу написать - поэтому я бегу гуглить и искать говно, которое высрал кто-то другой». Сильно.

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

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

У Си версии та же производительность. Смысл?

Я бы вынес тут части вот этой красоты в переменные

TZV = ((pT[Mj*(i+1)+j] + pT[Mj*(i-1)+j])/(dx*dx) + (pT[Mj*i+(j+1)] + pT[Mj*i+(j-1)])/(dy*dy))/ostt;

Уж очень оно тяжело читается с этими ij]M1[()

Выше подсказали вариант с лямбда-функцией, если это она.

Только я никак не соображу, какой здесь тип на самом деле должен быть const auto pT вместо auto.

какой здесь тип на самом деле должен быть const auto pT вместо auto

Именно auto, это же лямбда.

pT — это объект, содержащий лямбду. Тип этой лямбды знает только компилятор, поэтому разработчик должен писать auto для автоматического вывода этого самого типа. Поэтому в первом приближении получается auto pT = ....

Далее, значение pT в принципе меняться не должно. Поэтому, по правилам хорошего тона (и чтобы у компилятора было больше подсказок для оптимизации), явно говорим о том, что pT не изменится после определения. Отсюда и результирующая запись const auto pT = ....

Это C++ головного мозга:

const auto pT = [&T](auto i, auto j) -> auto & { return T[Mj*i+j]; };

Это препроцессор головного мозга:

#define pT(i,j) T[Mj*i+j]

Выбирайте, какая болезнь вам больше нравиться

Это препроцессор головного мозга:

#define pT(i,j) T[Mj*i+j]

Анонимные надмозги во всей красе. Матчасть сперва выучите, потом в ослоумии испражняйтесь.

#define pT(i,j) T[Mj*(i)+(j)]

Спасибо. Вот в рамках C++98 и С++03 я когда-то (хотя это вообще был именно сишный код) использовал макрос, как указано anonymous. А скобки да, вечно про них все забывают :)