Tupling is a well-known transformation tactic to obtain new efficient recursive functions by grouping some recursive functions into a tuple. It may be applied to eliminate multiple traversals over the common data structure. The major difficulty in tupling transformation is to find what functions are to be tupled and how to transform the tupled function into an efficient one. Previous approaches to tupling transformation are essentially based on fold/unfold transformation. Though general, they suffer from the high cost of keeping track of function calls to avoid infinite unfolding, which prevents them from being used in a compiler. To remedy this situation, we propose a new method to expose recursive structures in recursive definitions and show how this structural information can be explored for calculating out efficient programs by means of tupling. Our new tupling calculation algorithm can eliminate most of multiple data traversals and is easy to be implemented. 1 Introduction Tupli...

The general goal of data mining is to extract interesting correlated information from large

Recursive programs may require large numbers of procedure calls and stack operations, and many such recursive programs exhibit exponential time complexity, due to the time spent re-calculating already computed sub-problems. As a result, methods which transform a given recursive program to an iterative one have been intensively studied. We propose here a new framework for transforming programs by removing recursion. The framework includes a unified method of deriving low time-complexity programs by solving recurrences extracted from the program sources. Our prototype system, ������, is an initial implementation of the framework, automatically finding simpler “closed form ” versions of a class of recursive programs. Though in general the solution of recurrences is easier if the functions have only a single recursion parameter, we show a practical technique for solving those with multiple recursion parameters.

We provide a transformation strategy for primitive recursive program schemes which is based on the three transformation relations splitting, sharing, and tupling, and which is provably semantic preserving. The transformation strategy works "without eureka". We can prove that there are infinitely many nontrivial primitive recursive program schemes for which the resulting recursive program scheme is strictly more efficient than the original one.

We consider primitive recursive program schemes with parameters together with the callby -value computation rule. The schemes are finite systems of functions which are defined by primitive (or: structural) recursion; simultaneous recursion and nesting of function calls is allowed. We present a transformation strategy which replaces primitive recursion by iteration. The transformation strategy which is fully automatic, takes as input a primitive recursive program scheme M with parameters and it computes a program scheme M 0 as output. We prove that, for every argument tuple, M 0 is at least as (time) efficient as M . We also prove that there are infinitely many nontrivial primitive recursive program schemes M with parameters for which the transformation yields a program scheme M 0 such that there are infinitely many argument tuples for which M 0 is more efficient than M . Moreover, we provide an algorithm which decides for an arbitrary given primitive recursive program scheme M...

We present a new program transformation strategy based on the introduction of lists. This strategy is an extension of the tupling strategy which is based on the introduction of tuples of xed length. The list introduction strategy overcomes some of the limitations of the tupling strategy and, in particular, it makes it possible to transform general recursive programs into linear recursive ones also in cases when this transformation cannot be performed by the tupling strategy. The linear recursive programs we derive by applying the list introduction strategy have in most cases very good time and space performance because they avoid repeated evaluations of goals and unnecessary constructions of data structures.

We present a new program transformation strategy based on the introduction of lists. This strategy is an extension of the tupling strategy which is based on the introduction of tuples of fixed length. The list introduction strategy overcomes some of the limitations of the tupling strategy, and in particular, it allows us to derive linear recursive programs when the tupling strategy is not successful. The linear recursive programs we may derive using this new strategy, have in most cases very good time and space performance because they avoid repeated evaluations of goals. We present our list introduction strategy in the case of definite logic programs, but it can also be applied in the case of functional programs thereby improving some transformation techniques proposed by Cohen [8] and by Chin and Hagiya [7].