Ray Tracing Through Functional Programming Language Using OCaml with Comparative Performance Analysis

In this paper, we discuss the cost of functional classes design style. Functional classes merge both object-oriented and functional programming paradigms; a functional class is a class without variables. Because of this, the methods in functional classes are true functions. Functional classes design style aims at improving reliability and program correctness. However, resulting program code is not optimal when considering the performance. As the main contribution, we analyze here the performance of functional classes in Java. We study especially the cost of recursive method calls. As the case study, we analyze an implementation of the cartesian product operation in a lightweight data mediator. The analysis confirms that functional classes design style leads to implementations that make poor use of HotSpot. However, the analysis also indicates how to restructure a functional class to improve the performance.

In this chapter, we present the main properties of functional programming. In functional programming, computation proceeds by rewriting functions and not by modifying the state. The fundamental characteristic of the languages in this paradigm, at least in their “pure” form, is precisely that of not possessing the concept of memory (and therefore side effect). Once an environment is fixed, an expression always denotes the same value. We will discuss the pure paradigm in the first sections, explaining the fundamental aspects. Functional programming languages, however, merge these “pure” ingredients in a context that adds many other mechanisms; we will review them before touching upon the SECD machine, an abstract machine for higher-order functional languages which constitutes the prototype of many real implementations. We will, at this point, be in a position to discuss the reasons why the functional programming paradigm is interesting with respect to ordinary imperative languages. The chapter concludes with a more theoretical section which provides a succinct introduction to the lambda-calculus, a formal system for computability which inspires all functional languages and which has been a constant model for the design of programming languages.KeywordsNormal FormRecursive FunctionFunctional ProgrammingAbstract MachineFunctional LanguageThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

To investigate how the propagation of energy away from steady sources may be influenced by the horizontal structure of the time-averaged flow in the troposphere, solutions to a barotropic model are displayed and interpreted. The model is steady and linearized about a basic state which varies in latitude and longitude. Emphasis is placed on cases where the longitudinal variations are gradual. Many of the results can be analyzed by locally applying tools developed for zonally symmetric basic states, e.g., ray tracing and refractive indices. Simple background flows are constructed which have longitudinally confined critical lines, reflective surfaces, wave guides, and regions conducive to propagation. An example is given in which longitudinal derivatives of the basic state are significant. The theory of ray tracing in a two-dimensional wind must be employed as an interpretive tool in this case. It is concluded that zonal variations tend to enhance poleward (equatorward) propagation in large-scale troughs (ridges). Examples are also shown of propagation through observed January 300 mb mean flow. These experiments suggest that the southern flank of the Asiatic jet may act as a partial reflector, increasing the likelihood of resonance in the midlatitudes. The central tropical Pacific appears to have potential as a corridor for inter-hemispheric transmission, though during typical January conditions wavetrains emanating from the mid-latitudes are absorbed there.

This chapter presents an original Graphics processing units ray-tracing application running solely on the compute shader and Shader Model 5.0 in DirectX 11. It describes a step-by-step ray-tracing implementation in the compute shader using Shader Model 5.0 in DirectX 11.0. Ray tracing is an advanced illumination technique that simulates the effects of light by tracing rays through the screen on an image plane. Ray tracing is traditionally known to be a trivially parallel-implementation problem given that the color computation for each pixel is independent of its neighbors. The application includes the most-used effects in ray tracing and allows programmers to add their own code or to modify the existing code in order to improve the visual effects and their performance. One of the main characteristics of the compute shader is that it “is not a part of the pipeline. The shader computes the pixel color just as if the current intersected primitive had the current-material-to-render attached to itself.

This paper proposes a library for computational intelligence using functional programming to address the complexities in algorithm implementation and highlighting specific concerns that are often ignored in the algorithm descriptions. Useful abstractions, common in the paradigm of functional programming, are used to make implementation specifics of algorithms part of the algorithm definition, resulting in the tracking of these effects, together with the control of the effects. Effects, requiring management within an algorithm, include the use of pseudo-random number generators, writing data to files or the console, or providing the control parameter configuration of the algorithm in an experiment. By defining the units of work for an algorithm in a general and generic form, composition of these different algorithmic units is possible, thereby creating larger, more complex computational units. The software library providing such reusable, peer-reviewed compos able computational unit, is called CIlib.

Objectives: The main objective of this paper is to identify suitable programming concepts from Functional Programming paradigm concerning low resource devices development and eventually contribute an approach for design level optimization. Methods: Experiments have been conducted, CPU time and memory consumptions (Private Bytes) were measured. Findings: The research results indicated that Pattern Matching, Lazy, Curried, Tail Recursion, Functional Composition, Referential Transparency and Higher Order Functions with functions as parameters concepts consumed less CPU and memory resources compared to their alternative concepts. This paper suggests that the above mentioned concepts can be applied by any software engineering practitioners in designing resource efficient constructs for software applications. Applications: Using these guidelines substantial performance growth can be formed and at the same time, performance degradation issues can be easily avoided. Eventually, this paper contributes a way to optimize the Functional Programming design at design level.

A functional data structure is a data structure that is suitable for implementation in a functional programming language, or for coding in an ordinary language like C or Java using a functional style. Functional data structures are closely related to persistent data structures and immutable data structures—in fact, the three terms are often used interchangeably. Howevber, there are subtle differences. The term persistent data structures refers to the general class of data structures in which an update does not destroy the previous version of the data structure, but rather creates a new version that co-exists with the previous version. See Chapter 33 for more details about persistent data structures. The term immutable data structures emphasizes a particular implementation technique for achieving persistence, in which memory devoted to a particular version of the data structure, once initialized, is never altered. The term functional data structures emphasizes the language or coding style in which persistent data structures are implemented. Functional data structures are always immutable, except in a technical sense discussed in Section 41.4.

Abstract. At a fundamental level, functional and object-oriented programming languages are all ‘higher-order’, in the sense that they support computing with values that are themselves pieces of program code encapsulated with a local environment. In functional languages these ‘active’ values are functions, while in object-oriented languages they are objects. Both styles of higher-order language claim to provide good support for writing adaptable programs, but functional and object-oriented languages achieve this adaptability in different ways: functional programs rely on parameterisation at the value, type and module level, while object-oriented languages rely primarily on subtyping and implementation inheritance. Here we compare these two approaches, mainly in terms of the features and properties of their type systems, and consider the benefits and disadvantages of unifying (or merging) the two paradigms by adding object-oriented features to ML as a base language. We argue that while some of the simpler aspects of object-oriented languages are compatible with ML, adding a full- edged class-based object system to ML leads to an excessively complex type system and relatively little expressive gain, especially if we aim to preserve that mostly functional style of programming that is a major advantage of ML.

A major impediment to the wider proliferation of Single-Instruction, Multiple Datastream (SIMD) (3) architectures rests in the unsuitability of sequential, scalar, languages for programming data-parallel systems. Existing languages lack sufficient expressive power to describe data-parallel computation. A functional language, extended with data-parallel primitives, provides a powerful abstraction of the capabilities of SIMD architectures. Such a language conveys the following benefits: greater expressive power, a rich set of data-types, transparent access to data-parallelism, amenability to program transformation and consistency with the functional style. A compilation strategy onto an abstract SIMD architecture is presented. >

In his 1977 ACM Turing Award Lecture, John Backus identified the word-at-a-time style of programming, inherited from the underlying hardware and dubbed the "von Neumann bottleneck", as a major obstacle to the advancement of programming. In this keynote, I argue that the functional programming he advocated introduced its own bottleneck: that everything produced by a computation (including nothing) must be encoded as a single value. This "obligation to singularity" is foreign to modelling, where single values sit collegially between no values and two values. Exploring diverse examples, I will argue that adopting a modelling (de facto: relational) style of programming eliminates the functional bottleneck, and with it many of the data-to-control flow escapes that Backus originally sought to avoid.

Current (heterogeneous) multi-core environments such as gpGPU architectures are hard to program with normal imperative and object-oriented (OO) languages. There are two basic problems to tackle: (1) it is too easy to program race conditions and dead-locks with the available synchronization primitives, and (2) these environments do not support (or support inefficiently) the instructions required for efficient execution of OO programs, e.g., because function pointers and pointer arithmetic are lacking. We address both problems with a new language that comprises both Functional Programming (FP) and OO programming. We solve problem (1) by auto-parallelization in the functional core where all loops and non-dependent calls can be executed in parallel. FP is to be used to write computational intensive code with safe concurrent memory access. An alternative object model that does neither use pointer arithmetic nor function pointers but smart pointers/proxies (to implement polymorphism) as well as mixins and templates (to implement OO like code reuse) solves problem (2). To cleanly integrate the two language cores, we propose a new integration model that even grants some restricted ways to access state from within FP mode. With the new language and prototype compiler we can transparently parallelize code to target both Cuda and multi-core machines (without annotations from the programmer) and obtain good speedups.

As wireless networks become more and more popular, people are paying more attention to the question of whether WiFi signals are harmful to the human body. In this paper, a full 3D propagation model based on ray tracing and uniform diffraction theory is used to predict the electromagnetic radiation environment of indoor 2.4 GHz WiFi signals. The electromagnetic distribution of the ground and the wall of office in the study area are effectively calculated. The research content can provide a basis for further wireless channel modeling and electromagnetic situation research.

Infrasonic signals refracted by thermal gradients in the rarefied upper atmosphere are modeled using a combination of ray tracing and weak shock theory to develop an understanding of thermospheric infrasound signals produced by energetic, transient sources. Canonical arrival structures in the form of u-wave signatures are identified for returns refracted at lower altitudes within the thermosphere, and possible multi-pathing produced by effective sound speed inflections are investigated to elucidate more complex arrival structures, which are found to be spatially localized. Variability in the source characteristics is investigated and it is found that whereas some waveform phase information is lost due to finite amplitude effects, arrival characteristics are strongly dependent on the peak overpressure near the source. Variability in the propagation path is considered using archived atmospheric specifications and implies that despite uncertainties related to the dynamic and sparsely sampled nature of the atmosphere, thermospheric signatures might be useful in estimating the yield for explosive sources. Last, thermospheric arrivals from a failed rocket launch, as well as those from several large chemical explosions, are analyzed and it is found that qualitative trends match those predicted, and analyses here provide additional insight into such signatures.

In this paper a 2D deterministic satellite propagation model in street canyon is developed in Matlab. The propagation model is based on ray tracing and Uniform Theory of Diffraction (UTD). The path-loss level is compared with 3D intelligent ray tracing (IRT) tool for satellite wave propagation developed by Winprop. A maximum average path-loss of 10.127 dB shows that a 2D model can be efficient for real-time applications that needs short computation time.