Implementation of hyperbolic complex numbers in Julia language

Full Text

1. Introduction The Julia programming language [1, 2] is a promising language for scientific computing. At the moment, the Julia language has reached a stable state. By design, Julia solves the problem of two languages. This problem lies in the fact that for rapid prototyping, data processing and visualization, an interpreted dynamic language or a mathematical package (Python, Matlab, etc.) is used, and for intensive numerical calculations, the program has to be rewritten in a compiled language with static typing (C/ C++, Fortran). An illustration of this problem can be seen in Python, which has gained wide popularity as an interface language-glue. Numerous wrapper libraries were written on it, which used Python code to call C/C++ and Fortran functions from precompiled libraries. For example, the well-known library NumPy [3] consists of 51% C code and only 47% Python code (the remaining percentages are divided between C++, Fortran, JavaScript and Unix shell). The Julia language combines the flexibility of dynamically typed interpreted languages with the performance of statically typed compiled languages. The basic part of the Julia language is very similar to other scientific programming languages, so it does not cause difficulties in mastering. However, Julia’s core is built around the concept of multiple dispatch [4], which is rare in other languages. It is in this mechanism that the essential difference of Julia from other languages lies, and its understanding is essential for the full use of all the advantages of Julia. In the article, the authors paid great attention to illustrating the mechanism of multiple dispatch and other mechanisms that are closely related to it. In the first part of the article, we give the necessary definitions and illustrate the concept of multiple dispatch with simple examples that allow you to understand the syntax associated with this part of the language and capture the essence of this approach. In the second part, we give an example of the implementation of hyperbolic complex numbers in the Julia language. This example allows you to touch not only multiple dispatch, but also the type casting mechanism, the abstract type hierarchy, overloading arithmetic operators, and specifying user-defined data types. 2. Multiple dispatch 2.1. Common definitions Dynamic dispatch is a mechanism that allows you to choose which of the many implementations of a polymorphic function (or operator) should be called in a given case [5]. In this case, the choice of one or another implementation is carried out at the stage of program execution. Multiple dispatch is based on dynamic dispatch. In this case, the choice of implementation of a polymorphic function is made based on the type, number, and order of the function’s arguments. This is how runtime polymorphic dispatch is implemented [6, 7]. Note also that in addition to the term multiple dispatch, the term multimethod is also used. The mechanism of multiple dispatch is similar to the mechanism of overloading functions and operators, implemented, for example, in the C++ language. Function overloading, however, is done exclusively at compile time, while multiple dispatch should work at runtime as well (runtime polymorphism). 2.2. Multiple dispatch in Julia To illustrate the mechanism of multiple dispatch, we will give the following code example in the Julia language: function f(x, y) println("Generic implementation") return x + y end function f(x) println("For single argument") return x end function f(x::Integer, y::Integer) println("Implementation for integers") return x + y end function f(x::String, y::String) println("Implementation for strings") return x * " " * y end function f(x::Tuple{Int, Int}, y::Tuple{Int, Int}) println("Implementation for tuples of two integer elements") return (x[1], x[2], y[1], y[2]) end In this example, we have created five implementations of the

About the authors

Anna V. Korolkova

Peoples’ Friendship University of Russia (RUDN University)

Email: korolkova-av@rudn.ru
ORCID iD: 0000-0001-7141-7610

Docent, Candidate of Sciences in Physics and Mathematics, Associate Professor of Department of Applied Probability and Informatics

6, Miklukho-Maklaya St., Moscow, 117198, Russian Federation

Migran N. Gevorkyan

Peoples’ Friendship University of Russia (RUDN University)

Email: gevorkyan-mn@rudn.ru
ORCID iD: 0000-0002-4834-4895

Candidate of Sciences in Physics and Mathematics, Assistant Professor of Department of Applied Probability and Informatics

6, Miklukho-Maklaya St., Moscow, 117198, Russian Federation

Dmitry S. Kulyabov

Peoples’ Friendship University of Russia (RUDN University); Joint Institute for Nuclear Research

Author for correspondence.
Email: kulyabov-ds@rudn.ru
ORCID iD: 0000-0002-0877-7063

Professor, Doctor of Sciences in Physics and Mathematics, Professor at the Department of Applied Probability and Informatics

6, Miklukho-Maklaya St., Moscow, 117198, Russian Federation; 6, Joliot-Curie St., Dubna, Moscow Region, 141980, Russian Federation

References