acm-header
Sign In

Communications of the ACM


121 - 130 of 167 for bentley


Computing the Geometric Intersection Number of Curves

The geometric intersection number of a curve on a surface is the minimal number of self-intersections of any homotopic curve, i.e., of any curve obtained by continuous deformation. Given a curve c represented by a closed walk of length at most ℓ on a combinatorial surface of complexity n, we describe simple algorithms to (1) compute the geometric intersection number of c in O(n+ ℓ2) time, (2) construct a curve homotopic to c that realizes this geometric intersection number in O(n+ℓ4) time, and (3) decide if the geometric intersection number of c is zero, i.e., if c is homotopic to a simple curve, in O(n+ℓ log ℓ) time. The algorithms for (2) and (3) are restricted to orientable surfaces, but the algorithm for (1) is also valid on non-orientable surfaces.

To our knowledge, no exact complexity analysis had yet appeared on those problems. An optimistic analysis of the complexity of the published algorithms for problems (1) and (3) gives at best a O(n+g22) time complexity on a genus g surface without boundary. No polynomial time algorithm was known for problem (2) for surfaces without boundary. Interestingly, our solution to problem (3) provides a quasi-linear algorithm to a problem raised by Poincaré more than a century ago. Finally, we note that our algorithm for problem (1) extends to computing the geometric intersection number of two curves of length at most ℓ in O(n+ ℓ2) time.

https://dl.acm.org/ft_gateway.cfm?id=3363367&dwn=1

Mimicking Biology's Sulfur Switching Mechanism for Redox Signal Reception

Bridging communication between biology and electronics is critically dependent on the modality. There have been remarkable successes in bio-device communication through the electrical modality associated with the flow of ions across cellular membranes because this modality is integral to communication in biology (e.g., in neuromuscular systems) and this modality is readily accessible to convenient electrode measurements. There has been considerably less success in establishing bio-device communication through molecularly-specific biological modalities because of the intrinsic measurement challenges. We are focused on a third modality associated with reduction and oxidation (redox) reactions. From a biological perspective, this redox modality is integral to immune responses and wound healing, and even appears to inter-connect biological systems (e.g., the gut-brain axis) and biological kingdoms (e.g., the gut microbiome and epithelium). From a technological perspective, this redox modality has global electrical features that are accessible to convenient electrode measurements. Further, this redox modality has molecular features that offer some level of selectivity to redox-based bio-device communication. Here, we focus on a single mechanism integral to biological redox-based signal processing - the oxidative switching of thiols to disulfides. Biology uses this sulfur switching for the redox-responsive expression of genes associated with stress responses. Using model polymers, we show that electrochemical inputs can be used to induce redox-based sulfur switching. Experimental results demonstrate that variations in the "strength" (i.e., voltage) of the redox input signal can lead to qualitatively and quantitatively different responses in polymer assembly. Potentially, these observations recapitulate the redox-responsive sulfur switching that alters the permeability of mucous membranes.

https://dl.acm.org/ft_gateway.cfm?id=3345473&dwn=1

Implicit array bounds checking on 64-bit architectures

Several programming languages guarantee that array subscripts are checked to ensure they are within the bounds of the array. While this guarantee improves the correctness and security of array-based code, it adds overhead to array references. This has been an obstacle to using higher-level languages, such as Java, for high-performance parallel computing, where the language specification requires that all array accesses must be checked to ensure they are within bounds. This is because, in practice, array-bounds checking in scientific applications may increase execution time by more than a factor of 2. Previous research has explored optimizations to statically eliminate bounds checks, but the dynamic nature of many scientific codes makes this difficult or impossible. Our approach is, instead, to create a compiler and operating system infrastructure that does not generate explicit bounds checks. It instead places arrays inside of Index Confinement Regions (ICRs), which are large, isolated, mostly unmapped virtual memory regions. Any array reference outside of its bounds will cause a protection violation; this provides implicit bounds checking. Our results show that when applying this infrastructure to high-performance computing programs written in Java, the overhead of bounds checking relative to a program with no bounds checks is reduced from an average of 63% to an average of 9%.

https://dl.acm.org/ft_gateway.cfm?id=1187982&dwn=1

A general method for solving divide-and-conquer recurrences

The approximate complexity of divide-and-conquer algorithms is often described by recurrence relations of the formT(n) = kT(n/c) + f(n).The only well-defined method currently used for solving such recurrences consists of solution tables for fixed functions f and varying k and c. In this note we describe a unifying method for solving these recurrences that is both general in applicability and easy to apply. This method is appropriate both as a classroom technique and as a tool for practicing algorithm designers.

https://dl.acm.org/ft_gateway.cfm?id=1008865&dwn=1

Parallel intersection detection in massive sets of cubes

We present ParCube, which finds the pairwise intersections in a set of millions of congruent cubes. This operation is required when computing boolean combinations of meshes or polyhedra in CAD/CAM and additive manufacturing, and in determining close points in a 3D set. ParCube is very compact because it is uses a uniform grid with a functional programming API. ParCube is very fast; even single threaded it usually beats CGAL's elapsed time, sometimes by a factor of 3. Also because it is FP, ParCube parallelizes very well. On an Nvidia GPU, processing 10M cubes to find 6M intersections, it took 0.33 elapsed seconds, beating CGAL by a factor of 131. ParCube is independent of the specific parallel architecture, whether shared memory multicore Intel Xeon using either OpenMP or TBB, or Nvidia GPUs with thousands of cores. We expect the principles used in ParCube to apply to other computational geometry problems. Efficiently finding all bipartite intersections would be an easy extension.

https://dl.acm.org/ft_gateway.cfm?id=3150921&dwn=1

A genetic algorithm with a variable-length genotype and embryogeny for microstructured optical fibre design

Microstructured optical fibres are a relatively recent advance in fibre technology which guide light by using arrays of air holes which run the length of the fibre. The internal microstructure of optical fibres can be altered to reshape and transform light for use in medical applications, sensing, long distance and local area network high bandwidth communications. Recent progress in the production of polymer fibres allows designs with complex microstructures consisting of hundreds of holes to be manufactured. In this paper we present a generative (embryogenic) representation which can produce symmetric fibre designs with a variable number of holes. The resulting genetic algorithm has the ability to search designs of varying complexity over time, allowing less or more complex designs to be evolved as required. Various aspects of this representation are discussed in light of the supporting genetic algorithm such as as recombination of designs and the conversion of the variable length binary genotype to the phenotype (optical fibre structure). We include some single objective design results for a high-bandwidth optical fibre along with manufactured designs.

https://dl.acm.org/ft_gateway.cfm?id=1144278&dwn=1

Template-driven interfaces for numerical subroutines

This paper describes a set of interfaces for numerical subroutines. Typing a short (often one-line) description allows one to solve problems in application domains including least-squares data fitting, differential equations, minimization, root finding, and integration. Our approach of “template-driven programming” makes it easy to build such an interface: a simple one takes a few hours to construct, while a few days suffice to build the most complex program we describe.

https://dl.acm.org/ft_gateway.cfm?id=155757&dwn=1

Modular thinking: evolving modular neural networks for visual guidance of agents

This paper investigates whether replacing non-modular artificial neural network brains of visual agents with modular brains improves their ability to solve difficult tasks, specifically, survive in a changing environment. A set of experiments was conducted and confirmed that agents with modular brains are in fact better. Further analysis of the evolved modules characterised their function and determined their mechanism of operation. The results indicate that the greater survival ability is obtained due to functional specialisation of the evolved modules; good agents do well because their modules are more specialised at tasks such as reproduction and consumption. Overall, the more specialised the modules, the fitter the agents.

https://dl.acm.org/ft_gateway.cfm?id=1144033&dwn=1

Read What You Touch with Intelligent Audio System for Non-Visual Interaction

Slate-type devices allow Individuals with Blindness or Severe Visual Impairment (IBSVI) to read in place with the touch of their fingertip by audio-rendering the words they touch. Such technologies are helpful for spatial cognition while reading. However, users have to move their fingers slowly, or they may lose their place on screen. Also, IBSVI may wander between lines without realizing they did. We addressed these two interaction problems by introducing a dynamic speech-touch interaction model and an intelligent reading support system. With this model, the speed of the speech will dynamically change with the user’s finger speed. The proposed model is composed of (1) an Audio Dynamics Model and (2) an Off-line Speech Synthesis Technique. The intelligent reading support system predicts the direction of reading, corrects the reading word if the user drifts, and notifies the user using a sonic gutter to help him/her from straying off the reading line. We tested the new audio dynamics model, the sonic gutter, and the reading support model in two user studies. The participants’ feedback helped us fine-tune the parameters of the two models. A decomposition study was conducted to evaluate the main components of the system. The results showed that both intelligent reading support with tactile feedback are required to achieve the best performance in terms of efficiency and effectiveness. Finally, we ran an evaluation study where the reading support system is compared to other VoiceOver technologies. The results showed preponderance to the reading support system with its audio dynamics and intelligent reading support components.

https://dl.acm.org/ft_gateway.cfm?id=2822908&dwn=1