Representation of grossone-based arithmetic in simulink for scientific computing

Numerical computing is a key part of the traditional computer architecture. Almost all traditional computers implement the IEEE 754-1985 binary floating point standard to represent and work with numbers. The architectural limitations of traditional computers make impossible to work with infinite and infinitesimal quantities numerically. This paper is dedicated to the Infinity Computer, a new kind of a supercomputer that allows one to perform numerical computations with finite, infinite, and infinitesimal numbers. The already available software simulator of the Infinity Computer is used in different research domains for solving important real-world problems, where precision represents a key aspect. However, the software simulator is not suitable for solving problems in control theory and dynamics, where visual programming tools like Simulink are used frequently. In this context, the paper presents an innovative solution that allows one to use the Infinity Computer arithmetic within the Simulink environment. It is shown that the proposed solution is user-friendly, general purpose, and domain independent.

the infinite representation of a number in the finite computer memory [see Sergeyev (2017)].
The Infinity Computer is a new kind of a supercomputer that allows one to work numerically with finite, infinite, and infinitesimal numbers. The software simulator of the Infinity Computer was written in the C++ language and is used in several research domains, especially in mathematics and physics to solve difficult real-life problems [see Sergeyev (2017) and references given therein]. Nevertheless, the software simulator is not yet sufficiently mature to address problems in control theory and dynamic systems due to implementative issues related to extending and integrating the C++ source code of the arithmetical and elementary operations in wellknown environments like Simulink.
To overcome these issues, the paper presents an innovative solution that allows one to use the Infinity Computer arithmetic within the Simulink environment, which is a wellknown graphical programming environment, developed by MathWorks, for studying and analyzing dynamic systems [see ]. Simulink provides a graphical block diagramming notation tightly integrated with the Matlab environment. Simulink is widely used in the modeling and simulation domain, including distributed simulation, Co-Simulation of Cyber-Physical Systems (CPS) and Model-Based design [see Bocciarelli et al. (2018);D'Ambrogio et al. (2019); Möller et al. (2016bMöller et al. ( , 2017].
The rest of the paper is organized as follows. Section 2 provides an introduction to the Infinity Computer and MATLAB/Simulink concepts and background knowledge on the research domain. Section 3 presents the Simulink-based solution for operating with the Infinity Computing concepts within the Simulink environment. In Sect. 4, three series of numerical experiments are presented to show the feasibility and validity of the solution. Finally, conclusions and future works are delineated in Sect. 5.

Background
The paper uses notions and concepts from Infinity Computing and its representation of numbers along with related algebraic operations, and MATLAB/Simulink, as described in the following subsections.

Infinity computing and representation of numbers
In the Infinity Computing framework [see Sergeyev (2017)], all numbers are represented using the positional numeral system with the infinite radix 1 introduced as the number of elements of the set of natural numbers [see, e.g., Sergeyev (2017)]: where quantities d i , i = 0, . . . , n, are finite (positive or negative) floating-point numbers called grossdigits, and p i , i = 0, . . . , n, are called grosspower s and can be finite, infinite and infinitesimal (positive or negative), n is the number of grosspowers used in computations (can be fixed or variable for all computations) 1 . Due to limitations of the Simulink (e.g., difficulties in working with variable-sized matrices in algebraic loops) and for simplicity, only finite floating-point grosspowers are considered in this paper. It should be noted that this methodology is not related to nonstandard analysis [see Sergeyev (2019) for details].
The Infinity Computer has been already successfully used for solving problems in applied mathematics, e.g., in optimization [see Cococcioni et al. (2020bCococcioni et al. ( , 2018

MATLAB/Simulink
Simulink is a software developed by MathWorks as extension of MATLAB [see MathWorks (2019a)]. It allows engineers to rapidly build, simulate and analyze dynamic systems using block diagram notation before moving to hardware. Moreover, Simulink offers a graphical support that shows the progress of a simulation, significantly increasing understanding of the system's behavior.
The potential productivity improvement achieved with Simulink to programming is impressive [see MathWorks (2019a)]. In the past, the common approach to develop a system was to start from its components by describing their logic through blocks. Then, blocks were translated into the corresponding source code according to a given programming language (e.g., C/C++). This approach involved duplication of effort, since the system had to be described twice; the first time using block notation and then in a programming language. This practice exposed to accuracy risks in the translation process from blocks to source code, making debugging phases difficult because errors could be in the design (block diagram level), in the programming (programming level), and/or in the translation process. With Simulink, this approach is no longer necessary since blocks are the "program".
Simulink is widely used in research and industry to explore and analyze different design alternatives of complex system in order to find the best configuration that meets the requirements. Research teams can exploit the multi-domain nature of Simulink to collaboratively simulate the behavior of the system's components, each of which developed by a team, also to understand how components influence the behavior of the entire system Falcone and Garro (2016a); Falcone et al. (2017aFalcone et al. ( , b, 2018a. Simulink allows one: to reduce expensive prototypes by testing the system in otherwise risky and/or time-consuming conditions; to validate the system design with hardwarein-the-loop testing and rapid prototyping; and to maintain traceability of requirements from design down to the corresponding source code.

Architecture
The proposed solution brings the power of the Infinity Computer into the Simulink Graphical Programming Environment (GPE). The solution has been designed to facilitate the modeling and simulation of dynamic systems by allowing engineers to focus on the specific aspects of their system's components, without dealing with the low level functionalities exposed by the Infinity Computer Arithmetic C++ library (ICA-lib). The presented Simulink-based solution is general-purpose and domain-independent; as a consequence, it can be exploited in all industrial and scientific domains where a high level of accuracy in the calculations represents a mainstay (e.g., Cyber-Physical Systems, Robotics and Automation, Aerospace [see ; Falcone et al. (2017b); Garro et al. (2015Garro et al. ( , 2018b]).
The design and implementation of the solution have been focused on standard software engineering methods and techniques, in particular, on the Agile software development process [see Martin (2002);Venkatesh et al. (2020)]. The solution has been developed through the use of standard Simulink Blocks and S-Functions, which allows engineers to jointly exploit the advantages coming from the Infinity Computer and the already available Simulink functionalities. Figure 1 presents an overview of the Simulink-based Infinity Computing solution and its integration with the MAT-LAB/Simulink environments.
In the following Fig. 1, the Simulink-based solution is placed in the middle of three layers.
The Simulink UI represents the Simulink environment used for modeling, analyzing and simulating dynamic systems through the graphical block diagramming tool accord-ing to the Model-Based Design (MBD) paradigm [see Falcone and Garro (2017b)]. MBD offers an efficient approach to address problems associated with the design and implementation of complex systems, signal processing equipment and communication components. This approach provides a common framework where engineers can define models with advanced functionalities using continuous-time and discretetime blocks. The so-obtained models can be simulated in Simulink by using different operational conditions leading to rapid prototyping, testing and verification of the system's requirements and performances.
The Simulink Environment layer provides all the standard Simulink blocks along with the ones offered by the Simulinkbased Infinity Computer solution (details will be given in Subsection 3.3).
The Matlab Environment represents the Matlab infrastructure where the Infinity Computer arithmetic C++ library (ICA-lib) has been integrated in order to handle infinite, finite, and infinitesimal computations. The integration of the ICA-lib in Simulink has been done by creating a MATLAB executable file (MEX), which provides an interface between the involved parts. When compiled, the MEX file is dynamically loaded by Simulink and permits to invoke the Infinity Computer arithmetic functions as if they were natively builtin.
The ICA-lib offers a set of services, each of which offers some C++ classes and interfaces that implement specific functionalities to handle infinite, finite, and infinitesimal quantities along with related computations.

Representation of grossnumbers in Simulink
In the Simulink-based solution of the Infinity Computer, a grossnumber x is represented through a standard Simulink Constant block as a variable-sized vector (1-D array) or matrix (2-D array) depending on the dimensionality of the "Constant value" parameter [see MathWorks (2019a)]. Specifically, the output has the same dimensions and elements as the "Constant value" parameter. If "Constant value" is a vector and "Interpret vector parameters as 1-D" is enabled, Simulink treats the output as a 1-D array; otherwise, the output is managed as a matrix (i.e., a 2-D array). Regardless of the output size, the first column represents the grossdigits, whereas the second one defines the grosspowers of a number written in the form (1): the number (1) is represented by the following matrix: (2) Fig. 1 Overview of the Simulink-based Infinity Computer solution and its integration in the MATLAB/Simulink environment For instance, the number 2 is represented in this solution through a vector 2 0 , while the number 5 1 0 + 1 1 −1 is represented by the matrix 5 0 1 −1 .

Functional blocks
A set of functional blocks have been created to manage computations on infinite, finite, and infinitesimal quantities written in the form (2) that each functional block takes as input infinite, finite, and infinitesimal quantities that are forwarded to the associated S-Function to perform the computation by interacting with ICA-lib. Figure 2 shows the functional block modules that constitute the Simulink-based Infinity Computer solution.

Arithmetic blocks module
This section is devoted to the Arithmetic Blocks Module (ABM). It provides a set of blocks devoted to perform arithmetic computations on infinite, finite, and infinitesimal quantities, such as Sum, Subtraction, Multiplication and Division.
All the blocks take as input two arguments x, y, which are defined as follow: where N is a configuration parameter that represents the maximum precision used to perform operations. This number fixes the number of rows in the matrix representation (2) of each grossnumber (1). It is defined within each block and by default its value is set to 20. The real precision of the Infinity Computer is defined through the parameter n, n ≤ N , which can be configured in the "n_configuration.m" file.
The x, y arguments represent the grossnumbers The result of the applied operation is a matrix z ∈ R N ×2 : where z has dimension and number of elements according to the Infinity Computer algebra [see Sergeyev (2003)], where the first n rows are significant, whereas the other N − n ones are null. For each block included in ABM, the specific function and an example that shows its application are presented, hereinafter.
The grossnumbers A, B, and C are defined as: The result C is defined by including both the items of A, a k i 1 k i : k i = m j with 1 ≤ j ≤ M and the ones of B, b m j 1 m j : m j = k i with 1 ≤ i ≤ K , and the terms having the same grosspower (a l i + b l i ) 1 l i , according to the Infinity Computer arithmetic described in Sergeyev (2017).
The division operation C = A/B leads to a result C plus a reminer R, where the first grossdigits are c k K = a l L /b m M and the maximal exponent is k K = l L − m M .
The first partial reminder R * is derived as: R * = A − c k K 1 k K · B. The calculation ends when either R * = 0 or the default accuracy is reached; otherwise, the number A is substituted by R * and the computation starts again [see Sergeyev (2017)].

Elementary blocks module
The Elementary Blocks Module (EBM) offers common elementary functions, such as cosine, sine, exponential, and logarithm.
Each elementary function f (x) has been implemented using the truncated Taylor series:  (8) is known and the analytical formulae for the respective deriva- are also known and simple to implement. For each elementary function, except x p and log(x), the value x 0 is chosen as the finite part of the input x even if this finite part is equal to 0. For the functions x p and log(x), since they are not differentiable at the point x 0 = 0, then the value x 0 was chosen as the finite part of x, if it is different from 0, and 0.1, otherwise (the number 0.1 has been chosen in order to be not too small nor too large and just to keep the computations also in the case, when x 0 = 0). Since the number x and the numbers (x − x 0 ) are grossnumbers, then the computations in this Taylor expansion are performed using the arithmetic operations implemented in the Infinity Computer library. The value N is the same as in (1), since the resulting value f (x) at a grossnumber x is also a grossnumber of the form (1).
All the blocks take as input one argument x (except the block Pow implementing the function x p , which takes also the second input p defined as the standard floating-point number), which is defined as follows: where N is the configuration parameter with the same significance as previously. The real precision of the Infinity Computer is also defined as previously through the parameter n (i.e., the rows in (9) starting from the (n + 1)th contain only zeros).
In this solution, the expansions (8) have significance only if the input x is not infinite; otherwise, the Taylor series become divergent. If these elementary functions should be evaluated also at the infinite points x, then another implementations should be used (e.g., the Newton method).
Sin. This block performs the trigonometric sine of an argument x expressed as a grossnumber. The values ± sin(x 0 ) and ± cos(x 0 ) being the respective derivatives used in the Taylor formula (8) are calculated using the standard C + + library math.h. Figure 4a shows a Simulink model that performs the computation sin(2 1 0 + 1 1 −1 ). The result 0.9093 1 0 − 0.4161 1 −1 − 0.4546 1 −2 ... is shown by the Display block.
Cos. This block performs the trigonometric cosine of an argument x expressed as a grossnumber. The values ± sin(x 0 ) and ± cos(x 0 ) being the respective derivatives used in the Taylor formula (8)  Exp. This block computes the base-e exponential function of a grossnumber x, which is e raised to the power x : e x . The value exp(x 0 ) being the respective derivative used in the Taylor formula (8) is calculated using the standard C + + library math.h. Figure 4c depicts a Simulink model that performs the computation e (2 1 0 +1 1 −1 ) . The result 7.389 1 0 + 7.389 1 −1 + 3.695 1 −2 ... is shown by the Display block.
Log. This block allows to calculate the natural logarithm of a grossnumber x. The values log(x 0 ) and x p 0 , where p is finite, used for the computation of the respective derivatives in the Taylor formula (8) are calculated using the standard C ++ library math.h. Figure 4d shows a Simulink model that performs the computation log(2 1 0 + 1 1 −1 ). The Display block shows the result 0.6931 1 0 0.5 1 −1 − 0.125 1 −2 + 0.04167 1 −3 ... of the computation.
Pow. This block applies the function that returns the base x to the power p, defined as x p . The values x q 0 , where q are finite, used for the computation of the respective derivatives in the Taylor formula (8) are calculated using the standard C + + library math.h. The value p is defined as a standard floating-point number. Figure 4e shows a Simulink model that performs the computation (2 1 0 + 1 1 −1 ) −2.5 . The Display block shows the result 0.1768 1 0 −0.221 1 −1 + 0.1933 1 −2 − 0.415 1 −3 of the computation.
Sqrt. This block, which has been added for convenience, uses the function defined in the Pow block to return the square root of a grossnumber x : Figure 4f shows a Simulink model that performs the computation (2 1 0 + 1 1 −1 ). The Display block shows the result 1.414 1 0 + 0.3536 1 −1 − 0.04419 1 −2 ... of the computation.

Utility blocks module
The Utility Blocks Module (UBM) provides common utility function blocks, which are required for supporting the implementation of models according to the Infinity Computer solution and making them compatible with the Simulink environment.
Continuous2Discrete. This utility block allows one to set the Sample Time to Discrete for all variable size blocks and Signals. It allows to sample time directly as a discrete numerical value. The produced value is used to update, during the simulation execution, the blocks internal states.
fillGrossnumber. This block adds zero rows to the matrix representation of its input in order to fix the size of all variables (by default the size of all variables representing grossnumbers is equal to 20 by 2, i.e., the number N from (2) is set to 20). Specifically, given a matrix M ∈ R n×m with m = 2 and i < n significant rows, the function adds an k-by-m rows of zeros, where k = n − i to fill M.
This block is required, for instance, to work with Simulink models containing algebraic loops where variable size variables are not allowed.
toGross. This block transforms a floating point number x in the corresponding matrix representation x 0 from (2). The so-obtained result is compatible with the Infinity Computer Simulink solution and therefore can be used as input for the other provided blocks.
getFinitePart. This block returns the finite part of a grossnumber x as a standard floating point number. For instance, given x = ⎡ ⎣ 2 1 5 0 3.1 −5 ⎤ ⎦ , this block returns the value 5, while for y = 3 2 3.1 −1 the result is 0.

Assessment and evaluation
In this section, three series of numerical experiments are presented in order to evaluate the proposed solution. First, several benchmark test functions are implemented using the proposed solution and using the standard Simulink blocks. Then, these functions are evaluated using different inputs given as grossnumbers. Finally, a simple approach for the exact higher-order differentiation is implemented for these benchmarks.

Benchmark functions
In this subsection, the following three test functions from  are considered: These functions have been chosen among the 24 test functions from  for the following reasons. First, they contain different elementary functions: f 1 (x) is rational, f 2 (x) is trigonometric, f 3 (x) contains the exponential function. Second, these functions are simple to implement for a fast visualization, do not contain a lot of blocks of the same type or algebraic loops. Finally, all these functions are infinitely differentiable.
In Figs. 5, 6, and 7, the implementations of the functions f i , i = 1, 2, 3, are presented using the proposed solution (a) and using standard Simulink blocks (b). One can see that these implementations are straightforward and simular. A unique difference consists of the block toGross, which transforms the input x from the traditional computational framework to the form (2) and the block get FinitePart, which returns the finite part of the result f (x). The utility blocks have been added in these implementations only to keep the computations in the traditional computational framework outside the functions, which can be useful in practice (so, there is no necessity to re-write all the implementations of the systems to the presented solution; this solution is used only where it is necessary). One can see from this figure, that the implementation of the functions in the proposed solution does not require a lot of additional knowledge about Fig. 4 Simulink models that perform the trigonometric function sin x (a), the trigonometric function cos x (b), the base-e exponential function e x (c), the natural logarithm log x (d), the base x to the exponent power p, x p , where p = −2.5 e, and the square root √ x (f) of the grossnumber x = 2 1 0 + 1 1 −1 Fig. 5 Implementations of the function f 1 (x) from (10) using the proposed solution (a) and using standard Simulink blocks (b) Fig. 6 The implementations of the function f 2 (x) from (11) using the proposed solution (a) and using standard Simulink blocks (b) Fig. 7 The implementations of the function f 3 (x) from (12) using the proposed solution (a) and using standard Simulink blocks (b) Fig. 8 The evaluation of the functions f i (x), i = 1, 2, 3, from (10) to (12) at the points x 1 = 3 1 0 + 1.5 1 −1 (left) and x 2 = 2.5 1 −1.5 − 3.6 1 −2 + 5 1 −3.2 (right) Fig. 9 Computation of the first 2 derivatives of a function f (x) at the points x = t given by the Simulink "clock" block the Infinity Computer or about the low-level implementations of the Infinity Computer arithmetic. The number of the used blocks is the same, so there is no additional costs in implementation of the functions (except the addition of the utility blocks at the initial and final parts of the Simulink system, which has a constant complexity). One can see also that the results of the computation of these two implementations of the test functions at the points x * i , i = 1, 2, 3, from  also coincide (the points x * i , which are the global minimizers of the functions f i (x), respectively, have been chosen just for simplicity: the results of the computations at any finite point x 0 coincide for these two implementations).

Evaluation
Let us now evaluate these functions at the inputs given as the grossnumbers, i.e., without the utility blocks toGross and get FinitePart. In Fig. 8, the results of the computa- Analytical derivative (f) Fig. 10 Graphs of the derivatives f i (x) (left) and f i (x) (right) of the functions f i (x), i = 1, 2, 3, from (10) to (12) at the interval [0, 10] obtained by the Infinity Computer and analytically. It can be seen that the graphs obtained by the Infinity Computer and by the analytical formulae coincide tion at two different points x 1 = 3 1 0 + 1.5 1 −1 (on the left side) and x 2 = 2.5 1 −1.5 − 3.6 1 −2 + 5 1 −3.2 (on the right side) are presented. The computations are kept with the precision n = 5, i.e., using 5 grosspowers in (1). One can see that computations with different grossnumbers are allowed in this solution. Moreover, the grosspowers are not necessarily integer, but can be different floating-point numbers, as well. It is very important that the user could not know how the arithmetic operations are implemented inside the functions f (x). Namely, it is sufficient to give an input x and the output f (x) will be automatically generated in the form (1) without the necessity to deal with the C + + class of the Infinity Computer simulator.

Exact higher-order differentiation
Let us consider now an important application of the proposed solution in the numerical analysis field. Suppose that we want to calculate the first k, k ≥ 1, derivatives of the function f (x) implemented using the Simulink arithmetic blocks. Traditionally [see Karris (2006b)], the internal Simulink block "Derivative" allows one to calculate the derivatives only using the finite forward differences, which are usually not accurate. Moreover, since using the forward differences for computation of the first k, k ≥ 1, derivatives, at least k + 1 observations of the function f (x) are needed, then the values of the derivatives at the first x 0 , x 1 , …, x k−1 points cannot be calculated using the Simulink's "derivative" blocks. The obtained error is of order 1, i.e., proportional to the Simulink's system sample time t, and often cannot be small enough due numerical cancellation errors. Another possibility to calculate the exact higher-order derivatives in Simulink is using external packages, e.g., for automatic differentiation. However, this solution has several disadvantages. First, using external packages requires additional knowledge on how they work and how to use them. Second, if the function f (x) is difficult and uses a lot of subsystems and external dependencies, then the resulting formulae or systems obtained by the automatic differentiation can be too difficult and can require a lot of computational resources to generate them. Moreover, in this case, the evaluation of the higher-order derivatives can be too slow or even impossible [see, e.g., Iavernaro et al. (2020a)].
Let us see, how the higher-order derivatives can be calculated on the Infinity Computer. Suppose that the function f (x) has only finite values at the finite points x (i.e., it does not depend on 1 ). Suppose also that there exists the (unknown) Taylor expansion of the function f (x) around the finite point x 0 . Then, the result of the computation of f (x) at the point x 0 + 1 −1 truncated after k + 1 grosspowers gives us the exact 2 higher-order derivatives of the function f (x) at the point x 0 : from where one can obtain that f ( Sergeyev (2011aSergeyev ( , 2017 for details]. In Fig. 9, the Simulink subsystem for computation of the first 2 derivatives of a function f (x) implemented in the subsystem "f(x)" at the time steps t using the proposed solution of the Infinity Computer is presented. Since the derivative is calculated with respect to the time t, then let us call the functions f (x) as the functions depending on time t, i.e., f (t), hereinafter. First, the input t given by the standard Simulink block "clock" is transformed to the grossnumber t gross by the block "toGross". Then, the infinitesimal 1 −1 expressed by the constant block is added to the transformed input t gross . The obtained grossnumber is moved to the input of the block "f(x)". The output of the block "f(x)" is multiplied by 1 and the result arrives to the block "getFinitePart" (from where the value f (t) is obtained), at the same time the output of the block "f(x)" is multiplied by 2 1 2 and the result arrives to the block "getFinitePart" as well (from where the value f (t) is obtained). The obtained values of the derivatives arrive to the scope blocks in order to construct their graphs.
The graphs of the first two derivatives for each test function f i (t), i = 1, 2, 3, from (10) to (12) are presented in Fig. 10, from where one can see that the derivatives obtained by the Infinity Computer coincide with the exact derivatives obtained analytically.
One can see that the differentiation using the presented solution is simple and almost does not require any additional knowledge and/or tools. Higher-order derivatives can be easily calculated using only the proposed blocks without the necessity of an additional specific tool or block. More applications are provided in the accompanying paper [see Falcone et al. (2020a)].

Conclusion
A new Simulink-based software solution to the Infinity Computer has been proposed in this paper. This solution uses the software simulator of the Infinity Computer written in C ++ according to the patents [see Sergeyev (2010a)] and loaded in Matlab using MEX-files for the implementation of the low-level arithmetic. The proposed solution is user-friendly, simple, general purpose and domain independent, i.e., it can be used in any domain where a high precision of the computations is required.
Four arithmetic blocks representing four operations +, −, ×, and /, have been proposed as well as the blocks for the elementary functions sin(x), cos(x), exp(x), log(x), x p , and √ x. Moreover, four utility blocks for supporting the implementation of models have been also proposed. The usage of the proposed blocks is similar to their internal Simulink analogues, so it does not require any additional tools or sophisticated techniques.
The solution has been evaluated on three benchmark test problems. It has been shown that the complexity of implementation of the functions using the proposed solution and using traditional Simulink blocks is the same, while the proposed solution allows one to use all the potentiality of the Infinity Computer in Simulink without the necessity of referring to the low-level implementation of the procedures on the Infinity Computer. As an example of the potential usage of the solution, an exact higher-order differentiation of the univariate functions has been considered. It has been shown that the proposed solution allows one to calculate the exact higher-order derivatives in a simple and efficient way without using any additional tool.
Future research efforts will be devoted to: (1) improve and extend the proposed solution to support a wider set of concepts and operations delineated by the Infinity Computer; (2) perform further experimentations of the solution in different application domains.
Funding Open access funding provided by Università della Calabria within the CRUI-CARE Agreement.

Compliance with ethical standards
Conflict of interest All authors declare that they have no conflict of interest.
Human and animal rights This article does not contain any studies with human participants or animals performed by any of the authors.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecomm ons.org/licenses/by/4.0/. Sergeyev YD, Kvasov DE, Mukhametzhanov MS (2018)  Publisher's Note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.