Integer Arrays Research Articles

Fast Access for Star Catalog Based on Locality-Sensitive Hashing

In order to improve the access speed and robustness of star catalog database during star identification, an algorithm based on locality-sensitive hashing is proposed. First, according to principle of star identification, the angle distances are quantified on the basis of angle distance error limit, and the order star set pattern is transformed into an array of integers, which has locally sensitive hash characteristics. Then key of hash obtain by hashing the array of integers with Stlport, and the value of hashing is a set of central star number in the ordered star point set pattern. Numerical simulation results indicate that the time complexity of proposed algorithm is O(1), which is much better than direct search, binary search and k-vector search technology. In addition, the proposed algorithm is robustness due to the affect is not significant as the performance influenced by angle distance error limit. Considering practical application, the error limit of angle distance could be chose as 1 pixel, the number of quantified angle distances could be chosen as 3. Under this condition, the collision rate in hashing table is 0.74%, the average searching time is 1.007 4 and the average consuming time is 22 μs during star identification.

ВИКОРИСТАННЯ ШАБЛОНУ АСИНХРОННОЇ ВЗАЄМОДІЇ ПОТОКІВ ДЛЯ ВІЗУАЛІЗАЦІЇ ВИБРАНИХ АЛГОРИТМІВ СОРТУВАННЯ В СЕРЕДОВИЩІ .NET

The article describes the process of the multithread application construction for the .Net framework. The application main thread interacts with the graphic user interface and with several other ones, which execute different sorting algorithms on arrays of integers. Every step of the execution displays on the application window. The article focuses on efficient ways to organize the threads interaction and on the application architecture. To execute and to control a sorting thread we use the self-produced C# class that encapsulates the .Net component Backgroundworker – event- based asynchronous pattern. Key words: multithread application, programming language C#, Backgroundworker, program event, sorting algorithm, graphic visualization.

Constant term formulas for refined enumerations of Gog and Magog trapezoids

Gog and Magog trapezoids are certain arrays of positive integers that generalize alternating sign matrices (ASMs) and totally symmetric self-complementary plane partitions (TSSCPPs) respectively. Zeilberger used constant term formulas to prove that there is the same number of (n,k)-Gog trapezoids as there is of (n,k)-Magog trapezoids, thereby providing so far the only proof for a weak version of a conjecture by Mills, Robbins and Rumsey from 1986. About 20 years ago, Krattenthaler generalized Gog and Magog trapezoids and formulated an extension of their conjecture, and, recently, Biane and Cheballah generalized Gog trapezoids further and formulated a related conjecture. In this paper, we derive constant term formulas for various refined enumerations of generalized Gog trapezoids including those considered by Krattenthaler and by Biane and Cheballah. For this purpose we employ a result on the enumeration of truncated monotone triangles which is in turn based in the author's operator formula for the number of monotone triangles with prescribed bottom row. As a byproduct, we also generalize the operator formula for monotone triangles by including the inversion number and the complementary inversion number for ASMs. Constant term formulas as well as determinant formulas for the refined Magog trapezoid numbers that appear in Krattenthaler's conjecture are also deduced by using the classical approach based on non-intersecting lattice paths and the Lindström–Gessel–Viennot theorem. Finally, we review and partly extend a few existing tools that may be helpful in relating constant term formulas for Gogs to those for Magogs to eventually prove the above mentioned conjectures.

The role of “Prominent Numbers” in open numerical judgment: Strained decision makers choose from a limited set of accessible numbers

Numerate adults can represent an infinite array of integers. When a judgment requires them to “pick a number,” how do they select one to represent the abstract signal in mind? Drawing from research on the cognitive psychology of number representation, we conjecture that judges who operate primarily in decimal systems simplify by initially selecting from a set of chronically accessible “Prominent Numbers” defined as the powers of ten, their doubles, and their halves [… 5, 10, 20, 50, 100, 200…]; then, when willing and able, refining from there. A sample of 3 billion stock trades reveals that traders’ decisions reflect Prominent-Number clustering (Study 1) and a “natural experiment” reveals more clustering in rushed trading conditions (Study 2). Three sets of subsequent studies provide evidence consistent with an accessibility-based account of Prominent-Number usage: Experiments show that judges rely more on Prominent Numbers when they are induced to rush rather than take their time (Studies 3a and 3b), and when they are under high versus low cognitive load (Studies 4a, 4b, and 4c); and a final correlational study shows that Prominent-Number clustering is more apparent for judgments that require judges to scan a wider range of plausible values (Study 5). This work underscores the need to differentiate between Round Numbers and Prominent Numbers, and between representational properties of graininess and accessibility, in numerical judgment.

The Role of 'Prominent Numbers' in Open Numerical Judgment: Strained Decision Makers Choose from a Limited Set of Accessible Numbers

Numerate adults can represent an infinite array of integers. When a judgment requires them to pick a number, how do they select one to represent the abstract signal in mind? Drawing from research on the cognitive psychology of number representation, we conjecture that judges who operate primarily in decimal systems simplify by initially selecting from a set of chronically accessible defined as the powers of ten, their doubles, and their halves [... 5, 10, 20, 50, 100, 200...]; then, when willing and able, refining from there. A sample of 3 billion stock trades reveals that traders' decisions reflect Prominent-Number clustering (Study 1) and a natural experiment reveals more clustering in rushed trading conditions (Study 2). Three sets of subsequent studies provide evidence consistent with an accessibility-based account of Prominent-Number usage: Experiments show that judges rely more on Prominent Numbers when they are induced to rush rather than take their time (Studies 3a and 3b), and when they are under high versus low cognitive load (Studies 4a, 4b, and 4c); and a final correlational study shows that Prominent-Number clustering is more apparent for judgments that require judges to scan a wider range of plausible values (Study 5). This work underscores the need to differentiate between Round Numbers and Prominent Numbers, and between representational properties of graininess and accessibility, in numerical judgment.

A parallel time-memory tradeoff attack on the Hill cipher

ABSTRACTLeap et al. (2016) reduced the time complexity of the Bauer-Millward (2007) ciphertext-only attack on the Hill cipher from 𝒪(Ln) to 𝒪(Ln−1), where L is the length of the alphabet, and n is the block size. This article presents an attack that reduces the complexity to 𝒪(Ln−1−s), 0 ≤ s ≤ n − 1. The practical limitation on the size of s is the memory available on the computer being used for the attack. Specifically, the computer must be able to hold Ls integer arrays of length N, where N is the number of blocks of ciphertext. The key idea is not to iterate over potential rows of the decryption matrix, but to iterate over randomly chosen characters in the plaintext. This attack also admits a straightforward parallel implementation on multiple processors to further decrease the run time of the attack.

Stream VByte: Faster byte-oriented integer compression

Arrays of integers are often compressed in search engines. Though there are many ways to compress integers, we are interested in the popular byte-oriented integer compression techniques (e.g., VByte or Google's varint-GB). Although not known for their speed, they are appealing due to their simplicity and engineering convenience. Amazon's varint-G8IU is one of the fastest byte-oriented compression technique published so far. It makes judicious use of the powerful single-instruction-multiple-data (SIMD) instructions available in commodity processors. To surpass varint-G8IU, we present Stream VByte, a novel byte-oriented compression technique that separates the control stream from the encoded data. Like varint-G8IU, Stream VByte is well suited for SIMD instructions. We show that Stream VByte decoding can be up to twice as fast as varint-G8IU decoding over real data sets. In this sense, Stream VByte establishes new speed records for byte-oriented integer compression, at times exceeding the speed of the memcpy function. On a 3.4 GHz Haswell processor, it decodes more than 4 billion differentially-coded integers per second from RAM to L1 cache.

Hook formulas for skew shapes I. q-analogues and bijections

The celebrated hook-length formula gives a product formula for the number of standard Young tableaux of a straight shape. In 2014, Naruse announced a more general formula for the number of standard Young tableaux of skew shapes as a positive sum over excited diagrams of products of hook-lengths. We give an algebraic and a combinatorial proof of Naruse's formula, by using factorial Schur functions and a generalization of the Hillman–Grassl correspondence, respectively.The main new results are two different q-analogues of Naruse's formula: for the skew Schur functions, and for counting reverse plane partitions of skew shapes. We establish explicit bijections between these objects and families of integer arrays with certain nonzero entries, which also proves the second formula.

Reconstructing a string from its Lyndon arrays

Given a string x=x[1..n] on an ordered alphabet Σ of size σ, the Lyndon array λ=λx[1..n] of x is an array of positive integers such that λ[i],1≤i≤n, is the length of the maximal Lyndon word over the ordering of Σ that begins at position i in x. The Lyndon array has recently attracted considerable attention due to its pivotal role in establishing the long-standing conjecture that ρ(n)<n, where ρ(n) is the maximum number of maximal periodicities (runs) in any string of length n. Here we first describe two linear-time algorithms that, given a valid Lyndon array λ, compute a corresponding string — one for an alphabet of size n, the other for a smaller alphabet. We go on to describe another linear-time algorithm that determines whether or not a given integer array is a Lyndon array of some string. Finally we show how σ Lyndon arrays λΣ={λ1=λ,λ2,…,λσ} corresponding to σ “rotations” of the alphabet can be used to determine uniquely the string x on Σ such that λx=λ.

Program Verification using Constraint Handling Rules and Array Constraint Generalizations*

The transformation of constraint logic programs (CLP programs) has been shown to be an effective methodology for verifying properties of imperative programs. By following this methodology, we encode the negation of a partial correctness property of an imperative program prog as a predicate incorrect defined by a CLP program P , and we show that prog is correct by transforming P into the empty program through the application of semantics preserving transformation rules. Some of these rules perform replacements of constraints that encode properties of the data structures manipulated by the program prog. In this paper we show that Constraint Handling Rules (CHR) are a suitable formalism for representing and applying constraint replacements during the transformation of CLP programs. In particular, we consider programs that manipulate integer arrays and we present a CHR encoding of a constraint replacement strategy based on the theory of arrays. We also propose a novel generalization strategy for constraints on integer arrays that combines the CHR constraint replacement strategy with various generalization operators for linear constraints, such as widening and convex hull. Generalization is controlled by additional constraints that relate the variable identifiers in the imperative program prog and the CLP representation of their values. The method presented in this paper has been implemented and we have demonstrated its effectiveness on a set of benchmark programs taken from the literature.

Specialization of Generic Array Accesses After Inlining

We have implemented an optimization that specializes type-generic array accesses after inlining of polymorphic functions in the native-code OCaml compiler. Polymorphic array operations (read and write) in OCaml require runtime type dispatch because of ad hoc memory representations of integer and float arrays. It cannot be removed even after being monomorphized by inlining because the intermediate language is mostly untyped. We therefore extended it with explicit type application like System F (while keeping implicit type abstraction by means of unique identifiers for type variables). Our optimization has achieved up to 21% speed-up of numerical programs.

GUE corners limit of $q$-distributed lozenge tilings

We study asymptotics of $q$-distributed random lozenge tilings of sawtooth domains (equivalently, of random interlacing integer arrays with fixed top row). Under the distribution we consider each tiling is weighted proportionally to $q^{\mathsf{vol} }$, where $\mathsf{vol} $ is the volume under the corresponding 3D stepped surface. We prove the following Interlacing Central Limit Theorem: as $q\rightarrow 1$, the domain gets large, and the fixed top row approximates a given nonrandom profile, the vertical lozenges are distributed as the eigenvalues of a GUE random matrix and of its successive principal corners. Our results extend the GUE corners asymptotics for tilings of bounded polygonal domains previously known in the uniform (i.e., $q=1$) case. Even though $q$ goes to $1$, the presence of the $q$-weighting affects non-universal constants in our Central Limit Theorem.

Isomorphism of Integer Array of Staircase Paths

Isomorphism of Integer Array of Staircase Paths

Optimization of scheduled cleaning of fouled heat exchanger network under ageing using genetic algorithm

The problem of heat exchanger network (HEN) fouling and ageing has been a costly feature of chemical and petrochemical industries, particularly, the oil refineries. In this paper, a strategy to determine the optimal cleaning schedule of the crude oil refinery's preheat train (PHT) under fouling and different ageing scenarios (i.e., slow and fast ageing) is addressed by a specialized Genetic Algorithm (GA) which uses an array of discrete and positive integers as chromosome representation. Specifically, the effect of key cleaning decision factors (i.e., which, when and how to clean), dictated by the GA, on optimal cleaning schedules based on both thermal and economic behavior of the PHT was studied. The results highlight the efficacy of the GA and a novel chromosome application to the optimization of complex cleaning scheduling. Considerable savings are achieved by the implementation of optimum cleaning schedules for all the ageing scenarios compared with un-optimized cleaning or no cleaning performed in a case study involving a 14-unit crude oil refinery HEN. Fast ageing led to significant reduction in energy losses, and hence, improved heat recovery and fewer number of cleanings due to the higher formation rate of a more thermally conductive coke, compared with slow ageing.

A Comparison of Sorting Times between Java 8 and Parallel Colt

An exploratory experiment found that sorting arrays of random integers using Java 8's parallel sort required only 50%-70% of the time taken using the parallel sort of the Parallel Colt library. Factors considered responsible for the performance advantage include the use of a dual-pivot quicksort on locally held data at certain phases of execution and work-stealing by threads, a feature of the fork-join framework. The default performance of Parallel Colt's parallel sort was found to degrade dramatically for small array sizes due to unnecessary thread creation.

Tight Heffter Arrays Exist for all Possible Values

A tight Heffter array H(m,n) is an m×n matrix with nonzero entries from Z2mn+1 such that (i) the sum of the elements in each row and each column is 0, and (ii) no element from {x,−x} appears twice. We prove that H(m,n) exist if and only if both m and n are at least 3. If H has the property that all entries are integers of magnitude at most mn, every row and column sum is 0 over the integers, and H also satisfies (ii), we call H an integer Heffter array. We show integer Heffter arrays exist if and only if mn≡0,3(mod4). Finally, an integer Heffter array is shiftable if each row and column contains the same number of positive and negative integers. We show that shiftable integer arrays exists exactly when both m,n are even.

Bound Analysis for Whiley Programs

The Whiley compiler can generate naive C code, but the code is inefficient because it uses infinite integers and dynamic array sizes. Our project goal is to build up a compiler that can translate Whiley programs into efficient OpenCL code with fixed-size integer types and fixed-size arrays, for parallel execution on GPUs. This paper presents an abstract interpretation-based bound inference approach along with symbolic analysis for Whiley programs. The source Whiley program is first analyzed by using our symbolic analyzer to find the matching pattern and make any necessary program transformation. Then the bound analyzer is used to analyze the transformed program to make use of primitive integer types rather than third-party infinite integer type (e.g. using GMP arbitrary precision library). The bound analysis results provide conservative estimates of the ranges of integer variables and array sizes so that efficient code can be generated and integer overflows avoided. The bound analyzer combines the bound consistency technique along with a widening operator to give fast time of solving program constraints and of converging to the fixed point. Several example programs are used to illustrate the bound analyzer algorithm and the program transformation.

New Bounds and Extended Relations Between Prefix Arrays, Border Arrays, Undirected Graphs, and Indeterminate Strings

We extend earlier works on the relation of prefix arrays of indeterminate strings to undirected graphs and border arrays. If integer array y is the prefix array for indeterminate string w, then we say w satisfies y. We use a graph theoretic approach to construct a string on a minimum alphabet size which satisfies a given prefix array. We relate the problem of finding a minimum alphabet size to finding edge clique covers of a particular graph, allowing us to bound the minimum alphabet size by n+n$n+\sqrt {n}$ for indeterminate strings, where n is the size of the prefix array. When we restrict ourselves to prefix arrays for partial words, we bound the minimum alphabet size by 2n$\left \lceil \sqrt {2n} \right \rceil $. Moreover, we show that this bound is tight up to a constant multiple by using Sidon sets. We also study the relationship between prefix arrays and border arrays. We give necessary and sufficient conditions for a border array and prefix array to be satisfied by the same indeterminate string. We show that the slowly-increasing property completely characterizes border arrays for indeterminate strings, whence there are exactly Cn distinct border arrays of size n for indeterminate strings (here Cn is the nth Catalan number). We give an algorithm to enumerate all prefix arrays for partial words of a given size, n. Our algorithm has a time complexity of n3 times the output size, that is, the number of valid prefix arrays for partial words of length n. We also bound the number of prefix arrays for partial words of a given size using Stirling numbers of the second kind.

A Rule-based Verification Strategy for Array Manipulating Programs

We present a method for verifying properties of imperative programs that manipulate integer arrays. Imperative programs and their properties are represented by using Constraint Logic Programs (CLP) over integer arrays. Our method is refutational. Given a Hoare triple {ϕ} prog {ψ} that defines a par tial correctness property of an imperative program prog, we encode the negation of the property as a predicate incorrect defined by a CLP program P, and we show that the property holds by proving that incorrect is not a consequence of P. Program verification is performed by applying a sequence of semantics preserving transformation rules and deriving a new CLP program T such that incorrect is a consequence of P iff it is a consequence of T. The rules are applied according to an automatic strategy whose objective is to derive a program T that satisfies one of the following properties: either (i) T is the empty set of clauses, hence proving that incorrect does not hold and prog is correct, or (ii) T contains the fact incorrect, hence proving that prog is incorrect. Our transformation strategy makes use of an axiomatization of the theory of arrays for the manipulation of array constraints, and also applies the widening and convex hull operators for the generalization of linear integer constraints. The strategy has been implemented in the VeriMAP transformation system and it has been shown to be quite effective and efficient on a set of benchmark array programs taken from the literature.

Indeterminate strings, prefix arrays & undirected graphs

An integer array y=y[1..n] is said to be feasible if and only if y[1]=n and, for every i∈2..n, i≤i+y[i]≤n+1. A string is said to be indeterminate if and only if at least one of its elements is a subset of cardinality greater than one of a given alphabet Σ; otherwise it is said to be regular. A feasible array y is said to be regular if and only if it is the prefix array of some regular string. We show using a graph model that every feasible array of integers is a prefix array of some (indeterminate or regular) string, and for regular strings corresponding to y, we use the model to provide a lower bound on the alphabet size. We show further that there is a 1–1 correspondence between labelled simple graphs and indeterminate strings, and we show how to determine the minimum alphabet size σ of an indeterminate string x based on its associated graphGx. Thus, in this sense, indeterminate strings are a more natural object of combinatorial interest than the strings on elements of Σ that have traditionally been studied.