Computing centroids in current-mode technique

A novel current-mode circuit for calculating the centre of mass of a discrete distribution of currents is described. It is simple and compact, an ideal building block for VLSI analogue IC design. The design principles are presented as well as the simulated behaviour of a one-dimensional implementation

Integrating Evolutionary Computation with Neural Networks

There is a tremendous interest in the development of the evolutionary computation techniques as they are well suited to deal with optimization of functions containing a large number of variables. This paper presents a brief review of evolutionary computing techniques. It also discusses briefly the hybridization of evolutionary computation and neural networks and presents a solution of a classical problem using neural computing and evolutionary computing technique

Computing sum of sources over an arbitrary multiple access channel

The problem of computing sum of sources over a multiple access channel (MAC) is considered. Building on the technique of linear computation coding (LCC) proposed by Nazer and Gastpar [2007], we employ the ensemble of nested coset codes to derive a new set of sufficient conditions for computing the sum of sources over an \textit{arbitrary} MAC. The optimality of nested coset codes [Padakandla, Pradhan 2011] enables this technique outperform LCC even for linear MAC with a structural match. Examples of nonadditive MAC for which the technique proposed herein outperforms separation and systematic based computation are also presented. Finally, this technique is enhanced by incorporating separation based strategy, leading to a new set of sufficient conditions for computing the sum over a MAC.Comment: Contains proof of the main theorem and a few minor corrections. Contents of this article have been accepted for presentation at ISIT201

Particle scattering in loop quantum gravity

We devise a technique for defining and computing n-point functions in the context of a background-independent gravitational quantum field theory. We construct a tentative implementation of this technique in a perturbatively-finite loop/spinfoam model.Comment: 4 page

Reasoning about context in uncertain pervasive computing environments

Context-awareness is a key to enabling intelligent adaptation in pervasive computing applications that need to cope with dynamic and uncertain environments. Addressing uncertainty is one of the major issues in context-based situation modeling and reasoning approaches. Uncertainty can be caused by inaccuracy, ambiguity or incompleteness of sensed context. However, there is another aspect of uncertainty that is associated with human concepts and real-world situations. In this paper we propose and validate a Fuzzy Situation Inference (FSI) technique that is able to represent uncertain situations and reflect delta changes of context in the situation inference results. The FSI model integrates fuzzy logic principles into the Context Spaces (CS) model, a formal and general context reasoning and modeling technique for pervasive computing environments. The strengths of fuzzy logic for modeling and reasoning of imperfect context and vague situations are combined with the CS model's underlying theoretical basis for supporting context-aware pervasive computing scenarios. An implementation and evaluation of the FSI model are presented to highlight the benefits of the FSI technique for context reasoning under uncertainty</p

PyCUDA and PyOpenCL: A Scripting-Based Approach to GPU Run-Time Code Generation

High-performance computing has recently seen a surge of interest in heterogeneous systems, with an emphasis on modern Graphics Processing Units (GPUs). These devices offer tremendous potential for performance and efficiency in important large-scale applications of computational science. However, exploiting this potential can be challenging, as one must adapt to the specialized and rapidly evolving computing environment currently exhibited by GPUs. One way of addressing this challenge is to embrace better techniques and develop tools tailored to their needs. This article presents one simple technique, GPU run-time code generation (RTCG), along with PyCUDA and PyOpenCL, two open-source toolkits that support this technique. In introducing PyCUDA and PyOpenCL, this article proposes the combination of a dynamic, high-level scripting language with the massive performance of a GPU as a compelling two-tiered computing platform, potentially offering significant performance and productivity advantages over conventional single-tier, static systems. The concept of RTCG is simple and easily implemented using existing, robust infrastructure. Nonetheless it is powerful enough to support (and encourage) the creation of custom application-specific tools by its users. The premise of the paper is illustrated by a wide range of examples where the technique has been applied with considerable success.Comment: Submitted to Parallel Computing, Elsevie