LINUX.ORG.RU

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

 ,


0

4

Julia — высокоуровневый высокопроизводительный свободный язык программирования с динамической типизацией, созданный для математических вычислений. Эффективен также и для написания программ общего назначения. Синтаксис Julia сходен с MATLAB с заимствованием элементов из Ruby и Lisp.

Что нового в версии 1.3:

  • возможность добавления методов в абстрактные типы;
  • поддержка Unicode 12.1.0 и возможность использования специфичных начертаний цифровых символов Unicode в идентификаторах;
  • добавлен макрос Threads.@spawn и ключевое слово Channel(f::Function, spawn=true) для организации запуска задач в любом доступном потоке. Системные операции ввода/вывода с файлами и сокетами и генератор псевдослучайных чисел адаптированы для многопоточных приложений;
  • добавлены новые библиотечные функции.

Код проекта доступен под лицензией MIT.

>>> Подробности

★★★★★

Проверено: cetjs2 ()

Ответ на: комментарий от Liz812

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

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

Vudod ★★★★★ ()
Ответ на: комментарий от skyman

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

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

psv1967 ★★★★★ ()
Ответ на: комментарий от Vudod

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

Slackware_user ★★★★★ ()
Ответ на: комментарий от Slackware_user

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

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

Vudod ★★★★★ ()
Ответ на: комментарий от Liz812

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

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

grem ★★★★★ ()
Последнее исправление: grem (всего исправлений: 2)
Ответ на: комментарий от grem

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

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

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

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

Vudod ★★★★★ ()
Ответ на: комментарий от Vudod

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

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

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

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

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

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

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

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

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

grem ★★★★★ ()
Последнее исправление: grem (всего исправлений: 4)
Ответ на: комментарий от dave

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

anonymous ()
Ответ на: комментарий от Vudod

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

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

yvv ★★☆ ()
Ответ на: комментарий от Vudod

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

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

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

mag1ck ()
Ответ на: комментарий от Slackware_user

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

Vudod ★★★★★ ()
Ответ на: комментарий от Vudod

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

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

grem ★★★★★ ()
Ответ на: комментарий от Slackware_user

Я о том , что 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, которая приводила к падению программы.

grem ★★★★★ ()
Последнее исправление: grem (всего исправлений: 4)
Ответ на: комментарий от anonymous

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

grem ★★★★★ ()
Последнее исправление: grem (всего исправлений: 1)
Ответ на: комментарий от andalevor

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

grem ★★★★★ ()
Ответ на: комментарий от grem

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

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

Vudod ★★★★★ ()
Ответ на: комментарий от anonymous

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

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

Vudod ★★★★★ ()
Ответ на: комментарий от Vudod

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

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

grem ★★★★★ ()
Последнее исправление: grem (всего исправлений: 1)
Ответ на: комментарий от Vudod

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

anonymous ()
Ответ на: комментарий от anonymous

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

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

Vudod ★★★★★ ()
Ответ на: комментарий от Vudod

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


#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 ()
   {
   }

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

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

anonymous ()
Ответ на: комментарий от anonymous

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

anonymous ()
Ответ на: комментарий от anonymous

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

    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

Vudod ★★★★★ ()
Ответ на: комментарий от anonymous

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

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

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

yvv ★★☆ ()
Ответ на: комментарий от Vudod

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

    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 - в ваш говноязычок до сих пор не завезли вменяемые идентификаторы ? Такое говно в любой нетленке профессора Дебилдауна тоннами валяется. В общем говнокод.

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

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

anonymous ()