Релиз языка программирования Julia 1.3

typhon на гитхаб. автор JGressier кажись. там 90й фортран с ооп.

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

?

Да/нет, это древняя, но, возможно, ещё поддерживаемая хрень. Современный Фортран может выглядеть примерно так:

module qsort_mod

implicit none

type datum
    integer :: num
    real, allocatable :: vec(:)
end type datum

type nu
    integer :: num
    real :: u
end type nu

type, extends(nu) :: nuv
    real :: v = 0.0
end type nuv

contains

recursive subroutine QRSort(series, N, pole)
!!*** Сортирует массив записей series по номеру координаты pole ***
type(datum), intent(inout) :: series(N)
integer, intent(in) :: N, pole

!! Локальные переменные
integer :: left, right
real :: random_val
real :: pivot
type (datum) :: temp
integer :: marker

!! Исполняемые операторы
left = 0
right = N + 1
! Случайный разрез:
call random_number(random_val)
pivot = series(int(random_val*real(N-1))+1)%vec(pole)
! Основной цикл сортировки:
do while (left < right)
    right = right - 1
    do while (series(right)%vec(pole) > pivot)
        right = right - 1
    enddo
    left = left + 1
    do while (series(left)%vec(pole) < pivot)
        left = left + 1
    enddo
    if (left < right) then
        temp = series(left)
        series(left) = series(right)
        series(right) = temp
    endif
enddo
! Обработка результатов:
if (left == right) then
    marker = left + 1
else
    marker = left
endif
! Рекурсивный вызов:
if (marker > 2) then
    call QRSort(series(:marker-1), marker-1, pole)
endif
if (marker < N) then
    call QRSort(series(marker:), N-marker+1, pole)
endif
end subroutine QRSort

Это типа quicksort? Я поражена.

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

В R не нравится организация текста и таблиц

Текст и таблицы делаются в формате LaTeX (ну или другого любимого языка разметки текста, TeX просто самый богатый). Тонны готовых генераторов.

ой помню был фееричный баг то ли в g95 то ли в gfortran.. элементы типов внутри if и прочих как-то дико неправильно вычислялись, allocatable когда были объявлены. Это обошлось мне в длительное и увлекательное путешествие в дебагер)

ой помню был фееричный баг то ли в g95 то ли в gfortran.. элементы типов внутри if и прочих как-то дико неправильно вычислялись, allocatable когда были объявлены. Это обошлось мне в длительное и увлекательное путешествие в дебагер)

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

Лет 10 назад его изучали в МАИ, на каких факультетах не знаю.

Это FORTRAN, а Julia сравнивают с Fortran.

Но так как ты употребляешь именно термин FORTRAN, то ты и так знаешь разницу. Более того, ты прекрасно знаешь,что приведённый тобой пример реализован на FORTRAN II.

*То есть на FORTRAN IV.

Сами создатели языка, как пишут, больше отталкивался от matlab и R.

Нет Фортрана уже почти нигде. Причина проста: реформа 90-го года была довольно успешна, но даже она не была принята до конца: остаётся много кода 77-го стандарта. За это время накопилось большое число вопросов к языку, поскольку он уже не соответствует времени, но стандарты 2003 и 2008 года не решили этих проблем толком, хотя дополнительно усложнили язык.

В Фортране по прежнему есть большое число функций для операций разной точности и необходимость явного приведения типов. Есть большие проблемы с операциями со строками и файловой системою, в том числе при чтении файлов, как текстовых, так и бинарных (всё, что есть, очень неудобно). До сих пор не доведена до конца работа по стандартизации функций автоматического поиска по массивам, в том числе номеров минимумов и максимумов.

Нет собственного менеджера пакетов и систем сборки. Интеграция с классическими библотеками типа LAPACK плохо налажена, часть библиотек даже отсутствуют в дистрибутивах, а наработки по портированию их на более дружелюбный 90/95-тый стандарт фактически оказались не у дел. Имеет место даже деградация экосистемы: если ещё десять лет назад можно было использовать LAPACK90 из репозиториев Дебиана, там же были и некоторые другие проекты вроде MINPACK, то теперь только компиляция из исходников.

Фортран медленно погибает и я не вижу пока механизмов его возрождения.

систем сборки

Есть система сборки FoBiS заточенная под проекты на фортран от автора библиотеки StringiFor (всё подумываю опакетить их для gentoo). Это кроме make, cmake, meson, waf, scons, ninja (патченный).

До сих пор не доведена до конца работа по стандартизации функций автоматического поиска по массивам, в том числе номеров минимумов и максимумов.

Чем плохи minval, maxval, where? Имеется ввиду, чтобы вернуть не само значение, а индексы? Maxloc, minloc?

часть библиотек даже отсутствуют в дистрибутивах

Это уже вопросы к ментейнерам, хотя разработчикам неплохо бы наладить опакечивания для распространённых. С другой стороны некоторые пакеты часто требуют достаточно тонкой настройки и поэтому самостоятельная сборка таких библиотек может оказаться предпочтительнее. Портирование кода библиотек на новые стандарты часто не проводится, чтобы сохранять совместимость со старыми - от этого никуда не деться :(

Но, настолько я понимаю, ты чаще имеешь дело с фортраном, чем я (я очень -очень редко). На мой взгляд разработка стандарта больше ушла в сторону поддержки HPC, в частности распараллеливания и основное внимание при его обновлении уделяется этому.

А постсоветском секторе с ним совсем не очень: чаще попадаются программы на 77 или даже 66 с нестандартными расширениями. Одно искоренение использования записи вида kind=8 кажется невозможным. Но это понятно - код написан, тщательно отлажен и работает - поддержка не требуется. Заниматься его переписыванием, смысла никакого нет.

В США и ряде Европейских стран с этим лучше, даже новые стандарты преподавали относительно недавно

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

Фортран медленно погибает и я не вижу пока механизмов его возрождения.

Даже не собирается погибать. Ибо для массивных параллельных HPC задач заменить его нечем.

А теория очередей (массового обслуживания) востребована такими «дидами»?

Это нормально. Почти всем, и уже давно нужно быстрее писать, а не быстрее считать. На написание метеорологических моделей, которые потом на кластерах сутками считаются, оно не рассчитано, а обработать результаты какого-нибудь эксперимента вполне можно и имея потерю в производительности по отношению к Фортрану в 3-5 раз. Даже Питон, который и в 30-100 раз может быть медленнее (если не суметь правильно numpy применить), часто годится.

Да врёшь ты всё и не краснеешь. Не разбираешься ведь нихрена, всё с тобой ясно «эксперт».

MIT утверждает, что Julia единственный из высокоуровневых языков динамического программирования, который может быть причислен к «петафлопному клубу». Он использовался для симуляции 188 млн звёзд, галактик и других астрономических объектов на Cori, десятом из самых мощных суперкомпьютеров в мире. В симуляции, длившейся 14,6 минут, было задействовано 650 тыс. ядер Intel Knights Landing Xeon Phi, обеспечивших производительность 1,5 петафлопс. источник

Вот, как пример:

https://www.drive2.ru/b/523622347714855958/

item%array.size возвращал size не array а item если конкретно )

double заменяет real(kind=8) со времен 77 фортрана. хотя и считается плохим тоном.

с автодополнением в ночных сборках codeblocks отлично все пишется в пару нажатий.

Интересное поведение. Но не удивительно, если честно. С записями в Фортране не всегда всё понятно, хотя казалось бы уже проще некуда, там же почти всё нельзя!

это как раз почти точно можно.

var%array%size должно отрабатывать метод size на массив

Современный Фортран может выглядеть примерно так:

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

с нелокальными переменными во вложенных функциях

Инициализировал при объявлении? Кажется, в этом случае неявно применяется параметр save и тогда переменная сохраняет значение пи при следующем входе в эту же функцию не инициализируется снова.

Я о том , что kind=8 (и не только «8») является на самом деле непереносимой конструкцией и зависит от компилятора.

с автодополнением в ночных сборках codeblocks отлично все пишется в пару нажатий.

Не понял, что пишется?

P.s. Для codeblocks ещё есть дополнительный плагин FortranProject (http://cbfortran.sourceforge.net/),но его в официальных сборках поставляют только для windows - он внешний и описание его сборки отсутствует в скриптах. Можно собрать самому как codeblocks проект или средствами autotools.

Ещё вариант - использовать сборку codebocks от автора плагина или, если повезло, пакеты codeblocks 17.12 для gentoo, alt, rosa (версия плагина 1.5). Там этот плагин поставляется, в других дистрибутивах он отсутствует.

Для Виндоус установщик codeblocks 17.12 с компилятором фортрана в комплекте лучше не использовать, там упакована сломанная версия библиотеки libgfortran 5.1, которая приводила к падению программы.

Так уж и нечем?

для массивных параллельных HPC

Уже давно используется CUDA.

Которая написана nvidia, одно из подразделений которой разрабатывает в том числе компилятор fortran и инструменты к нему для работы с cuda.

Как вариант C++, так как работа в C со строками, если они нужны, - это боль и страдание (на Фортране в гораздо меньшей степени, просто небольшие страдания без боли). Но есть одно большое «но»: чтобы не тратить время, а это может быть не один год, на переписывание и тестирование ряда библиотек, гораздо быстрее будет подключать куски кода, давно реализованные на Фортране или расширять их в некоторых случаях.

Для Си++ придётся делать свою модель многомерных массивов, чтобы можно было производить операции со срезами, и заново определять функции типа minval, который работает по срезу. Также придётся писать функции типа matmul и dot_product. Сделать это можно, но такое велосипедостроение придётся производить каждый раз. Число багов при этом будет весьма немаленьким. И вызов многих перепесанных на Си фортрановских либ типа CLAPACK придётся оборачивать.

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

Инициализировал при объявлении?

Нет, кажется. Обычно я все объявления выношу в отдельный блок. Впрочем, уже не помню.

Уже давно используется CUDA.

Сказки не рассказывайте! На неё только некоторые классы алгоритмов ложатся. А все алгоритмы с интенсивными матричными вычислениями, везде, где QR, SVD, МНК, всё это не работает, потому что блоков с двойною точностью мало, а запрашивать данные каждый раз приходится из глобальной памяти. Вот решение слабо связанных систем дифуров или теоретико-информационные меры действительно хорошо раскладываются. И то, системы с запаздыванием уже не порешаешь: при большой длине задержки и малом шаге интегрирования массив запаздывающих аргументов не помещается в локальную память — и привет.

свою модель многомерных массивов

Или попытаться использовать библиотеку blitz++. Только не знаю, насколько она всё ещё совместима с совсем новыми компиляторами. Но в Фортране то всё это уже есть и намного удобнее для использования.

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

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

Жду код в плюсах из 5 строк без использования самодельных либ на одной только STL. Ну и, конечно, со вменяемыми идентификаторами и ограничением в 80 символов на строку.

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

Пожалуй, правильное решение.

Ибо для массивных параллельных HPC задач заменить его нечем

Дедушка громко пернул.

https://trilinos.github.io/capability.html

Сортировка массивов по значению поля:

#include <algorithm>

struct S
   {
   float vec [100];
   };
  
struct cmp
   {
   int pole;
   cmp (int a) : pole (a) {}

   bool operator () (const struct S & a, const struct S & b)
      {
      return a.vec[pole] < b.vec[pole];
      } 
   };

/* Без велосипедизма и заката солнца вручную: */
void q_sort (struct S s [], int n, int pole)
   {
   std :: sort (s, s + n, cmp (pole));
   }

int main ()
   {
   }

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

Твой ход. Только покажи чего-нить реально возможное только на фортране.

std::sort - это не спортивно и работает он крайне медленно.

А, ну да, конечно. Самопальный лисапет он конечно по определению всегда метеор. Речь шла про «средствами stl» - дак получите, распишитесь.

Ну тогда ладно, обскакал дидов на хромой козе.

Беру свои слова обратно насчет std::sort. Там теперь все не просто быстро, а очень быстро.

Держи код для расчёта энтропии переноса. Это, правда, не самый интересный случай, потому что там нет срезов двумерных и трёхмерных массивов. Другого нет пока под рукою.

    function calcTEksort(xx, yy, k) result(TE)
    !! Функция расчёта энтропии переноса по k-ому соседу
    real, intent(in) :: xx(:), yy(:)
    integer, intent(in) :: k
    real :: TE, eps2, dmax
    integer :: N, j0, j1, nx, nxx1, nxy, nmax
    real, allocatable :: TEarr(:), disti(:), epsiplu(:), epsimin(:)
    type(datum), allocatable :: xyx1s(:)
    ! Функция psi вычисляется по мере необходимости,
    ! вычисленные ранее значения сохраняются в массиве, их psiNumMax
    real, allocatable :: psiFunc(:)
    N = size(xx)
    !! Начальное состояние функции:
    psiFunc = digammaN(N+1)
    !! Подготавливаем переменные:
    allocate(TEarr(N-1))
    allocate(xyx1s(N-1))
    do j0 = 1, N-1
        xyx1s(j0) = datum(j0, [xx(j0), yy(j0), xx(j0+1)])
    enddo
    !! Сортируем xyx1s по возрастанию x:
    call QRSort(xyx1s, N-1, 1)
    !! Основной цикл по всем точкам:
    allocate(epsiplu(k))
    do j0 = 1, N-1
        !! Считаем расстояние вперёд:
        if (j0 < N-k-1) then
            forall (j1 = 1:k) epsiplu(j1) = maxval(abs(xyx1s(j0)%vec - xyx1s(j0+j1)%vec))
            j1 = j0 + k + 1
            ! Вычисляем расстояния:
            disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
            nmax = maxloc(epsiplu, 1)
            dmax = maxval(disti)
            ! Пока расстояние по x меньше двух оставшихся:
            do while (epsiplu(nmax) >= disti(1))
                if (dmax < epsiplu(nmax)) then
                    epsiplu(nmax) = dmax
                    nmax = maxloc(epsiplu, 1)
                endif
                j1 = j1 + 1
                if (j1 == N) then
                    exit
                endif
                disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
                dmax = maxval(disti)
            enddo
        elseif (j0 < N-1) then
            if (allocated(epsiplu)) then
                deallocate(epsiplu)
            endif
            allocate(epsiplu(N-1-j0))
            do j1 = 1, size(epsiplu)
                epsiplu(j1) = maxval(abs(xyx1s(j0)%vec - xyx1s(j0+j1)%vec))
            enddo
        else
            epsiplu = [maxval(abs(xyx1s(j0)%vec - xyx1s(j0-1)%vec))]
        endif
        !! Считаем расстояние назад:
        if (j0 > k + 1) then
            do j1 = 1, k
                epsimin(j1) = maxval(abs(xyx1s(j0)%vec - xyx1s(j0-j1)%vec))
            enddo
            j1 = j0 - k - 1
            ! Вычисляем расстояния:
            disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
            nmax = maxloc(epsimin, 1)
            dmax = maxval(disti)
            ! Пока расстояние по x меньше двух оставшихся:
            do while (epsimin(nmax) >= disti(1))
                if (dmax < epsimin(nmax)) then
                    epsimin(nmax) = maxval(disti)
                    nmax = maxloc(epsimin, 1)
                endif
                j1 = j1 - 1
                if (j1 == 0) then
                    exit
                endif
                disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
                dmax = maxval(disti)
            enddo
        elseif (j0 > 1) then
            if (allocated(epsimin)) then
                deallocate(epsimin)
            endif
            allocate(epsimin(j0-1))
            do j1 = 1, j0-1
                epsimin(j1) = maxval(abs(xyx1s(j0)%vec - xyx1s(j0-j1)%vec))
            enddo
        else
            if (allocated(epsimin)) then
                deallocate(epsimin)
            endif
            epsimin = [maxval(abs(xyx1s(j0)%vec - xyx1s(j0+1)%vec))]
        endif
        !! Расстояние до k-го соседа:
        if (size(epsiplu) == k) then
            do j1 = 1, size(epsimin)
                epsiplu(maxloc(epsiplu)) = min(maxval(epsiplu), epsimin(j1))
            enddo
            eps2 = maxval(epsiplu)
        else
            do j1 = 1, size(epsiplu)
                epsimin(maxloc(epsimin)) = min(maxval(epsimin), epsiplu(j1))
            enddo
            eps2 = maxval(epsimin)
        endif
        !! Инициализируем счётчики:
        nx = -1;  nxy = -1;  nxx1 = -1
        !! Ищем число соседей по x, xy и xx1 вверх:
        j1 = j0
        disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
        do while (disti(1) < eps2)
            nx = nx + 1
            if (disti(2) < eps2) then
                nxy = nxy + 1
            endif
            if (disti(3) < eps2) then
                nxx1 = nxx1 + 1
            endif
            j1 = j1 + 1
            if (j1 == N) then
                exit
            endif
            disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
        enddo
        !! Ищем число соседей по x, xy и xx1 винз:
        j1 = j0
        disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
        do while (disti(1) < eps2)
            nx = nx + 1
            if (disti(2) < eps2) then
                nxy = nxy + 1
            endif
            if (disti(3) < eps2) then
                nxx1 = nxx1 + 1
            endif
            j1 = j1 - 1
            if (j1 == 0) then
                exit
            endif
            disti = abs(xyx1s(j0)%vec - xyx1s(j1)%vec)
        enddo
        !! Считаем psi:
        TEarr(j0) = psiFunc(nx) - psiFunc(nxy) - psiFunc(nxx1)
    enddo
    !! Нормируем и добавляем постоянные слагаемые:
    TE = psiFunc(k) + sum(TEarr) / (N-1)
    end function calcTEksort

Кстати, я всё ещё жду решения на 5 строк. Ведь мужик сказал — мужик сделал. Можешь фигурные скобки убрать ради экономии места.

для массивных параллельных HPC

Уже давно используется CUDA.

Напиши мне GCM на CUDA. Да, в отдельных компонентах используется, но далеко не везде можно, т.к. памяти в GPU мало.

Так уж и нечем?

Было бы чем, уже давно заменили бы.

Ээээ.... И в чём тут киллер фичи фортрана ? (т. е., то что на других яп было бы громоздко/неэффективно/неидиоматично). В этом что ли?:

    real, intent(in) :: xx(:), yy(:)
    integer, intent(in) :: k
    real :: TE, eps2, dmax
    integer :: N, j0, j1, nx, nxx1, nxy, nmax
    real, allocatable :: TEarr(:), disti(:), epsiplu(:), epsimin(:)
    type(datum), allocatable :: xyx1s(:)

xx, yy, k, TE, eps2, dmax, N, j0, j1, nx, nxx1, nxy, nmax, TEarr, disti, epsiplu, epsimin, xyx1s - в ваш говноязычок до сих пор не завезли вменяемые идентификаторы ? Такое говно в любой нетленке профессора Дебилдауна тоннами валяется. В общем говнокод.

За сим откланиваюсь.

ЗЫ. Пять строк как раз занимает именно часть отвечающая за сортировку, если ты мог заметить. Впрочем, признаю, да не пять строк в общем, но и не тот лисапет на фортране.

в ваш говноязычок до сих пор не завезли вменяемые идентификаторы ?

расскажи нам, как бы ты их обозвал

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

Разогнуться не забудь.