Search

In this paper, the performance of Binary Increase Adaptive Decrease (TCP-BIAD) congestion control algorithm in high-speed long-distance networks is evaluated. As its name implies, this TCP variant is a combination of an enhanced binary increase algorithm during the congestion avoidance phase with the adaptive decrease mechanism of TCP Westwood after a packet loss episode. We also propose a mathematical analysis of the TCP-BIAD paradigm to study the steady-state throughput provided by TCP-BIAD and investigate the intra-protocol friendliness between TCP-BIAD and Additive Increase/Multiplicative Decrease algorithms. Our analysis shows that TCP-BIAD algorithm is exponentially stable, while maintaining an adequately fair and friendly behavior with respect to co-existing TCP-Reno flows. Finally, our results are validated with respect to other TCP variants such as BIC-TCP, CUBIC, HighSpeed TCP, HTCP, Hybla and TCP-Reno by means of computer simulations in networks with large bandwidth-delay products and low sensitivity to RTT values.

The performance of the learning models will intensely rely on the characteristics of the training data. The previous outcomes recommend that the overlapping between classes and the presence of noise have the most grounded impact on the performance of learning algorithm, and software defect datasets are no exceptions. The class overlap problem is concerned with the performance of machine learning classifiers critical problem is class overlap in which data samples appear as valid examples of more than one class which may be responsible for the presence of noise in datasets. We aim to investigate how the presence of overlapped instances in a dataset influences the classifier’s performance, and how to deal with class overlapping problem. To have a close estimate of class overlapping, we have proposed four different measures namely, nearest enemy ratio, subconcept ratio, likelihood ratio and soft margin ratio. We performed our investigations using 327 binary defect classification datasets obtained from 54 software projects, where we first identified overlapped datasets using three data complexity measures proposed in the literature. We also include treatment effort into the prediction process. Subsequently, we used our proposed measures to find overlapped instances in the identified overlapped datasets. Our results indicated that by training a classifier on a training data free from overlapped instances led to an improved classifier performance on the test data containing overlapped instances. The classifiers perform significantly better when the evaluation measure takes the effort into account.

Pseudorandom number generators are required for many computational tasks, such as stochastic modelling and simulation. This paper investigates the serial and parallel implementation of a Linear Congruential Generator for Graphics Processing Units (GPU) based on the binary representation of the normal number $$\alpha _{2,3}$$ . We adapted two methods of modular reduction which allowed us to perform most operations in 64-bit integer arithmetic, improving on the original implementation based on 106-bit double-double operations, which resulted in four-fold increase in efficiency. We found that our implementation is faster than existing methods in literature, and our generation rate is close to the limiting rate imposed by the efficiency of writing to a GPU's global memory.

In [1] it was shown how to deduce a directed metric time from the causal partial ordering of binary events. This result made it possible to introduce the notion of simultaneity and to define a Boolean algebra over simultaneous binary events. The main result here is that the algebra can be extended to include nonsimultaneous events although at the expense of sacrificing equivalence and of coupling complementarity to time reversal.

Conceiving time as a fundamental notion, the relations between time and logic have been studied since antiquity. In constrast, time is here deduced from the notion of causality. First we introduce the notion of a binary event which generates a bit and thereby marks a point of time. Assuming causality between the binary events allows to map a coherent set of binary events into a simultaneity set of a single point of time. This set provides the base for the definition of an algebra over binary events and a logic over time-bound propositions. The calculus allows the functional and operational specification of processing systems, i. e. their complete specification. As is further shown, a complete specification can be decomposed into a set of liveness properties and a set of safety properties. Finally, the superiority of the calculus to temporal logics is substantiated.

The performance of Heapsort algorithms on arbitrary input is examined. It is proved that ann logn−O(n) lower bound on the number of comparisons holds for a set of Heapsort algorithms, including Williams-Floyd's algorithm, Carlsson's bottom-up linear or binary insertion algorithm, and all up-down algorithms, on any input.

A memory-coupled multiprocessor—well suited to bit-wise operation—can be utilized to operate as a 1024 items cellular processing unit. Each processor is working on 32 bits and 32 such processors are combined to a multiprocessor. The information is stored in “vertical” direction, as it is defined and described in earlier papers [1] on “vertical processing”. The two-dimensional array (32 times 32 bits) is composed of the 32 bit-machine-words of the coupled processors on the one hand and of 32 processors in nearest-neighbour-topology on the other hand. The bit-wise cellular operation at one of the 1024 “points” is realized by the program of the processor—possibly assisted by appropriate microprogam sequences.

We analyze the totally implicitO(h2k) finite difference method applied to a linear unidimensional diffusion equation with a boundary moving with constant velocity. The related physical problem is the solidification of a finite column filled with a binary mixture, in the quasiequilibrium regime. By advancing the boundary along the pathh/k=velocity of the interface, a simple algorithm is obtained which is shown to be consistent and unconditionally stable for any value of the interfacial segregation factor and of the Peclet number.

A version of binary cascades iterative refinement (LSBCIR) for solving linear least squares problem minx ‖b-Ax‖2,A(m*n),m>n=rank(A), to a prescribed accuracy e>0 is proposed and investigated. The time cost of the process in the sequential computation is of order $$mn^2 M(t_0 ) + mnM\left( {\left\lceil {\log _2 /\varepsilon } \right\rceil } \right)$$ , wheret0 is a basic mantissa length andM(t)=Kt2 is the time cost of two numbers multiplication infl(t).

A theorem concerning the relation between the Towers of Hanoi and the binary numbers is proven in this paper. From this theorem, an algorithm for the Towers of Hanoi problem follows. The performance evaluations of all existing recursive and iteative algorithms for the Towers of Hanoi problem show that the above iterative algorithm is the most efficient one in terms of time and space. Finally, it is shown that the binary representation of numbers completely characterizes the status of alln discs in each step.

The parallel evaluation ofAN=a1∘a2∘...∘aN, where ∘ is binary associative, is studied. Under an idealized model of parallel computation, the minimal number of parallel processors required to computeAN in at mostt steps is determined for ⌈log2N⌉≤t≤N−1. This indicates that it is not always desirable to reduce the running time to an absolute minimum, and provides a lower bound on the processing power required for time-constrained evaluation of general arithmetic expressions. Results for two-input processors, are generalized tob-input processors, and then to non-homogeneous collections of processors. The latter does not have a closed-form solution, so approximations are analyzed.

The problem considered is to partition an edge-valued, node-weighted, finite, connected, simple graph (called a network) into disjoint subgraphs, each of which has a total node weight that does not exceed a weight constraint, and so that the total value of edges interconnecting the subgraphs is minimized. This paper presents a new approach which is effective in solving the problem, and fast enough to be practical in finding optimal partitions of large networks. It uses the concept of “divide and conquer” to partition the problem into several subproblems, which can be efficiently solved one after the other by using depth-first search and branch-and-bound principle. The operations required under the algorithms are additions, comparisons, and logical operations on binary vectors.

LetA 1 andA 2 be floating point numbers represented in arbitrary base β and randomly chosen from a logarithmic distribution. Letr denote the round-off error $$r = fl(A_1 * A_2 ) - (A_1 * A_2 )$$ where * is floating point multiplication and wherefl(A 1*A 2) denotes the normalizedN digit computer result of forming (A 1*A 2). This paper analyzes the mean and variance of both the actual round-off error and the fraction round-off error. This analysis relies upon sharp order estimates for the digit by digit deviation of logarithmically distributed numbers from uniformly distributed numbers. This completely resolves open questions of Kaneko and Liu and of Tsao. Also included is a generalization to arbitrary base (from binary) of an important round-off theorem of Henrici.

LetAn be the average root-to-leaf distance in a binary trie formed by the binary fractional expansions ofn independent random variablesX1,...,Xn with common densityf on [0, 1). We show thateither E(An)=∞ for alln≥2or\(\mathop {\lim }\limits_n E(A_n )/\log _2 n = 1\) depending on whether ∫f2 (x)dx = ∞ or ∫f2 (x)dx < ∞.

The algorithm generates a list of distinct binaryn-tuples such that eachn-tuple differs from the one preceding it in just one coordinate [1]. The binary Gray code is often used to generate all subsets of a given set [2]. The whole theory can easily be generalized to generatingr-ary codes,r>2, [3].

An efficient binary technique is presented for determining, to prescribed accuracy, the location of the zeros of a stochastic functionB(x) that is a classical one-dimension Brownian motion.

The smallest machine representable interval containing the square root of a given machine representable number is sought. Assuming binary computers with optimal upward directed rounding, it is shown bya priori methods of error analysis that this interval may be obtained via Newton's method without using interval arithmetic. Less sharp but still useful results are obtained for the cube root.

Pseudo-random numbers are usually generated by multiplicative methods. For binary computers the sequencesyi+1эa yi (mod 2k) are common and the derived numbersxi=yi/2k are taken as samples from the uniform distribution in (0, 1). In this paper 4a ≈2k ξ is proposed as a guide line for the choice of the multiplicatora where ξ is the golden section number\(\frac{1}{2}(\sqrt 5 - 1)\). Such values of the factor a have the property that an approximate knowledge ofyi will not yield information about the successoryi+1. Bounds for the autocorrelations of the entire sequences are derived. These are of the same order of magnitude asGreenberger's bounds in the case\(a \approx \sqrt {2^k }\). However, the precise evaluation of the serial correlations fork≤100 indicates that the factors 4a ≈2k ξ are superior. One million numbers of a special sequence were tested statistically. The included ALGOL and FORTRAN subroutines will enable programmers to make practical use of this paper.