arXiv subjects
Publications and source records attributed to Alexandros V. Gerbessiotis.
We present two algorithms based on the Newton-Raphson method to calculate the floor of y**(1/m) for natural integer numbers y>2 and m >1. One could use such an algorithm to establish whether y is an integer power of an integer in number theory problems, even though binary search methods are traditionally considered simpler to implement.
This brief, in the form of an e-book, is a collection of notes that cover elementary and medium level number theory with a target audience of primarily computer science students. It can be used in the number theory portion of a discrete mathematics course, or a course on the mathematical foundations of computer science, or as background material for a cryptography course. Thematically it is split into five areas that map to chapters. The first chapter is introductory and covers topics including divisibility, prime numbers, and modular arithmetic including modular linear equations. The second chapter covers additional topics such as Euler's totient function, units and inverses, the Chinese remainder theorem, and Fermat's and Euler's theorems. The following chapter covers primitive roots, quadratic residues, the Jacobi and Legendre symbols, Gauss's lemma and Eisenstein's theorem, and briefly discusses applications of number theory to cryptography. The fourth chapter is focused on traditional primality testing methods covering Miller's algorithms, Rabin's conversion of a Miller algorithm into a probabilistic primality test algorithm, Solovay-Strassen's algorithm and several other peripheral results including Carmichael numbers and the equivalence of Miller's two algorithms. Finally the last brief chapter can be viewed as an introduction to more advanced elements of number theory and its coverage includes multiplicative functions, the Möbius function, Dirichlet products and Dirichlet and Möbius inversions. Different parts of this e-book are for freshman to senior undergraduate students in computing and in particular computer science. Graduate students with limited exposure to number theory can use it to acquire a background suitable for typical cryptography courses at the master's level.
This is a survey paper that discusses the original bounds of the seminal papers by Chernoff and Hoeffding. Moreover, it includes a variety of derivative bounds in a variety of forms. Complete proofs are provided as needed. The intent is to provide a repository of reference bounds for the interested researcher.
Integer sorting on multicores and GPUs can be realized by a variety of approaches that include variants of distribution-based methods such as radix-sort, comparison-oriented algorithms such as deterministic regular sampling and random sampling parallel sorting, and network-based algorithms such as Batcher's bitonic sorting algorithm. In this work we present an experimental study of integer sorting on multicore processors. We have implemented serial and parallel radix-sort for various radixes, deterministic regular oversampling and random oversampling parallel sorting, and also some previously little explored or unexplored variants of bitonic-sort and odd-even transposition sort. The study uses multithreading and multiprocessing parallel programming libraries with the C language implementations working under Open MPI, MulticoreBSP, and BSPlib utilizing the same source code. A secondary objective is to attempt to model the performance of these algorithm implementations under the MBSP (Multi-memory BSP) model. We first provide some general high-level observations on the performance of these implementations. If we can conclude anything is that accurate prediction of performance by taking into consideration architecture dependent features such as the structure and characteristics of multiple memory hierarchies is difficult and more often than not untenable. To some degree this is affected by the overhead imposed by the high-level library used in the programming effort. We can still draw however some reliable conclusions and reason about the performance of these implementations using the MBSP model, thus making MBSP useful and usable.
There have been many proposals for sorting integers on multicores/GPUs that include radix-sort and its variants or other approaches that exploit specialized hardware features of a particular multicore architecture. Comparison-based algorithms have also been used. Network-based algorithms have also been used with primary example Batcher's bitonic sorting algorithm. Although such a latter approach is theoretically "inefficient", if there are few keys to sort, it can lead to better running times as it has low overhead and is simple to implement. In this work we perform an experimental study of integer sorting on multicore processors using not only multithreading but also multiprocessing parallel programming approaches. Our implementations work under Open MPI, MulticoreBSP, and BSPlib. We have implemented serial and parallel radix-sort for various radixes and also some previously little explored or unexplored variants of bitonic-sort and odd-even transposition sort. We offer our observations on a performance evaluation using the MBSP model of such algorithm implementations on multiple platforms and architectures and multiple programming libraries. If we can conclude anything is that modeling their performance by taking into consideration architecture dependent features such as the structure and characteristics of multiple memory hierarchies is difficult and more often than not unsuccessful or unreliable. However we can still draw some very simple conclusions using traditional architecture independent parallel modeling.
The Bulk-Synchronous Parallel model of computation has been used for the architecture independent design and analysis of parallel algorithms whose performance is expressed not only in terms of problem size n but also in terms of parallel machine properties. In this paper the performance of implementations of deterministic and randomized BSP sorting algorithms is examined. The deterministic algorithm uses deterministic regular oversampling and parallel sample sorting and is augmented to handle duplicate keys transparently with optimal asymptotic efficiency. The randomized algorithm is sample-sort based and uses oversampling and the ideas introduced with the deterministic algorithm. The resulting randomized design, however, works differently from traditional parallel sample-sort based algorithms and is also augmented to transparently handle duplicate keys with optimal asymptotic efficiency thus eliminating the need to tag all input keys and to double communication/computation time. Both algorithms are shown to balance the work-load evenly among the processors and the use and precise tuning of oversampling that the BSP analysis allows combined with the transparent duplicate-key handling insures regular and balanced communication.