Reverse Polish Research Articles

Point containment algorithms for constructive solid geometry with unbounded primitives

We present several algorithms for evaluating point containment in constructive solid geometry (CSG) trees with unbounded primitives. Three algorithms are presented based on postfix, prefix, and infix notations of the CSG binary expression tree. We show that prefix and infix notations enable short-circuiting logic, which reduces the number of primitives that must be checked during point containment. To evaluate the performance of the algorithms, each algorithm was implemented in the OpenMC Monte Carlo particle transport code, which relies on CSG to represent solid bodies through which subatomic particles travel. Two sets of tests were carried out. First, the execution time to generate a rasterized image of a 2D slice of three CSG models of varying complexity was measured. Use of both prefix and infix notations offered significant speedup over the postfix notation that has traditionally been used in particle transport codes, with infix resulting in a 6× reduction in execution time relative to postfix for a model of a tokamak fusion device. We then measured the execution time of neutron transport simulations of the same three models using each of the algorithms. The results and performance improvements reveal the same trends as for the rasterization test, with a 5.52× overall speedup using the infix notation relative to the original postfix notation in OpenMC for the tokamak model.

SYNTACTIC ANALYSIS OF ARITHMETIC EXPRESSIONS FOR OPTIMIZING THE OPERATION OF PROGRAMS

Our algorithm combines the Reverse Polish Notation (RPN) and expression tree algorithms it is a novel method for efficiently evaluating arithmetic expressions. The algorithm combines the benefits of Reverse Polish Notation (RPN) and Expression Trees to provide a practical and efficient solution for evaluating expressions in both infix and postfix notation. The algorithm first converts the infix notation to RPN, which is then used to construct an expression tree. The expression tree is evaluated using a recursive function that traverses the tree and performs the required operations. The use of an expression tree allows for the optimization of sub-expressions, further improving the efficiency of the algorithm. The Combined RPN and Expression Tree Algorithm offers several advantages over other algorithms for evaluating arithmetic expressions. It is more efficient than some recursive algorithms while being more practical than stack-based algorithms. Furthermore, the use of an expression tree allows for the optimization of sub-expressions, further improving efficiency.

ATTRIBUTE EVALUATION METHODS IN A TOP-DOWN TABLE-DRIVEN PARSER

The article outlines methods for efficient computation of attributes in a table-driven top-down parsing process. This methods are based on the introduction of a stack of attributes into the parser. Semantic actions using this stack are defined by one of three methods. The first method is based on the fact that two parsers: table-driven and recursive descent parsers have the same use of depth first traversal. Therefore, the mechanisms for computing attributes in recursive descent are also applicable in a table-driven parser. Then the attribute stack will act like a frame stack of function calls. The second method assumes that the attribute stack is the memory of an abstract machine. For the source language of the translator, the structural-operational semantics is specified, which puts the translation result in line with the language constructions. The semantic actions of the translation scheme are implemented as analyzing and applying rules of an abstract machine built on the basis of structural-operational semantics. The third method assumes that an abstract syntax tree in postfix form will be formed in the attribute stack. Semantic actions for the attribute stack are built in such a way that the expressions formed on the stack are evaluated as far as possible. The article shows that the application of the three proposed methods to the scheme of translation of arithmetic expressions gives the same result. The proposed methods can significantly reduce the amount of memory used and make the design of the translator more understandable.

Postfix Form to Infix Form

Even though infix expression is easy for humans to understand, it is hard for the computers to comprehend. According to Sayan Mahapatra from GeekforGeeks , “Prefix and Postfix expressions can be evaluated faster than an infix expression. This is because we don’t need to process any brackets or follow operator precedence rule.” Using postfix expression eliminates the problem of confusion due to precedence. For example, an infix expression such as 2$3&4. One does not know if 2$3 should be applied first or 3&4 without knowing the precedence . In addition, Postfix expression can be easily calculated with the Stack base algorithm .

The Work of Writing Programs: Logic and Inscriptive Practice in the History of Computing

This article explores the entanglement of logic and computing by focusing on the activity of writing. Although mathematical logic is sometimes cast as the immaterial spirit of the computer’s material body, the study of logic also takes place in the physical world through the manipulation of symbols on paper. Already in the 19th century, mathematical logic was understood to be related to mechanization, though not as the science behind an as-yet-uninvented technology. Rather, symbolic notations were seen as tools that opened possibilities but required new kinds of work. Turning to early electronic computing in the 1950s, I observe that researchers similarly relied on novel inscriptive techniques to mitigate labor. Finally, considering Charles Hamblin’s Reverse Polish Notation, I show how logic was a source of notational invention, emerging as a practical resource for the work of writing programs independently of its role as a plausible theoretical foundation for computer science.

Graphical simulation of functions

In scientific research, it is normal practice to arrive at a description of the analyzed process with the function of one independent variable and the participation of several parameters, which are also assumed to be independent quantities, but in the study they have relatively constant values. These parameters are usually used to adjust the process, ie when choosing their specific values, the process meets the requirements of the researcher for optimality according to pre-selected criteria. The present work aims to develop a graphical user interface for managing parameters involved in an analytically presented function. The possibilities of the Korelia program for function research are considered. The function is entered as a string. After the lexical and syntactic analysis, a table of identifiers and an reverse polish notation of the function are formed. By modifying the values of the parameters of the function, the user tracks the changes in its graph. In this way, the role of each of them can be assessed.

O znaczeniu odwrotnej notacji polskiej dla rozwoju technik informatycznych

O znaczeniu odwrotnej notacji polskiej dla rozwoju technik informatycznych

Department of History, Princeton University (Princeton, USA)

Between the World Wars, a robust research community emerged in the nascent discipline of mathematical logic in Warsaw. Logic in Warsaw grew out of overlapping imperial legacies, launched mainly by Polish-speaking scholars who had trained in Habsburg universities and had come during the First World War to the University of Warsaw, an institution controlled until recently by Russia and reconstructed as Polish under the auspices of German occupation. The intellectuals who formed the Warsaw School of Logic embraced a patriotic Polish identity. Competitive nationalist attitudes were common among interwar scientists – a stance historians have called “Olympic internationalism,” in which nationalism and internationalism interacted as complementary rather than conflicting impulses. One of the School’s leaders, Jan Łukasiewicz, developed a system of notation that he promoted as a universal tool for logical research and communication. A number of his compatriots embraced it, but few logicians outside Poland did; Łukasiewicz’s notation thus inadvertently served as a distinctively national vehicle for his and his colleagues’ output. What he had intended as his most universally applicable invention became instead a respected but provincialized way of writing. Łukasiewicz’s system later spread in an unanticipated form, when postwar computer scientists found aspects of its design practical for working under the specific constraints of machinery; they developed a modified version for programming called “Reverse Polish Notation” (RPN). RPN attained a measure of international currency that Polish notation in logic never had, enjoying a global career in a different discipline outside its namesake country. The ways in which versions of the notation spread, and remained or did not remain “Polish” as they traveled, depended on how readers (whether in mathematical logic or computer science) chose to read it; the production of a nationalized science was inseparable from its international reception.

A safety simulation analysis algorithm for Altarica language

SummaryAltarica is a modeling language for safety analysis and supports simulation analysis. Although Altarica is widely used in the industry, research studies on simulation algorithm are rarely found. Therefore, we design and implement a simulation algorithm. We first briefly introduce the syntax and characteristics of Altarica, and then describe the design and implementation of the algorithm in detail, and finally accurately simulate the most probable sequence of events. We use Reverse Polish Notation to deal with complex event triggered conditions, and support three kinds of synchronization, including Synchronization, Broadcasting and Common Cause Failure, and support multiple probability distribution types. At the end of this paper, through case study and comparison with SIMFIA, the correctness of the algorithm is proved.

Parallelisation of equation-based simulation programs on heterogeneous computing systems.

Numerical solutions of equation-based simulations require computationally intensive tasks such as evaluation of model equations, linear algebra operations and solution of systems of linear equations. The focus in this work is on parallel evaluation of model equations on shared memory systems such as general purpose processors (multi-core CPUs and manycore devices), streaming processors (Graphics Processing Units and Field Programmable Gate Arrays) and heterogeneous systems. The current approaches for evaluation of model equations are reviewed and their capabilities and shortcomings analysed. Since stream computing differs from traditional computing in that the system processes a sequential stream of elements, equations must be transformed into a data structure suitable for both types. The postfix notation expression stacks are recognised as a platform and programming language independent method to describe, store in computer memory and evaluate general systems of differential and algebraic equations of any size. Each mathematical operation and its operands are described by a specially designed data structure, and every equation is transformed into an array of these structures (a Compute Stack). Compute Stacks are evaluated by a stack machine using a Last In First Out queue. The stack machine is implemented in the DAE Tools modelling software in the C99 language using two Application Programming Interface (APIs)/frameworks for parallelism. The Open Multi-Processing (OpenMP) API is used for parallelisation on general purpose processors, and the Open Computing Language (OpenCL) framework is used for parallelisation on streaming processors and heterogeneous systems. The performance of the sequential Compute Stack approach is compared to the direct C++ implementation and to the previous approach that uses evaluation trees. The new approach is 45% slower than the C++ implementation and more than five times faster than the previous one. The OpenMP and OpenCL implementations are tested on three medium-scale models using a multi-core CPU, a discrete GPU, an integrated GPU and heterogeneous computing setups. Execution times are compared and analysed and the advantages of the OpenCL implementation running on a discrete GPU and heterogeneous systems are discussed. It is found that the evaluation of model equations using the parallel OpenCL implementation running on a discrete GPU is up to twelve times faster than the sequential version while the overall simulation speed-up gained is more than three times.

Synthesis and exploration of clock spines

This study addresses the problem of developing a synthesis algorithm for clock spine networks, which is able to systematically explore the clock resources and clock variation tolerance. The idea is to transform the problem of allocating and placing clock spines on a plane into a slicing floorplan optimisation (SFO) problem, in which every candidate of clock spine network structures is uniquely expressed into a postfix notation to enable a fast cost computation in the SFO. As a result, the authors proposed synthesis algorithm can explore the diverse structures of the clock spine network to find globally optimal ones within acceptable run time. Through experiments with benchmark circuits, it is shown that the proposed algorithm is able to synthesise the clock spine networks with 38% reduced clock skew over the clock tree structures, even 11% reduced clock power. In addition, in comparison with the clock mesh structures, the proposed clock spine networks have comparable tolerance to clock skew variation while using considerably less clock resources, reducing clock power by 36%.

CutLang: A Particle Physics Analysis Description Language and Runtime Interpreter

This note introduces CutLang, a domain specific language that aims to provide a clear, human readable way to define analyses in high energy particle physics (HEP) along with an interpretation framework of that language. A proof of principle (PoP) implementation of the CutLang interpreter, achieved using C++ as a layer over the CERN data analysis framework ROOT, is presently available. This PoP implementation permits writing HEP analyses in an unobfuscated manner, as a set of commands in human readable text files, which are interpreted by the framework at runtime. We describe the main features of CutLang and illustrate its usage with two analysis examples. Initial experience with CutLang has shown that a just-in-time interpretation of a human readable HEP specific language is a practical alternative to analysis writing using compiled languages such as C++.Program summaryProgram title: CutLangProgram Files doi:http://dx.doi.org/10.17632/pym39s7vy7.1Licensing provisions: GNU General Public License 3 (GPL)Programming language: C++Nature of problem: Obtaining a physics result from high energy collider (e.g. LHC) data typically involves complex software frameworks for data analysis. Operating such analysis frameworks usually demands high computational expertise from the physicists, which makes trying simple analysis ideas difficult. The difficulty can be overcome by decoupling the description of all physics components of an analysis from the software framework. Analyses would thus be fully and unambiguously described by a framework-independent domain specific language. Defining such a language, which would be text-based and human readable is the first problem this paper investigates. Once a text-based language is available, a major task is to write an interpreter (or compiler) that converts it into instructions that can actually be executed, perhaps in some framework. The second problem addressed here is to write an automated, just-in-time interpreter to perform this task.Solution method: CutLang addresses the above problems by first constructing a domain specific language which aims to provide a clear, human readable way to define high energy physics analyses. The language is capable of defining various components of the analysis like object selection, event selection, and allows analysis tools like variable definition, χ2 minimization, multiple selection regions definition and many others. CutLang also provides an automated interpretation framework for the language, which is achieved using C++ classes as a layer over the CERN ROOT framework. The interpreter evaluates each component of the analysis description at runtime, without compilation. It handles event selection by classes which consist of a function that evaluates event-by-event object or event related quantities, a comparison operator, and one or two limit values, For each evaluation, the function result is compared to the limit values to find a boolean result of 0 or 1. Multiple selection criteria are combined together using logical operators. CutLang evaluates such expressions numerically by first converting them into Reverse Polish Notation, and then by parsing them with the Shunting Yard algorithm. Several properties of the interpreter are being able to work with multiple particle types, allowing particle combinations to make new particles, offering standard functions, histogramming, etc.Additional comments including restrictions and unusual features: The CutLang language and interpreter can work for a large number of physics analyses at the LHC. However it would benefit from some generalizations which would make it eligible for a larger variety of analysis. These generalizations could be achieved by inclusion of external functions for computing analysis-related variables, and allowing user-defined particle collections.

РАЗРАБОТКА АЛГОРИТМА РАЗБИЕНИЯ ЗАДАЧ НА ПОДЗАДАЧИ В СИСТЕМАХ РАСПРЕДЕЛЕННОЙ ОБРАБОТКИ ДАННЫХ

In terms of the problem of insufficient computational resources for a number of tasks, realization of computational cluster of neurocomputers is being considered as a variant. To implement the basic principle of distributed computing, there has been presented an algorithm for splitting the tasks entering the computational cluster of neurocomputers into sub-tasks. For this purpose, the program introduced into the cluster is suggested to present for execution in the modified postfix Polish record and to store it in the program command stack. To modify the program Polish notation should include different, non-arithmetic, operators and constructions. The next step is to get an abstract syntax tree of the program, following the rules for translating the modified postfix Polish record from the command stack into an abstract syntax tree. Then, the data should be sent to the abstract syntax tree of the program taking into account their bit depth, and to obtain the contiguity matrix of the program control flow graph that will display the set of all ways of program execution. The authors come to the conclusion that all operations recorded in the modified reverse Polish record presented in the form of an abstract syntax tree when data of a certain bit depth are transmitted to them, at the moment of transition to the program control flow graph executed in a single clock cycle are indivisible operations and can be represented as subprograms of the source program, which was submitted for processing to the computer cluster of neurocomputers.

Connection between Petri nets and Polish notation

We propose Petri nets that produce languages of Polish notation and reverse Polish notation for propositional formulas and mathematical expressions. Propositional formulas can contain a given number of variables and mathematical expressions. Arithmetic expressions can contain a given number of variables and constants. We also propose inhibitor nets that produce the fixed-point binary numbers in mathematical expressions for above-mentioned languages. The technique of the nets construction allows to use arbitrary functions with a given arity. We also propose a coloured Petri net for calculating values of propositional formulas in reverse Polish notation. The technique of the net construction allows to use arbitrary functions with a given arity using a truth table of a corresponding function.

Financial Time Series Modeling and Prediction Using Postfix-GP

Financial time series prediction is considered as a challenging task. The task becomes difficult due to inherent nonlinear and non-stationary characteristics of financial time series. This article proposes a combination of wavelet and Postfix-GP, a postfix notation based genetic programming system, for financial time series prediction. The discrete wavelet transform approach is used to smoothen the time series by separating the fluctuations from the trend of the series. Postx-GP is then employed to evolve models for the smoothen series. The out-of-sample prediction capability of evolved solutions is tested on two stocks price and two stock indexes series. The results are compared with those obtained using ECJ, a Java based evolutionary framework. The nonparametric statistical tests are applied to evaluate the significance of the obtained results.

Postfix automata

We introduce a notion of postfix automata and apply it to finite automata constructions. We give a compact method for constructing smaller nondeterministic finite automata (NFAs) from given regular expressions. There are four steps in our method. First, we convert one or more given regular expressions into postfix form, better known as Reverse Polish notation, and call it a postfix regular expression. Second, we construct a syntax tree for the postfix regular expression. Next, we code the syntax tree using a specific algorithm and finally, we construct an NFA based on the coded syntax tree. Using our method we can obtain smaller NFAs, called postfix automata, with only one starting state and one final state. In this paper, we prove several notions and present a classical example to compare the size of a postfix automaton with the NFAs created by several classical construction methods. We also derive the efficiency in reducing the size of the NFA through general theoretical analysis.

Using programmable calculators for financial applications

Electronic calculations are becoming an indispensable tool for financial practitioners. Several textbooks recommend the use of calculators in finance classes. However, the variety of forms and sizes make it a problem to pick the right choice for a practitioner. Some recent articles have discussed the use of financial calculators and others have attempted to program the Black–Scholes option pricing model in a programmable calculator using 'Reverse Polish Notation' (RPN) logic. Thus practitioners may be required to carry several calculators, for the different types of applications in his day–to–day job. Alternatively, they may carry a laptop computer with a bunch of programs. However, it may often be more convenient and economical to have a pocket calculator that can serve the function equally well. This paper selects a series of economical programmable calculators using algebraic logic, and programs the time value functions as well as the Black–Scholes option–pricing model in the same calculator. It gives the complete programming steps, including a brief theoretical background. Subsequently, it gives an application section in which it takes the reader step by step through the various programs showing the display of the calculator at every step. Thus the reader can check the programming steps and debug for errors if the answers do not match.

Performance comparison of crossover operators for postfix genetic programming

In this article, we present three crossover operators for postfix-GP, a GP system that adopts postfix notation for an individual representation. These crossover operators are: GA-like one-point, sub-tree, and semantic aware sub-tree. The algorithm and implementation details for each of these crossover operators are presented. The operators are applied on a set of real-valued symbolic regression problems. The performance comparison of the crossover operators is carried out using two measures, number of successful runs and mean best adjusted fitness. The significance of the obtained results is tested using statistical test. The results suggest that semantic aware sub-tree crossover outperforms GA-like one-point and sub-tree crossovers on all problems.

Tree template matching in ranked ordered trees by pushdown automata

We consider the problem of tree template matching in ranked ordered trees, and propose a solution based on the bottom-up technique. Specifically, we transform the tree pattern matching problem to a string matching problem, by transforming the tree template and the subject tree to strings representing their postfix notation, and then use pushdown automata as the computational model. The method is analogous to the construction of string pattern matchers. The given tree template is preprocessed once, by constructing a nondeterministic pushdown automaton, which is then transformed to the equivalent deterministic one. Although we prove that the space required for preprocessing is exponential to the size of the tree template in the worst case, the space required for a specific class of tree templates is linear. The time required for the searching phase is linear to the size of the subject tree in both cases.

Computing all subtree repeats in ordered trees

We consider the problem of computing all subtree repeats in a given labeled ordered tree. We first transform the tree to a string representing its postfix notation, and then present an algorithm based on the bottom-up technique to solve it. The proposed algorithm consists of two phases: the preprocessing phase and the phase where all subtree repeats are computed. The linear time and space complexity of the proposed algorithm are important parts of its quality.