Search

Recently, cryptographic literature has seen new block cipher designs such as PRESENT, GIFT or SKINNY that aim to be more lightweight than the current standard, i.e., AES. Even though AES family of block ciphers were designed two decades ago, they still remain as the de facto encryption standard, with AES-128 being the most widely deployed variant. In this work, we revisit the combined one-in-all implementation of the AES family, namely both encryption and decryption of each AES-128/192/256 as a single ASIC circuit. A preliminary version appeared in Africacrypt 2019 by Balli and Banik, where the authors design a byte-serial circuit with such functionality. We improve on their work by reducing the size of the compact circuit to 2268 GE through 1-bit-serial implementation, which achieves 38% reduction in area. We also report stand-alone bit-serial versions of the circuit, targeting only a subset of modes and versions, e.g., AES-192 and AES-256. Our results imply that, in terms of area, AES-192 and AES-256 can easily compete with the larger members of recently designed SKINNY family, e.g., SKINNY-128-256, SKINNY-128-384. Thus, our implementations can be used interchangeably inside authenticated encryption candidates such as SKINNY-AEAD/-HASH, ForkAE or Romulus in place of SKINNY.

International audience; Thematic Working Group 2 focused on six questions related to teaching and learning of arithmetic and number systems from grades 1 to 12:1) What is the interplay between conceptual understanding and procedural skills for number operations, and how should these two aspects be balanced in the design of learning environments?2) What does it mean to operate flexibly with numbers, and what knowledge and skills are required therefore?3) What are the roles of models in teaching and learning of arithmetic and number systems, and how do they support flexibility and conceptual understanding?4) What are effective approaches for teaching and learning of arithmetic and number systems in inclusive education? How can this content area be taught for students with special needs? 5) What aspects of number theory (including specific reasoning) are supposed to be taught in primary and secondary school, and how can this be done? 6) How is it possible to support and analyze long-term learning processes from grade 1 to grade 12? How can different transitions that come with a long-term learning process be taken into account, especially the primary-secondary transition, but also the secondary-tertiary transition.

Structured codes are known to be necessary in practical implementations of capacity-approaching "dirty paper schemes". In this paper we study the performance of a recently proposed dirty paper technique, by Erez and ten Brink which, to the authors' knowledge, is firstly applied to data-hiding, and compare it with other existing approaches. Specifically, we compare it with conventional side-informed schemes previously used in data-hiding based on repetition and turbo coding. We show that a significant improvement can be achieved using Erez and ten Brink's proposal. We also study the considerations we have to take into account when these codes are used in data-hiding, mainly related with perceptual questions.

Recently, there has been a growing emphasis on basic number processing competencies (such as the ability to judge which of two numbers is larger) and their role in predicting individual differences in school-relevant math achievement. Children’s ability to compare both symbolic (e.g. Arabic numerals) and nonsymbolic (e.g. dot arrays) magnitudes has been found to correlate with their math achievement. The available evidence, however, has focused on computerized paradigms, which may not always be suitable for universal, quick application in the classroom. Furthermore, it is currently unclear whether both symbolic and nonsymbolic magnitude comparison are related to children’s performance on tests of arithmetic competence and whether either of these factors relate to arithmetic achievement over and above other factors such as working memory and reading ability. In order to address these outstanding issues a quick (two-minute) paper-and-pencil tool was designed to measure children’s ability to compare symbolic and nonsymbolic numerical magnitudes. Individual differences in children’s performance on this test were then correlated with individual differences in arithmetic achievement. Chapter 2 demonstrated that both symbolic and nonsymbolic number comparison accuracy were related to individual differences in arithmetic achievement. However, only symbolic number comparison performance accounted for unique variance in arithmetic achievement. Results also revealed that symbolic scores accounted for unique variance in children’s arithmetic scores when controlling for age, IQ, reading skills and working memory. Chapter 3 assessed the soundness of the paper-and-pencil test. Results indicated that the paper-and-pencil test demonstrated criterion-related validity, levels of convergent validity and test-retest reliability. Findings again revealed that only children’s performances on symbolic items accounted for unique variance in arithmetic scores. In Chapter 4, further evidence of the convergent validity of the paper-and-pencil test was demonstrated and again, symbolic processing accounted for unique variance in children’s arithmetic achievement. Results also demonstrated that participants’ performance on the paper-and-pencil test in kindergarten was a significant predictor of their math grade in Grade 1. Together these three studies give evidence to suggest that a simple two-minute paper-and-pencil test is a valuable and reliable tool for assessing basic magnitude processing in children from kindergarten to the third grade.

Let ω be a real quadratic irrational number with 0

The use of functional near-infrared spectroscopy (fNIRS) in block designs provides measures of cortical activity in ecologically valid environments. However, in some cases, the use of block designs may be problematic when data are not corrected for performance in a time-restricted block. We sought to investigate the effects of task complexity and processing speed on hemodynamic responses in an fNIRS block design. To differentiate the effects of task complexity and processing speed, 20 subjects completed the trail making test (TMT) in two versions (TMT-A versus TMT-B) and three different speed levels (slow versus moderate versus fast). During TMT-A, subjects are asked to connect encircled numbers in numerically ascending order (1-2-3 ... ). In the more complex TMT-B, subjects are instructed to connect encircled numbers and letters in alternating ascending order (1-A-2-B ... ). To illustrate the obscuring effects of processing speed on task complexity, we perform two different analyses. First, we analyze the classical measures of oxygenated blood, and second, we analyze the measures corrected for the number of processed items. Our results show large effects for processing speed within the bilateral inferior frontal gyrus, left dorsolateral prefrontal cortex, and superior parietal lobule (SPL). The TMT contrast did not show significant effects with classical measures, although trends are observed for higher activation during TMT-B. When corrected for processed items, higher activity for TMT-B in comparison to TMT-A is found within the SPL. The results are discussed in light of recent research designs, and simple to use correction methods are suggested. (c) The Authors. Published by SPIE under a Creative Commons Attribution 3.0 Unported License. Distribution or reproduction of this work in whole or in part requires full attribution of the original publication, including its DOI.

No abstract available.

Logarithmic number systems (LNS) reduce hardware complexity for multiplication and division in embedded systems, at the cost of more complicated addition and subtraction. Existing LNS typically use base-2, meaning that representable numbers are some (often fractional) power of two. We argue that other bases should be considered. The base of the LNS determines the distribution of values and may reduce representation errors when converting inputs to LNS in domain-specific embedded hardware accelerators. Further, LNS addition and subtraction are normally implemented with lookup tables whose properties may be a function of the base. We show that other bases can lower both representation and addition and subtraction error. We consider the case of 8-bit LNS, when converting from 8-bit floating point (FP). We find that base-1.984 significantly reduces the conversion error. Where we can scale values, base-1.851 reduces the error to just 0.011 units of least precision (ULP). A suitable base can also reduce average arithmetic errors. For example, base-1.802 LNS has an average error of 0.242 ULP and 0.212 ULP as compared to 0.243 ULP and 0.226 ULP for addition and subtraction, respectively, for base-2.

Learning curves, which express performance as a function of the cumulative number of repetitions when performing a given task, have a long tradition of supporting managerial decisions in production and operations management. Performance generally improves as the number of repetitions of a given task increases, with the latter being a primary proxy to reflect experience. A learning curve is usually a maximum-likelihood trend-line that best fits raw data points by splitting them to above and below it. However, its curvature does not always accurately capture the scatter around it, which reduces its accuracy. This paper advocates for an improved learning curve, one that accounts for the variable degree of cognitive interference that occurs while learning when moving from one repetition to the next. To capture this phenomenon, this paper accounts for memory traces of repetitions to measure the residual (interference-adjusted), not the nominal (maximum), cumulative experience. Two alternative learning curve modelswere developed. The first model aggregates the residual cumulative experience for each repetition while fitting the data. The second model is an approximate expression and, as a continuous model, much easier to implement. The models were tested against data from different learning environments (such as production and assembly), alongside a more traditional power (log-linear) form of the learning curve and its plateau version. The results show that the interference-adjusted models fit the data very well, such that they can serve as valuable tools in production and operations management.

International audience; This paper presents a novel verification methodfor arithmetic circuits subjected to some user or applicationconstraints. The verification problem is solved in an algebraicdomain rather than in a Boolean domain by representingcircuit specification and its implementation as polynomials.The concept of deterministic terms is introduced to describethe constraints imposed on the circuit. Based on this concept, acase splitting analysis is proposed to resolve the memory problemduring algebraic rewriting. The computational complexityof the method is analyzed, and two techniques are proposedto accelerate the verification process. The experimental resultsfor constrained arithmetic circuits up to 128 bits, and thecomparison with the state-of-the-art SAT solver demonstratethe effectiveness and the scalability of the proposed method.

This paper presents an analysis of a hitherto barely known conceptual problem in the foundations of arithmetic. An unknown type of number, so-called complex numbers, first emerged in 18th century France and became connected with the claim of non-commutativity of their multiplication. These first French practitioners are here analysed, along with examination of the impact of the introduction of the metric decimal system. International dissemination of the notion is then analysed, in particular in the case of Brazil. The paper concludes by looking at the mathematical foundations of multiplying (physical) quantities. (c) 2020 Elsevier Inc. All rights reserved.

An ideal test is supposed to show not only the presence of bugs but also their absence. Based on the Fundamental Test Theory of Goodenough and Gerhart (IEEE Trans Softw Eng SE-1(2):156-173, 1975), this paper proposes an approach to model-based ideal testing of hardware description language (HDL) programs based on their behavioral model. Test sequences are generated from both original (fault-free) and mutant (faulty) models in the sense of positive and negative testing, forming a holistic test view. These test sequences are then executed on original (fault-free) and mutant (faulty) HDL programs, in the sense of mutation testing. Using the techniques known from automata theory, test selection criteria are developed and formally show that they fulfill the major requirements of Fundamental Test Theory, that is, reliability and validity. The current paper comprises a preparation step (consisting of the sub-steps model construction, model mutation, model conversion, and test generation) and a composition step (consisting of the sub-steps pre-selection and construction of Ideal test suites). All the steps are supported by a toolchain that is already implemented and is available online. To critically validate the proposed approach, three case studies (a sequence detector, a traffic light controller, and a RISC-V processor) are used and the strengths and weaknesses of the approach are discussed. The proposed approach achieves the highest mutation score in positive and negative testing for all case studies in comparison with two existing methods (regular expression-based test generation and context-based random test generation), using four different techniques., University of Antwerp and Flanders Make (a strategic research center) [43169], Y The authors express their gratitude to John B. Goodenough for his valuable comments and suggestions on earlier versions of this article. The authors also thank anonymous reviewers for their valuable comments on an earlier version. This study is financially supported by University of Antwerp and Flanders Make (a strategic research center) under Grant No. 43169.

Multiplicative thinking underpins much of the mathematics learned beyond the middle primary years. As such, it needs to be understood conceptually to highlight the connections between its many aspects. This paper focuses on one such connection; that is how the array, place value partitioning and the distributive property of multiplication are related. It is important that students understand how the property informs the written multiplication algorithm. Another component of successful use of the standard multiplication algorithm is extended number facts and the paper also explores students’ ability to understand and generate them. One purpose of the study was to investigate the extent to which students used the standard multiplication algorithm and if their use of it is supported by an understanding of the underpinning components of the array, partitioning, the distributive property, and extended number facts. That is, we seek to learn if students have a conceptual understanding of the multiplication algorithm and its underpinning mathematics that would enable them to transfer their knowledge to a range of contexts, or if they have procedurally learned mathematics. In this qualitative study, data were generated from the administration of a Multiplicative Thinking Quiz with a sample of 36 primary aged students. Data were analyzed manually and reported using descriptive statistics. The main implications of the study are that the connections among the multiplicative array, place value partitioning, base ten property of place value, distributive property of multiplication, and extended number facts need to be made explicit for children in terms of how they inform the use of the written algorithm for multiplication.

In the paper information-management system development conception on basis of binary binomial number systems is considered. It is based on the new information technology on data processing using binary binomial numbers. There are three interrelated science schools applied in this technology: combinatorial configurations generation on structures of ordered sets of binary binomial numbers, combinatorial configurations enumeration by means of binary binomial number systems and development of machine binomial arithmetic. The constant weight codes, quasi-equilibrium codes and other codes-combinations, which are widely-distributed enough in the information-management systems, are proposed in the capacity of combinatorial configurations. According to the pointed technology code objects of a binomial structure applying to input binary data are generated, then the obtained code objects are converted into binary binomial numbers to carry out standard or specialized information processes, after that the binary binomial numbers or corresponding to them code objects of a binomial structure are converted into output data on basis of binary number systems. The approaches and ideas to put into practice solving of type or specific information problems are given using binary binomial numbers. Application of binary binomial numbers has for an object to increase processing power of information-management systems under minimum additional hardware and software expenses. The adaptive binomial data compression, binomial self-diagnosis and error control, generation of combinatorial configurations and solution of some combinatorial optimization tasks on basis of binomial numbers, the implementation of binomial arithmetic are under review as illustrations in the paper.

International audience; In this paper we consider the model of single insertion-deletion systems that at each step insert or delete a single symbol in a context-free manner (i.e. at any position in the word). The corresponding operation is performed if the word contains a set of permitting (that have to be present in the word) and/or forbidding (that must not be present in the word) strings of some size. The main result of this paper states that if forbidding strings of size 2 and permitting strings of size 1 are used then computational completeness can be achieved; moreover, checking for a single permitting symbol is sufficient. We also show that in the case of systems having rules with forbidding conditions only, all regular languages can be obtained. Finally, we show the computational non-completeness in the case of systems using rules with forbidding strings of size 1 (single symbols) and permitting strings of any finite size.

In the theory of answer set programming, two groups of rules are called strongly equivalent if, informally speaking, they have the same meaning in any context. The relationship between strong equivalence and the propositional logic of here-and-there allows us to establish strong equivalence by deriving rules of each group from rules of the other. In the process, rules are rewritten as propositional formulas. We extend this method of proving strong equivalence to an answer set programming language that includes operations on integers. The formula representing a rule in this language is a first-order formula that may contain comparison symbols among its predicate constants, and symbols for arithmetic operations among its function constants. The paper is under consideration for acceptance in TPLP., Comment: Paper presented at the 37th International Conference on Logic Programming (ICLP 2021), 15 pages

Financial and commercial data are mostly represented in decimal format. To avoid errors introduced when converting some decimal fractions to binary, these data are processed with decimal arithmetic. Most processors only have hardwired binary arithmetic units. So, decimal operations are executed with slow software-based decimal arithmetic functions. For the fast execution of decimal operations, dedicated hardware units have been proposed and designed in FPGA. Decimal multiplication is found in most decimal-based applications and so its optimized design is very important for fast execution. In this paper two new parallel decimal multipliers in FPGA are proposed. These are based on a new decimal adder/subtractor also proposed in this paper. The new decimal multipliers improve state-of-the-art parallel decimal multipliers. Compared to previous architectures, implementation results show that the proposed multipliers achieve 26% better area and 12% better performance. Also, the new decimal multipliers reduce the area and performance gap to binary multipliers and are smaller for 32 digit operands.

The aim of the Platform-Independent Approach to Formal Specification and Verification of Standard Mathematical Functions project is the development of an incremental combined approach to specification and verification of standard mathematical functions like sqrt, cos, sin, etc. The term “platform-independence” means that we attempt to design a relatively simple axiomatization of computer arithmetic in terms of real arithmetic (i.e., the arithmetic of the field ℝ of real numbers), but do not specify either the base of the computer arithmetic or the format of the representation of numbers. The incrementality means that we start with the most straightforward specification of the simplest algorithm in real numbers and finish with a realistic specification and a verification of the algorithm in computer arithmetic. We call our approach combined because we start with consideration of a “basic” case, the manual (pen-and-paper) verification of the algorithm in real numbers, then use this verification as proof-outlines for the manual verification of the algorithm in computer arithmetic, and finish with a computer-aided validation of the manual proofs with a proof-assistant system to avoid appeals to “obviousness” that are common in human-carried proofs. In the paper, we apply our platform-independent incremental combined approach to specification and verification of the standard mathematical square root function. By now, the computer-aided validation of the developed algorithms has been carried out only partially to prove, using the ACL2 system, the correctness (consistency) of our fixed-point arithmetic and the existence of a look-up table with the initial approximations of the square roots for fixed-point numbers.

Research objective. The paper deals with the solution of the problem of regulation of lecturer and student relations using neural networks for bimodal electronic universities. First, the approaches of other authors to this topic are explored.It is known that in bimodal electronic universities, students are trained both in the traditional order and outside the classroom (in distance form). Studies show that for traditional universities there are different approaches with the use of expert systems, genetic algorithms to solve thisDevelopment of the mechanism of intellectual management of “student-lecturer” relations in the space of virtual education with the use of neural networks problem. However, the problem is not solved using neural networks, as well as for students who have an off-campus. The relationship between lecturers and students in universities is regulated by the schedule of lessons.Materials and methods. Schedule of lessons is available in various combinations. The combination of the schedule of lessons is determined once in the beginning of each semester for traditional education, but these combinations are constantly changing in the distance learning environment. These changes are due to the requirement of independence of time and space for distance learning environments. This indicates the relevance of the problem and the compatibility of the use of neural networks to solve the problem. In the presented paper, to solve the problem, the schedule of classes is considered as a matrix. As you know, it is easier to process matrix elements when it is in the form of numbers. To this end, the subjects to be taught in the group are numbered according to the lecturers who will teach them. Then the schedule of lessons is compiled in an arbitrary combination of matrices 3×5 in accordance with the weekly schedule of lessons.Methods of research. The solution process is implemented in the MATLAB environment. To simplify the solution process, the matched matrix is converted to a single row matrix using the RESHAPE command. Then, all combinations of a single row matrix are obtained by applying the PERMS function. As a result, we obtain 15!×15 – dimensional matrix. This matrix is used as the target matrix of the neural network.After that, the weekly schedule of each lecturer’s training is also compiled as a matrix of 3×5, called the “lecturer employment matrix” and is marked as M (I) according to the numbers of the lecturers. Elements of “lecturer employment matrices” can get the value “0” or “İ”. The value of the matrix element is “0”, indicates that the lecturer is busy, and “İ” is free. At the next stage, the “employment matrix” for each lecturer turns into a linear matrix 1×15. Then an input matrix is constructed that combines the elements of the “employment matrix” of lecturers with each element of the target matrix. The weight coefficients for neurons are defined as the difference from the target matrix of the input matrix.Results of the study. Thus, the problem is introduced into a two-dimensional linear equation. Then, the neural network model is selected, tuned and trained in accordance with the conditions of the problem.Conclusion. In the end, the network is tested with input prices that correspond to the interests of the user. The schedule of lessons according to the received results is represented. At the end of the paper, the method side for the distance learning process is useful.

This is the behavioral and VBM dataset described in "Arithmetic skills are associated with grey matter volume in left fronto-temporal areas: A brain-wide association study with 536 children and adolescents". Raw MRI data for four of the datasetsincluded in the study are available at OpenNeuro (https://openneuro.org/datasets/ds001486/versions/1.3.1, https://openneuro.org/datasets/ds001894/versions/1.4.1, https://openneuro.org/datasets/ds002886/versions/1.1.0, and https://openneuro.org/datasets/ds002424/versions/1.2.0).Because of anonymization concerns withinthe framework of EU privacy regulations (GDPR) regarding two of the other datasets, we cannot provide raw MRI data. Therefore, the MRI data here consistof individualpre-processed volumes, normalized into the MNItemplate (see paper for details about the preprocessing pipeline). Anonymizedbehavioral data (with z-transformed scores, see manuscript for details) and GMV data extracted from ROIs are also provided in the file participants.csv. ROIs.zip contains the ROI masks that were used in the analyses

Binary MQ arithmetic coding is widely used as a basic entropy coder in multimedia coding system. MQ coder esteems high in compression efficiency to be used in JBIG2 and JPEG2000. The importance of arithmetic coding is increasing after it is adopted as a unique entropy coder in HEVC standard. In the binary MQ coder, arithmetic approximation without multiplication is used in the process of recursive subdivision of range interval. Because of the MPS/LPS exchange activity that happens in the MQ coder, the output byte tends to increase. This paper proposes an enhanced binary MQ arithmetic coder to make use of look-up table (LUT) for (A × Qe) using quantization skill to improve the coding efficiency. Multi-level quantization using 2-level, 4-level and 8-level look-up tables is proposed in this paper. Experimental results applying to binary documents show about 3% improvement for basic context-free binary arithmetic coding. In the case of JBIG2 bi-level image compression standard, compression efficiency improved about 0.9%. In addition, in the case of lossless JPEG2000 compression, compressed byte decreases 1.5% using 8-level LUT. For the lossy JPEG2000 coding, this figure is a little lower, about 0.3% improvement of PSNR at the same rate.

Polynomial multiplication is a bottleneck in most of the public-key cryptography protocols, including Elliptic-curve cryptography and several of the post-quantum cryptography algorithms presently being studied. In this paper, we present a library of various large integer polynomial multipliers to be used in hardware cryptocores. Our library contains both digitized and non-digitized multiplier flavours for circuit designers to choose from. The library is supported by a C++ generator that automatically produces the multipliers' logic in Verilog HDL that is amenable for FPGA and ASIC designs. Moreover, for ASICs, it also generates configurable and parameterizable synthesis scripts. The features of the generator allow for a quick generation and assessment of several architectures at the same time, thus allowing a designer to easily explore the (complex) optimization search space of polynomial multiplication., This paper has been accepted for conference proceeding in DDECS 2021 - April 7-9 2021 Vienna, Austria

The goal of this paper is a reassessment of Peirce’s doctrine of symbol. The paper discusses a common reading of Peirce’s doctrine, according to which all and only symbols are conventional signs. Against this reading, it is argued that neither are all Peircean symbols conventional, nor are all conventional signs Peircean symbols. Rather, a Peircean symbol is a general sign, i. e., a sign that represents a general object.

This paper presents a class of integer codes suitable for use in optical networks with low error rates. The presented codes are constructed with the help of a computer and have two important features: first, they can correct single errors affecting one or two b-bit bytes, and second, they use processor-friendly operations to encode/decode data bits. The effectiveness of the presented codes is demonstrated on theoretical models of four-core and six-core processors. The obtained results show that the decoder throughput reaches 14.70Gbps, which is above the operating speed of 10G networks. Finally, the paper compares the proposed codes with BCH codes of similar properties. The comparison is made in terms of redundancy and the number of decoding operations. This is the peer-reviewed version of the article: Radonjić, Aleksandar, "Integer Codes Correcting Single Errors within Two Bytes" in Journal of Circuits, Systems and Computers (2021), [https://doi.org/10.1142/S0218126621502601]

In this paper we propose new techniques related to division property. We describe for the first time a practical algorithm for computing the propagation tables of 16-bit Super-Sboxes, increasing the precision of the division property by removing a lot of false division trails. We also improve the complexity of the procedure introduced by Lambin et al. (Design, Codes and Cryptography, 2020) to extend a cipher with linear mappings and show how to decrease the number of transitions to look for. While search procedures for integral distinguishers most often rely on MILP or SAT solvers for their ease of programming the propagation constraints, such generic solvers can only handle small 4/8-bit Sboxes. Thus we developed an ad-hoc tool handling larger Sboxes and all the improvements described in the paper. As a result, we found new integral distinguishers on SKINNY-64, HIGHT and Midori-64.

We present the artifact for the accepted paper, An Approach to Generate Correctly Rounded Math Libraries for New Floating Point Variants. We describe the list of claims made by the paper, the installation instructions, and evaluation instructions. To ease the installation effort, we provide a docker image with all required softwares installed already. Additionally, we provide complete instructions to manually install the artifact on Ubuntu-16.04 or Ubuntu-18.04. _________________________________________________________________________________________________ * Hardware recommendation: All of our evaluations were performed on a machine with Intel Xeon Gold 6130 machine with 2.10GHz processor and 32GB of RAM, which runs Ubuntu-16.04-LTS. However, we predict that the artifact should be functional with modern machines with 16GB of RAM, running Ubuntu-16.04 or later. _________________________________________________________________________________________________ * Claims made from the paper: All claims to be evaluated in the artifact are found in Section 5. Experimental Evaluation. (1) Our technique successfully generates polynomials that are used in the correctly rounded math library functions for bfloat16, posit16, and float (claimed in Table 1). (2) The math library functions created using our technique produces the correctly rounded result for all inputs (claimed in Table 1). (3) Using glibc's float math library to compute the 10^x function for bfloat16 does not produce the correctly rounded result. Similarly, using glibc's float math library to compute log2(x) function for float does not produce the correctly rounded result. (claimed in Table 1) (4) On average, ourLibm's functions are 1.79x faster when compared to glibc's float library and 2.3x faster over glibc's double math library. Also we claim specific speedup of each math library function (claimed in Figure 11) (5) We also report ourLibm's posit16 function speedup compared to SoftPosit-Math library in Figure 12. (6) Section 5.3.3 reports 1.02x speedup of ourLibm's log2(x) for float compared to glibc's log2(x) for float. _________________________________________________________________________________________________ * INSTALLATION GUIDE: There are two methods to install the artifact: (1) Installing docker and downloading the docker image for the artifact or (2) Manual installation. We recommend to use the docker image provided to expedite the installation process. ** DOWNLOADING PREBUILT DOCKER IMAGE We have prebuilt a docker image and hosted it in the docker hub. (1) Install docker if not already installed by following the installation documentation in this link: https://docs.docker.com/install/ We recommend installing docker and evaluating our artifact on a machine with Ubuntu. Although docker can be used with Windows or MacOS, docker may run on top of a linux VM (2) Download the prebuilt docker image by using the command: $ sudo docker pull jpl169/popl21artifact The docker image is roughly 1GB (3) Run the docker image: $ sudo docker run -it jpl169/popl21artifact (4) If running the docker image on macOS, increase docker's memory resource. You can increase memory resource by going to docker->preference->Resources. 12GB ~ 16GB of memory usage should be sufficient. (5) Installation is complete. Go to EVALUATION GUIDE section. ** MANUAL INSTALLATION (1) To install and evaluate the artifact manually, first install a list of prerequisites: $ sudo apt-get update $ sudo apt-get install build-essential cmake git libgmp3-dev libmpfr-dev zlib1g zlib1g-dev bc wget python python3 python3-pip $ python3 -m pip install matplotlib (2) Download and install soplex 4.0.1: Please download soplex-4.0.1 from https://soplex.zib.de/index.php#download. $ tar -xvf soplex-4.0.1.tar $ cd soplex-4.0.1 $ mkdir build $ cd build $ cmake .. $ make $ cd ../.. (3) Download and compile SoftPosit : $ git clone https://gitlab.com/cerlane/SoftPosit.git $ cd SoftPosit/build/Linux-x86_64-GCC/ $ make $ cd ../../.. (4) Download and compile softposit-math : $ git clone https://gitlab.com/cerlane/softposit-math.git $ cd softposit-math/build/ $ ./make.sh $ cd ../.. (5) Set the following environment variables: $ export SOFTPOSITPATH= $ export SOPLEXPATH= $ export SOFTPOSITMATHPATH= (6.a) Download POPL21 artifact from github $ git clone https://github.com/jpl169/POPL21-artifact.git $ cd POPL21-artifact (6.b) Or, download POPL21 artifact from Zenodo and untar the file: - Zenodo page: https://doi.org/10.5281/zenodo.4067180 $ tar -xvf POPL21-artifact.tar $ cd POPL21-artifact.tar (7) Installation is complete. Go to EVALUATION GUIDE section. _________________________________________________________________________________________________ * EVALUATION GUIDE FOR THE ARTIFACT If you have followed one of the two installation methods in the INSTALLATION GUIDE section, you should be in the POPL21-artifact directory. If you are evaluating the artifact using the provided docker image, you will automatically be placed into POPL21-artifact directory when you run the docker image. (1) Generating the polynomials for ourLibm (Claim 1): To test our technique in generating the polynomials, run the bash script, $ ./runFunctionGen.sh This script will take roughly 20 minutes. This script creates a number of header files that contains coefficients for each elementary function generated by our function generator. These header files are used to build the library for correctness testing and performance testing. The header files are located in: - functiongen/bfloat16/full/headers : for bfloat16 functions - 10 header files - function/posit16/full/headers : for posit16 functions - 6 header files - function/float/sampling/headers : for log2 function for float - 1 header file To check that our function generator created header files, you can build ourLibm math library and verify that no error message is showing. To do so, go to POPL21-artifact folder and build the math library: $ make This build will show a divide by zero warning message, which is intended. (2) Checking the correctness of ourLibm (Claim 2 & 3): To test the correctness of ourLibm, run the bash script, $ ./runLibTest.sh This script will take roughly 2 minutes. Once the script terminates, the result will be outputted to LibTestResult.txt in POPL21-artifact directory. This file reports whether the elementary math functions produce the correctly rounded value for all inputs, for each representation (bfloat16, posit16, and float). You can view the result file using this command: $ cat LibTestResult.txt If ourLib produces the correctly rounded value for all inputs for a particular function, you will see the message "Function returns correct values for all inputs." after the name of the elementary function. You should see this message for ALL functions. This experiment tests for claim (2). You should also see an additional message for bfloat16's EXP10 function and float's LOG2 function that says, "Using Glibc's float mlib computes X/Y values incorrectly." This message indicates that using glibc mlib's float math library to compute the result of bfloat16's EXP10 or float's LOG2, then X number of inputs produce incorrect results. This message correlates to the claim (3). (3) Checking the speedup of ourLibm (Claim 4, 5, & 6): - To test the speedup of ourLibm, run the bash script, $ ./runOverheadTest.sh This script will take roughly 10~20 minutes. Once the script terminates, you will see the following files: (a) bfloatOverheadFull.pdf - This file shows the graph presented in Figure 11 (a) (b) bfloatOverheadInternal.pdf - This file shows the graph presented in Figure 11 (b) (c) positOverheadInternal.pdf - This file shows the graph presented in Figure 12 (d) F32OvhdRslt.txt - This file shows the speedup of ourLibm's log2(x) for float compared to glibc mlib's log2(x) for float. - If you're using docker to evaluate the artifact, you can copy the pdf's from the container to your host machine using the following commands: $ exit $ sudo docker container ls -a (Find the correct container id) $ sudo docker cp :/home/POPL21-artifact/bfloatOverheadFull.pdf . $ sudo docker cp :/home/POPL21-artifact/bfloatOverheadInternal.pdf . $ sudo docker cp :/home/POPL21-artifact/positOverheadInternal.pdf . - To go back into docker container, use the following commands: $ sudo docker start $ sudo docker attach To evaluate the result, compare the graphs from the pdf against Figure 11 and Figure 12. The speedup may be differ greatly between hardware architecture and specific configurations. Additionally, the file F32OvhdRslt.txt shows the speedup of ourLibm's log2(x) for float compared to glibc mlib's log2(x) for float. Since the submission, we have improved our technique in generating the polynomial and the range reduction technique for log2(x) for float. Our new log2(x) for float produces the correctly rounded value for all inputs now, as opposed to only inputs between 1 to 2 at the time of submission. Additionally, it uses a different type of range reduction technique. Thus, the new speedup may be different compared to claim (6). Nevertheless, we have observed that we have speedup over the glibc libm's double implementation of log2(x). _________________________________________________________________________________________________ * CASE STUDY: COMPARISON BETWEEN GENERATED POLYNOMIAL AND OURLIBM IMPLEMENTATION If you are interested in the source code of ourLibm, the source code is located in "source" directory. The source code is separated into the math library functions for bfloat16, posit16, and float in its own sub-directory. The case study shown in Section 5.4 describes our experiences in creating the math library functions, and hence, reflects the code in the source code. (1) Section 5.4.1: 10^x for Bfloat16 The source code of 10^x of Bfloat16 is located in source/bfloat16/exp10.cpp. The coefficients used in this source code is located in functiongen/bfloat16/full/headers/exp10.h. The special cases and range reduction technique used in the file should match with the description in Section 5.4.1 (2) Section 5.4.2: ln(x), log2(x), and log10(x) for Bfloat16 The source code of ln(x), log2(x), and log10(x) for Bfloat16 is located in source/bfloat16/log.cpp, source/bfloat16/log2.cpp, and source/bfloat16/log10.cpp, respectively. The coefficients used in these source codes does are located in functiongen/fbloat16/full/header/log.h, functiongen/fbloat16/full/header/log2.h, and functiongen/fbloat16/full/header/log10.h, respectively. The special cases and range reduction technique used in the file should match with the description in Section 5.4.2 (3) Section 5.4.3: log2(x) for 32-bit float The source code of log2(x) for 32-bit float is located in source/float/log2.cpp. The coefficients used in these source code is located in functiongen/float/sampling/log2.h. Since the submission, we made several improvements to ourLibm and the technique. Hence, the range reduction technique and the polynomial used in the implementation is different from the description in Section 5.4.3. The new implementation produces the correct result for ALL inputs, not just inputs between 1 and 2. We provide a script that checks whether our log2(x) function for float produces the correctly rounded result for all inputs. This claim is not a part of our submission, and we provide this script for the completeness. This script will take roughly 2-3 hours to complete. To run the script, use the command: $ ./runFullLog2ForFloat.sh Once the script finishes, you will find LibTestFulLog2Float.txt. This file should say "Function returns correct values for all inputs."

As a substitute for the IEEE 754-2008 floating-point standard, Posit, a new kind of number system for floating-point numbers, was put forward recently. Hitherto, some studies have proven that Posit is a better floating-point style than IEEE 754-2008 in some fields. However, most of these studies presented the advantages of Posit from the arithmetical aspect, but none of them suggested it had a better hardware implementation than that of IEEE 754-2008. In this paper, we propose several hardware implementations that contain the Posit adder/subtractor, multiplier, divider, and square root. Our goal is to achieve an arbitrary Posit format and exploit the minimum circuit area, which is required in embedded devices. To implement the minimum circuit area for the divider and square root, the alternating addition and subtraction method is used rather than the Newton&ndash, Raphson method. Compared with other works, the area of our divider is about 0.2&times, &ndash, 0.7&times, (FPGA). Furthermore, this paper provides the synthesis results for each critical module with the Xilinx Virtex-7 FPGA VC709 platform.

The Big Match is a multistage two-player game. In each stage, player 1 hides one or two pebbles in his hand, and his opponent has to guess that number. Player 1 loses a point if player 2 is correct; otherwise, he wins a point. As soon as player 1 hides one pebble, the players cannot change their choices in any future stage. The undiscounted Big Match has been much-studied. Blackwell and Ferguson (1968) give an [Formula: see text]-optimal strategy for player 1 that hides, in each stage, one pebble with a probability that depends on the entire past history. Any strategy that depends on just the clock or just a finite memory is worthless (i.e., cannot guarantee strictly more than the least reward). The long-standing natural open problem has been whether every strategy that depends on just the clock and a finite memory is worthless. The present paper proves that there is such a strategy that is [Formula: see text]-optimal. In fact, we show that just two states of memory are sufficient.

International audience; In the context of interactive theorem provers based on a dependent type theory, automation tactics (dedicated decision procedures, call of automated solvers, ...) are often limited to goals which are exactly in some expected logical fragment. This very often prevents users from applying these tactics in other contexts, even similar ones. This paper discusses the design and the implementation of pre-processing operations for automating formal proofs in the Coq proof assistant. It presents the implementation of a wide variety of predictible, atomic goal transformations, which can be composed in various ways to target different backends. A gallery of examples illustrates how it helps to expand significantly the power of automation engines.

Even if shared mobility services are encouraged by transportation policies, they remain underused and inefficient transportation modes because they struggle to find their customer base. This paper aims to estimate the potential demand for such services by focusing on individual trips and determining the number of passengers who perform similar trips. Contrary to existing papers, this study focuses on the demand without assuming any specific shared mobility system. The experiment performed on data coming from New York City conducts to cluster more than 85% of the trips. Consequently, shared mobility services such as ride-sharing can find their customer base and, at a long time, to a significantly reduce the number of cars flowing in the city. After a detailed analysis, commonalities in the clusters are identified: regular patterns from one day to the next exist in shared mobility demand. This regularity makes it possible to anticipate the potential shared mobility demand to help transportation suppliers to optimize their operations.

This paper proposes a chaotic color image encryption scheme based on DNA-coding calculations and arithmetic over the Galois field. Firstly, three modified one-dimensional (1D) chaotic maps with larger key space and better chaotic characteristics are presented. The experimental results show that their chaotic intervals are not only expanded to 0,15, but their average largest Lyapunov Exponent reaches 10. They are utilized as initial keys. Secondly, DNA coding and calculations are applied in order to add more permutation of the cryptosystem. Ultimately, the numeration over the Galois field ensures the effect for the diffusion of pixels. The simulation analysis shows that the encryption scheme proposed in this paper has good encryption effect, and the numerical results verify that it has higher security than some of the latest cryptosystems.

This paper proposes a new block encryption algorithm for cryptographic information protection. It describes a new transformation method EM (Exponentiation Module), which is part of the algorithm, and a method of S-box obtaining. The paper also considers an optimization technique to advance the efficiency of key selection and calculation. We discuss the possibility to obtain good results by applying the peculiar properties of cryptographic primitives in the Galois field. To increase the strength and speed of the encryption algorithm, we used a nonpositional polynomial notation and an indexed view for the Galois field. The paper provides for statistical properties of the ciphertext obtained with the developed algorithm. We also present the results of differential and linear cryptanalysis of the S-box used.

The object of the paper are the so-called “unimaginable numbers”. In particular, we deal with some arithmetic and computational aspects of the Knuth’s powers notation and move some first steps into the investigation of their density. Many authors adopt the convention that unimaginable numbers start immediately after 1 googol which is equal to \(10^{100}\), and G.R. Blakley and I. Borosh have calculated that there are exactly 58 integers between 1 and 1 googol having a nontrivial “kratic representation”, i.e., are expressible nontrivially as Knuth’s powers. In this paper we extend their computations obtaining, for example, that there are exactly 2 893 numbers smaller than \(10^{10\,000}\) with a nontrivial kratic representation, and we, moreover, investigate the behavior of some functions, called krata, obtained by fixing at most two arguments in the Knuth’s power \(a\!\uparrow ^b\!c\).

The four layers of human language – form, meaning, function, and value – are systematically integrated in order to play the communicative functions of human interaction. It is not an easy job to explore and to explain the nature of human language as the four layers are systematically integrated in complex ways. Thus, the linguistic studies should be held in specific domains and topics by means of appropriate theoretical bases and frameworks. This paper, which is mainly inspired by the grammatical-typological analysis on prefix ba- in Minangkabaunese, particularly discusses how the language features are linguistically analyzed in order to come to logic, valid, reliable findings and conclusion. The discussion presented in this paper aims at proposing logical and reasonable ways of doing linguistic analyses on available data of language. In short, this paper deals with how to begin and to do linguistic analyses toward a group of language data collected. In this paper, the prefix ba- of Minangkabaunese is used as the example of case. The discussion presented in this paper respectively answers two main questions; (i) What should be firstly analyzed dealing with the prefix ba- of Minangkabaunese?; and (ii) How are the linguistic analyses toward the prefix ba- of Minangkabaunese logically continued?

This paper is an extension of work originally presented in conference name” Study Performance of Speed Tracking Control with Frequency and Amplitude Dependence”. Though many PMSMs (Permanent Magnet Synchronous Motor) control approach have already been published, little endeavors have been invested in the study of speed tacking control with frequency or amplitude dependence. The use of NDI (Nonlinear Dynamic Inversion) tracking control in versus amplitude and frequency dependence is the major focus of this paper. The proposed tracking control demonstrates that NDI control presents the ability to track the desired output with high precision. PMSM outputs are characterized at different amplitude and frequency. The speed and the direct current versus amplitude and frequency are successfully extracted. A mathematical (d-q) of the permanent magnet synchronous motor model is also presented. A comparative study between desired data and simulation results is conducted. Important to note, the proposed model and the simulation results reflect a successful agreement as far as a amplitude and frequency dependence is concerned. A new validity approach, namely “Validity Abacus” is proposed and discussed.

This paper presents an input-series-output-series modular multilevel dc transformer (ISOS-M2DCT) with an inter-module arithmetic phase interleaving control (IAPIC) for high-voltage dc transmission and medium-voltage dc distribution application. The presented ISOS-M2DCT has several advantages over conventional dual active bridge (DAB)-based dc transformer (DAB-DCT) and M2DCTs. It possesses a higher power capacity, a dc fault tolerant superiority, and a higher power factor in heavy load than DAB-DCT; it simplifies the manufacturing of ac link transformers and averts the problem of circulating currents among different modules compared with M2DCTs. The introduced IAPIC is able to cut down the dc ripples without any rise in volume of passive elements, thereby making it easier to realize the compact design of ISOS-M2DCT. In this paper, the topology, operation principle, modulation strategy, basic control scheme, power characterization, the generating mechanism of dc ripples, and the IAPIC scheme are proposed and analyzed successively. Finally, an ISOS-M2DCT prototype is built, and the proposed method is verified by simulation and experimental results.

The pandemic of Covid-19 has caused a shift of paradigm of education, from face-to-face to e-learning. E-learning leads to an escalation in digitalization of handwritten documents because it requires submission of homework and assignments through online. To help teachers in checking digitalized handwritten homework, this paper proposes an automatic checking system based on a convolutional neural network (CNN) for handwritten numeral recognition. The CNN is used to recognize four arithmetic operations in mathematical questions consisting of addition, deduction, multiplication and division. The performance CNN in handwritten numeral recognition have been optimized in terms of activation function and gradient descent algorithm. The proposed CNN is also trained and tested with the MNIST handwritten data set. The experimental results show that the recognition accuracy the improved CNN improves to a certain extent as compared to before optimization.

Ultrasound imaging is a largely used medical imaging system as it is safe, non-invasive, and capable of real-time imaging. In ultrasound imaging, different beamforming methods are used to obtain the image of the field of view. The image quality largely depends on the type of beamforming used in ultrasound imaging. To make the ultrasound imaging system portable, beamforming system needs to be implemented as compact hardware architecture. Dynamic focusing and adaptive apodization are used in beamforming systems to generate high-quality ultrasound images, however, their implementation into the hardware requires large hardware resource which consumes high power. This paper presents the implementation of a compact receive beamformer architecture using a hardware-efficient dynamic delay calculator, an IEEE single-precision arithmetic based adaptive apodization system architecture and a focusing mechanism. The proposed beamformer provides real-time beamforming output which can be used to display high quality ultrasound images. Field-II toolbox is used to simulate and verify the beamformer output. The proposed beamformer consumes 1370k NAND-2 gate equivalent logic resources in UMC 90 nm CMOS standard cell library.

Watson-Crick (WK) finite automata are working on a Watson-Crick tape, that is, on a DNA molecule. Therefore, it has two reading heads. While in traditional WK automata both heads read the whole input in the same physical direction, in 5'->3' WK automata the heads start from the two extremes and read the input in opposite direction. In sensing 5'->3' WK automata the process on the input is finished when the heads meet. Since the heads of a WK automaton may read longer strings in a transition, in previous models a so-called sensing parameter took care for the proper meeting of the heads (not allowing to read the same positions of the input in the last step). In this paper, a new model is investigated, which works without the sensing parameter (it is done by an appropriate change of the concept of configuration). Consequently, the accepted language classes of the variants are also changed. Various hierarchy results are proven in the paper., In Proceedings AFL 2017, arXiv:1708.06226

Canonic real-valued fast Fourier transform (RFFT) has been proposed to reduce the arithmetic complexity by eliminating redundancies. In a canonic N-point RFFT, the number of signal values at each stage is canonic with respect to the number of signal values, i.e., N. The major advantage of the canonic RFFTs is that these require the least number of butterfly operations and only real datapaths when mapped to architectures. In this paper, we consider the FFT computation whose inputs are not only real but also even/odd symmetric, which indeed lead to the well-known discrete cosine and sine transforms (DCTs and DSTs). Novel algorithms for generating the flow graphs of canonic RFFTs with even/odd symmetric inputs are proposed. It is shown that the proposed algorithms lead to canonic structures with $\frac {N}{2}+1$ signal values at each stage for an N-point real even symmetric FFT (REFFT) or $\frac {N}{2}-1$ signal values at each stage for an N-point RFFT real odd symmetric FFT (ROFFT). In order to remove butterfly operations, several twiddle factor transformations are proposed in this paper. We also discuss the design of canonic REFFT for any composite length. Performances of the canonic REFFT/ROFFT are also discussed. It is shown that the flow graph of canonic REFFT/ROFFT has less number of interconnections, less butterfly operations, and less twiddle factor operations, compared to prior works.

In this paper, we present an eight round distinguisher for four-branch type-2 generalized Feistel network (GFN) with double-SP (DSP) functions and two distinguishers for eight-branch type-2 GFN with single-SP (SSP) functions in a known key attack (KKA) model. We improved the result presented by Sasaki in Indocrypt 2012 by extending the number of rounds attacked from seven to eight for four-branch GFN. Furthermore, for eight-branch type-2 GFN with SSP functions, we present the first known key distinguishers. Our attack works up to 15 rounds of this GFN for all practical parameters. Subsequently, we extend the attack to 17 rounds for the same GFN, which works for most practical parameters. On the basis of our second result and the number of rounds attacked, we conclude that eight-branch type-2 GFN with SSP functions is weaker than four-branch type-two GFN with DSP functions in the KKA model. We apply rebound attack technique to mount all three distinguishers. However, a limitation of all the distinguishers presented in this paper is that they are useful only if the input size of S-boxes in bits is greater than or equal to the number of S-boxes in one S-box layer.

The paper investigates a nonlinear substitution transformation, presented as an element of the number system of factorial sets. This approach takes into account the characteristic features of substitutions and al-lows you to minimize the amount of memory for storing. Based on the unambiguous numbering approach for substitutions, three methods of storing in memory are considered: in the form of a vector, in the form of values of cyclic shifts of elements of an identical substitution, and in the form of a decimal substitution number. The results of the analysis of the amount of data required for storing the nonlinear substitution transformation for cryptographic primitives are presented. The complexity of translating the transformed substitutions into the standard form of storage by a vector is determined. The obtained results can be ap-plied in software solutions for ensuring information security using cryptographic primitives containing a nonlinear substitution transformation. The proposed approach to writing in the form of substitution trans-formations is recommended for implementation in complexes with a limited amount of memory.

In this paper, optimal bounds for the sine and hyperbolic tangent means by arithmetic and centroidal means in exponential type are established using the monotone form of L'Hospital's rule and the criterion for the monotonicity of the quotient of power series.

Let \(C\) be the middle-third Cantor set. Define \(C*C=\{x*y\colon x,y\in C\}\), where \(*=+,-,\cdot,\div\) (when \(*=\div\), we assume \(y\neq0\)). Steinhaus [17] proved in 1917 that \(C-C=[-1,1]\), \(C+C=[0,2]\). In 2019, Athreya, Reznick and Tyson [1] proved that \(C\div C=\bigcup_{n=-\infty}^{\infty}\left[ 3^{-n}\dfrac{2}{3},3^{-n}\dfrac {3}{2}\right] \cup \{0\}\). In this paper, we give a description of the topological structure and Lebesgue measure of \(C\cdot C\). We indeed obtain corresponding results on the uniform \(\lambda\)-Cantor sets.

This is the behavioral and VBM dataset described in "Arithmetic skills are associated with grey matter volume in the left inferior frontal gyrus: A brain-wide association study with 536 children and adolescents". Raw MRI data for four of the datasetsincluded in the study are available at OpenNeuro (https://openneuro.org/datasets/ds001486/versions/1.3.1, https://openneuro.org/datasets/ds001894/versions/1.4.1, https://openneuro.org/datasets/ds002886/versions/1.1.0, and https://openneuro.org/datasets/ds002424/versions/1.2.0).Because of anonymization concerns withinthe framework of EU privacy regulations (GDPR) regarding two of the other datasets, we cannot provide raw MRI data. Therefore, the MRI data here consistof individualpre-processed volumes, normalized into the MNItemplate (see paper for details about the preprocessing pipeline). Anonymized second level behavioral data (with z-transformed scores, see manuscript for details) and whole-brain unthresholded t-maps corresponding to Fig. 1 and Fig. 2 are also provided. If you have any questions, please send an email to jerome.prado [at] univ-lyon1.fr.

International audience; Anonymous shared memory is a memory in which processes use different names for the same shared read/write register. As an example, a shared register named A by a process p and a shared register named B by another process q can correspond to the very same register X, and similarly for the names B at p and A at q which can correspond to the same register Y = X. Hence, there is a permanent disagreement on the register names among the processes. This new notion of anonymity was recently introduced by G. Taubenfeld (PODC 2017), who presented several memory-anonymous algorithms and impossibility results. This paper introduces a new problem, that consists in "de-anonymizing" an anonymous shared memory. To this end, it presents an algorithm that, starting with a shared memory made up of m anonymous read/write atomic registers (i.e., there is no a priori agreement on their names), allows each process to compute a local addressing mapping, such that all the processes agree on the names of each register. The proposed construction is based on an underlying deadlock-free mutex algorithm for n ≥ 2 processes (recently proposed in a paper co-authored by some of the authors of this paper), and consequently inherits its necessary and sufficient condition on the size m of the anonymous memory, namely m must belong to the set M (n) = {m : such that ∀ ℓ : 1 < ℓ ≤ n : gcd(ℓ, m) = 1} \ {1}. This algorithm, which is also symmetric in the sense process identities can only be compared by equality, requires the participation of all the processes; hence it can be part of the system initialization. Last but not least, the proposed algorithm has a noteworthy first-class property, namely, its simplicity.

International audience; The present paper considers an important cultural treasure in the early Swedish history of mathematics education. After the reformation in the 16th century it became possible to study mathematics in Sweden. The first printed textbook in Swedish on arithmetic appeared in 1614, but already in 1601, the oldest known manuscript in Swedish on arithmetic was written by Hans Larsson Rizanesander. In this paper we investigate Rizanesander’s manuscript in its historical context.

In this paper, a new simplified iterative division algorithm for modular numbers that is optimized on the basis of the Chinese remainder theorem (CRT) with fractions is developed. It requires less computational resources than the CRT with integers and mixed radix number systems (MRNS). The main idea of the algorithm is (a) to transform the residual representation of the dividend and divisor into a weighted fixed-point code and (b) to find the higher power of 2 in the divisor written in a residue number system (RNS). This information is acquired using the CRT with fractions: higher power is defined by the number of zeros standing before the first significant digit. All intermediate calculations of the algorithm involve the operations of right shift and subtraction, which explains its good performance. Due to the abovementioned techniques, the algorithm has higher speed and consumes less computational resources, thereby being more appropriate for the multidigit division of modular numbers than the algorithms described earlier. The new algorithm suggested in this paper has O (log2 Q) iterations, where Q is the quotient. For multidigit numbers, its modular division complexity is Q(N), where N denotes the number of bits in a certain fraction required to restore the number by remainders. Since the number N is written in a weighed system, the subtraction-based comparison runs very fast. Hence, this algorithm might be the best currently available.

Error Correction Codes (ECCs) are commonly used to protect memories against soft errors with an impact on memory area and delay. For large memories, the area overhead is mostly due to the additional cells needed to store the parity check bits. In terms of delay, the overhead is mostly needed to detect and correct errors when the data is read from the memory. Most ECCs that can correct more than one error have a complex decoding process and so are limited in high speed memory applications. One exception is One Step Majority Logic Decodable (OS-MLD) codes for which decoding can be done in parallel at high speed. Unfortunately, there are only a few OS-MLD codes that provide a limited choice in terms of block sizes, error correction capabilities and code rate. Therefore, there is considerable interest in a novel construction of OS-MLD codes to provide additional choices for protecting memories. In this paper, a new method to construct Double Error Correction (DEC) OS-MLD codes is presented. This method is based on the use of parity check matrices in which two bits have at most two parity check equations in common; the proposed method provides codes that require a smaller number of parity check bits than existing codes like Orthogonal Latin Square (OLS) codes. The drawback of the proposed Two Bit Overlap (TBO) codes is that they require slightly more complex decoding than OLS codes. Therefore, they provide an intermediate solution between OLS and non OS-MLD codes in terms of decoding delay and number of parity check bits. The proposed TBO codes have been implemented for some block sizes and compared to both OLS and BCH codes to illustrate the trade off in delay and memory overhead. Finally, this paper discusses the generalization of the proposed scheme to codes with larger error correction capabilities. Publicado

This paper proposes an analysis of and a reflection on interval arithmetic (IA) and its extension to gradual interval arithmetic (GIA). Through this reflection, an overview of a part of IA that is directly related to fuzzy interval arithmetic (FIA) is analyzed, compared, and categorized according to two main families of IA: standard interval arithmetic (SIA) and instantiated interval arithmetic (IIA). Furthermore, SIA and IIA visions represent two viewpoints of computation that are different and they will cause modifications in interval interpretation and manipulation. This vision is essential in understanding the philosophy of IA and GIA computational mechanisms. The contribution of this paper is twofold. First, according to SIA and IIA visions, an analysis and a classification of a part of IAs are given. Equivalences and links between these IAs are analyzed and established. Second, an extension of IA to the gradual context is proposed. The GIA extension provides a new interpretation of FIA according to the gradual representation.