Log in

Relevant bibliographies by topics / Recursive programming / Journal articles

To see the other types of publications on this topic, follow the link: Recursive programming.

Journal articles on the topic 'Recursive programming'

Author: Grafiati

Published: 4 June 2021

Last updated: 31 July 2024

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 50 journal articles for your research on the topic 'Recursive programming.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

Chiang, David, Colin McDonald, and Chung-chieh Shan. "Exact Recursive Probabilistic Programming." Proceedings of the ACM on Programming Languages 7, OOPSLA1 (April 6, 2023): 665–95. http://dx.doi.org/10.1145/3586050.

Full text

Abstract:

Recursive calls over recursive data are useful for generating probability distributions, and probabilistic programming allows computations over these distributions to be expressed in a modular and intuitive way. Exact inference is also useful, but unfortunately, existing probabilistic programming languages do not perform exact inference on recursive calls over recursive data, forcing programmers to code many applications manually. We introduce a probabilistic language in which a wide variety of recursion can be expressed naturally, and inference carried out exactly. For instance, probabilistic pushdown automata and their generalizations are easy to express, and polynomial-time parsing algorithms for them are derived automatically. We eliminate recursive data types using program transformations related to defunctionalization and refunctionalization. These transformations are assured correct by a linear type system, and a successful choice of transformations, if there is one, is guaranteed to be found by a greedy algorithm.

APA, Harvard, Vancouver, ISO, and other styles

2

Zdor, Dmitrii Valer'evich, and Tat'yana Nikolaevna Gornostaeva. "Analysis of the methods for competing recursion in recursive riles in the logic programming language Prolog." Программные системы и вычислительные методы, no. 4 (April 2021): 68–76. http://dx.doi.org/10.7256/2454-0714.2021.4.35383.

Full text

Abstract:

One of the developing trends in programming is the logic programming associated with the implementation of tools for creating artificial intelligence. One of such programming languages is the nonprocedural declarative logic programming language Prolog. This article is dedicated to the use of recursive rules in Prolog software. The goal of this work lies in analysis of the methods for completing recursive calls in recursive rules, as well as in explication of the use of such methods on the examples of programs with recursion. The author explores the specialized literature on the topic, generalized and systematizes the data, as well as tested the programs and the progress of their implementation. Recursive rule in the Prolog software sets an infinite cycle of repetition of predicates. For completing the recursive cycle, it is necessary to set a condition within the program that would end the cycle. The article examines the variants of organizing recursions with the completion of infinite cycle. The examples used in the article allows using them as the basis for programming in language Prolog for solving similar tasks. The acquired results are valuable for further development of the use of recursive predicates in logic programming languages.

APA, Harvard, Vancouver, ISO, and other styles

3

Nakata, Keiko, and Jacques Garrigue. "Recursive modules for programming." ACM SIGPLAN Notices 41, no. 9 (September 16, 2006): 74–86. http://dx.doi.org/10.1145/1160074.1159813.

Full text

APA, Harvard, Vancouver, ISO, and other styles

4

Parigot, Michel. "Recursive programming with proofs." Theoretical Computer Science 94, no. 2 (March 1992): 335–56. http://dx.doi.org/10.1016/0304-3975(92)90042-e.

Full text

APA, Harvard, Vancouver, ISO, and other styles

5

BOVE, ANA, and VENANZIO CAPRETTA. "Modelling general recursion in type theory." Mathematical Structures in Computer Science 15, no. 4 (July 15, 2005): 671–708. http://dx.doi.org/10.1017/s0960129505004822.

Full text

Abstract:

Constructive type theory is an expressive programming language in which both algorithms and proofs can be represented. A limitation of constructive type theory as a programming language is that only terminating programs can be defined in it. Hence, general recursive algorithms have no direct formalisation in type theory since they contain recursive calls that satisfy no syntactic condition guaranteeing termination. In this work, we present a method to formalise general recursive algorithms in type theory. Given a general recursive algorithm, our method is to define an inductive special-purpose accessibility predicate that characterises the inputs on which the algorithm terminates. The type-theoretic version of the algorithm is then defined by structural recursion on the proof that the input values satisfy this predicate. The method separates the computational and logical parts of the definitions and thus the resulting type-theoretic algorithms are clear, compact and easy to understand. They are as simple as their equivalents in a functional programming language, where there is no restriction on recursive calls. Here, we give a formal definition of the method and discuss its power and its limitations.

APA, Harvard, Vancouver, ISO, and other styles

6

De Nivelle, Hans. "A Recursive Inclusion Checker for Recursively Defined Subtypes." Modeling and Analysis of Information Systems 28, no. 4 (December 18, 2021): 414–33. http://dx.doi.org/10.18255/1818-1015-2021-4-414-433.

Full text

Abstract:

We present a tableaux procedure that checks logical relations between recursively defined subtypes of recursively defined types and apply this procedure to the problem of resolving ambiguous names in a programming language. This work is part of a project to design a new programming language suitable for efficient implementation of logic. Logical formulas are tree-like structures with many constructors having different arities and argument types. Algorithms that use these structures must perform case analysis on the constructors, and access subtrees whose type and existence depend on the constructor used. In many programming languages, case analysis is handled by matching, but we want to take a different approach, based on recursively defined subtypes. Instead of matching a tree against different constructors, we will classify it by using a set of disjoint subtypes. Subtypes are more general than structural forms based on constructors, we expect that they can be implemented more efficiently, and in addition can be used in static type checking. This makes it possible to use recursively defined subtypes as preconditions or postconditions of functions. We define the types and the subtypes (which we will call adjectives), define their semantics, and give a tableaux-based inclusion checker for adjectives. We show how to use this inclusion checker for resolving ambiguous field references in declarations of adjectives. The same procedure can be used for resolving ambiguous function calls.

APA, Harvard, Vancouver, ISO, and other styles

7

BOUDOL, GÉRARD. "The recursive record semantics of objects revisited." Journal of Functional Programming 14, no. 3 (April 14, 2004): 263–315. http://dx.doi.org/10.1017/s0956796803004775.

Full text

Abstract:

In a call-by-value language, representing objects as recursive records requires using an unsafe fixpoint. We design, for a core language including extensible records, a type system which rules out unsafe recursion and still supports the construction of a principal type for each typable term. We illustrate the expressive power of this language with respect to object-oriented programming by introducing a sub-language for “mixin-based” programming.

APA, Harvard, Vancouver, ISO, and other styles

8

Goncharov, S. S., and D. I. Sviridenko. "Recursive Terms in Semantic Programming." Siberian Mathematical Journal 59, no. 6 (November 2018): 1014–23. http://dx.doi.org/10.1134/s0037446618060058.

Full text

APA, Harvard, Vancouver, ISO, and other styles

9

Seitman, David T. "Recursive programming—A valuable technique." International Journal of Clinical Monitoring and Computing 8, no. 2 (June 1991): 121–24. http://dx.doi.org/10.1007/bf02915546.

Full text

APA, Harvard, Vancouver, ISO, and other styles

10

Schmid, U., and B. Kaup. "Analogical learning in recursive programming." Kognitionswissenschaft 5, no. 1 (1995): 31. http://dx.doi.org/10.1007/s001970050018.

Full text

APA, Harvard, Vancouver, ISO, and other styles

11

Rossberg, Andreas. "Mutually Iso-Recursive Subtyping." Proceedings of the ACM on Programming Languages 7, OOPSLA2 (October 16, 2023): 347–73. http://dx.doi.org/10.1145/3622809.

Full text

Abstract:

Iso-recursive types are often taken as a type-theoretic model for type recursion as present in many programming languages, e.g., classes in object-oriented languages or algebraic datatypes in functional languages. Their main advantage over an equi-recursive semantics is that they are simpler and algorithmically less expensive, which is an important consideration when the cost of type checking matters, such as for intermediate or low-level code representations, virtual machines, or runtime casts. However, a closer look reveals that iso-recursion cannot, in its standard form, efficiently express essential type system features like mutual recursion or non-uniform recursion. While it has been folklore that mutual recursion and non-uniform type parameterisation can nicely be handled by generalising to higher kinds, this encoding breaks down when combined with subtyping: the classic “Amber” rule for subtyping iso-recursive types is too weak to express mutual recursion without falling back to encodings of quadratic size. We present a foundational core calculus of iso-recursive types with declared subtyping that can express both inter- and intra-recursion subtyping without such blowup, including subtyping between constructors of higher or mixed kind. In a second step, we identify a syntactic fragment of this general calculus that allows for more efficient type checking without “deep” substitutions, by observing that higher-kinded iso-recursive types can be inserted to “guard” against unwanted β-reductions. This fragment closely resembles the structure of typical nominal subtype systems, but without requiring nominal semantics. It has been used as the basis for a proposed extension of WebAssembly with recursive types.

APA, Harvard, Vancouver, ISO, and other styles

12

Otu, G. A., M. S. Oyebanji, F. I. Okonkwo, R. U. Ugbe, A. C. Okafor, S. A. Usman, and O. A. Ubadike. "Evaluation, computation and coding of iterative function using recursive approach." Dutse Journal of Pure and Applied Sciences 9, no. 1b (March 31, 2023): 209–18. http://dx.doi.org/10.4314/dujopas.v9i1b.20.

Full text

Abstract:

Iteration and recursion are very pivotal concepts in understanding the logic and building blocks of all computer programs across all programming paradigms. Although the theory of iteration together with the development and implementation of iterative algorithm is easy to grasp, that of recursion remains elusive to programmers especially novice programmers. In this research, functions composition is applied in the explanation of iteration using recursion. The method demonstrates an easy and elaborate way of writing iterative programs using recursion by identifying the significant variables in both constructs. Function composition is used to write the recursive function, the recursive variable is identified as a variable that converges towards the base case, also the base case is also identified as being the terminating point of the function call else the function call runs and fill the stack memory causing stack overflow. The recursive part is the loop update and base case the termination condition in iterative programs. The results obtained simplifies how to write iterative codes using recursion.

APA, Harvard, Vancouver, ISO, and other styles

13

Börger, Egon, and Klaus-Dieter Schewe. "A Behavioural Theory of Recursive Algorithms." Fundamenta Informaticae 177, no. 1 (December 18, 2020): 1–37. http://dx.doi.org/10.3233/fi-2020-1978.

Full text

Abstract:

“What is an algorithm?” is a fundamental question of computer science. Gurevich’s behavioural theory of sequential algorithms (aka the sequential ASM thesis) gives a partial answer by defining (non-deterministic) sequential algorithms axiomatically, without referring to a particular machine model or programming language, and showing that they are captured by (nondeterministic) sequential Abstract State Machines (nd-seq ASMs). However, recursive algorithms such as mergesort are not covered by this theory, as has been pointed out by Moschovakis, who had independently developed a different framework to mathematically characterize the concept of (in particular recursive) algorithm. In this article we propose an axiomatic definition of the notion of sequential recursive algorithm which extends Gurevich’s axioms for sequential algorithms by a Recursion Postulate and allows us to prove that sequential recursive algorithms are captured by recursive Abstract State Machines, an extension of nd-seq ASMs by a CALL rule. Applying this recursive ASM thesis yields a characterization of sequential recursive algorithms as finitely composed concurrent algorithms all of whose concurrent runs are partial-order runs.

APA, Harvard, Vancouver, ISO, and other styles

14

Chen, Li. "Iteration vs. Recursion." ACM SIGACT News 52, no. 1 (March 16, 2021): 81–86. http://dx.doi.org/10.1145/3457588.3457601.

Full text

Abstract:

Iteration and recursion are two essential approaches in Algorithm Design and Computer Programming. Both iteration and recursion are needed for repetitive processes in computing. An iterative structure is a loop in which a collection of instructions and statements will be repeated. A recursive structure is formed by a procedure that calls itself to make a complete performance, which is an alternate way to repeat the process.

APA, Harvard, Vancouver, ISO, and other styles

15

Shilov, Nikolay. "Etude on Recursion Elimination." Modeling and Analysis of Information Systems 25, no. 5 (October 28, 2018): 549–60. http://dx.doi.org/10.18255/1818-1015-2018-5-549-560.

Full text

Abstract:

Transformation-based program verification was a very important topic in early years of theory of programming. Great computer scientists contributed to these studies: John McCarthy, Amir Pnueli, Donald Knuth ... Many fascinating examples were examined and resulted in recursion elimination techniques known as tail-recursion and co-recursion. In the paper, we examine just a single example (but new we hope) of recursion elimination via program manipulations and problem analysis. The recursion pattern of the example matches descending dynamic programming but is neither tail-recursion nor corecursion pattern. Also, the example may be considered from different perspectives: as a transformation of a descending dynamic programming to ascending one (with a fixed-size static memory), or as a proof of the functional equivalence between recursive and iterative programs (that can later serve as a casestudy for automatic theorem proving), or just as a fascinating algorithmic puzzle for fun and exercising in algorithm design, analysis, and verification. The article is published in the author’s wording.

APA, Harvard, Vancouver, ISO, and other styles

16

Li, Jianlin, Eric Wang, and Yizhou Zhang. "Compiling Probabilistic Programs for Variable Elimination with Information Flow." Proceedings of the ACM on Programming Languages 8, PLDI (June 20, 2024): 1755–80. http://dx.doi.org/10.1145/3656448.

Full text

Abstract:

A key promise of probabilistic programming is the ability to specify rich models using an expressive program- ming language. However, the expressive power that makes probabilistic programming languages enticing also poses challenges to inference, so much so that specialized approaches to inference ban language features such as recursion. We present an approach to variable elimination and marginal inference for probabilistic programs featuring bounded recursion, discrete distributions, and sometimes continuous distributions. A compiler eliminates probabilistic side effects, using a novel information-flow type system to factorize probabilistic computations and hoist independent subcomputations out of sums or integrals. For a broad class of recursive programs with dynamically recurring substructure, the compiler effectively decomposes a global marginal-inference problem, which may otherwise be intractable, into tractable subproblems. We prove the compilation correct by showing that it preserves denotational semantics. Experiments show that the compiled programs subsume widely used PTIME algorithms for recursive models and that the compilation time scales with the size of the inference problems. As a separate contribution, we develop a denotational, logical-relations model of information-flow types in the novel measure-theoretic setting of probabilistic programming; we use it to prove noninterference and consequently the correctness of variable elimination.

APA, Harvard, Vancouver, ISO, and other styles

17

PITTS, ANDREW M. "Structural recursion with locally scoped names." Journal of Functional Programming 21, no. 3 (May 2011): 235–86. http://dx.doi.org/10.1017/s0956796811000116.

Full text

Abstract:

AbstractThis paper introduces a new recursion principle for inductively defined data modulo α-equivalence of bound names that makes use of Odersky-style local names when recursing over bound names. It is formulated in simply typed λ-calculus extended with names that can be restricted to a lexical scope, tested for equality, explicitly swapped and abstracted. The new recursion principle is motivated by the nominal sets notion of ‘α-structural recursion’, whose use of names and associated freshness side-conditions in recursive definitions formalizes common practice with binders. The new calculus has a simple interpretation in nominal sets equipped with name-restriction operations. It is shown to adequately represent α-structural recursion while avoiding the need to verify freshness side-conditions in definitions and computations. The paper is a revised and expanded version of Pitts (Nominal System T. In Proceedings of the 37th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL 2010 (Madrid, Spain). ACM Press, pp. 159–170, 2010).

APA, Harvard, Vancouver, ISO, and other styles

18

MANDARIA, George. "Methodology of Teaching Dynamic Programming." Journal of Technical Science and Technologies 3, no. 1 (September 16, 2014): 15–18. http://dx.doi.org/10.31578/jtst.v3i1.84.

Full text

Abstract:

In this article the methodology of learning dynamic programing is described. Mentioned methodology is one of the main methods of solvingsome programming problems and foresees dividing one problem into such sub problems that using their solutions will be possible to build thesolution of initial problem. The realization of this method needs memorizing the solutions of sub problems, thus, the dynamic tables are used.As well as that the solutions of sub problems and recursive dependence are explained in this article. It is showed how to use recursive dependencein order to divide a problem into sub problems. Moreover, some sample problems and their solutions are included.

APA, Harvard, Vancouver, ISO, and other styles

19

FISCHER, JÖRG, and SERGEI GORLATCH. "TURING UNIVERSALITY OF RECURSIVE PATTERNS FOR PARALLEL PROGRAMMING." Parallel Processing Letters 12, no. 02 (June 2002): 229–46. http://dx.doi.org/10.1142/s012962640200094x.

Full text

Abstract:

Dijkstra's famous thesis "goto considered harmful", which paved the way for structured programming, was formally substantiated by the result of Böhm and Jacopini on the Turing universality of the three well-known basic programming constructs. We argue for a similar ideal in parallel programming — "send-receive considered harmful" — i.e. abandoning explicit send-receive statements between processors and expressing programs using a restricted set of parallel constructs. We deal with recursive patterns of parallelism, represented formally as morphisms in a suitable calculus. The aim of this paper is to study the expressive power of two morphisms – catamorphisms and anamorphisms. For a restricted program calculus based on these morphisms, we constructively prove two formal results, whose pragmatic message is: (1) A programming language based on catamorphisms is computationally equivalent to the class of primitive recursive functions; (2) A programming language based on both catamorphisms and anamorphisms is equivalent to the class of partial recursive functions and is therefore Turing-universal. We present a case study on numerical integration, demonstrating the expressive power of ana- and catamorphisms for parallel programming.

APA, Harvard, Vancouver, ISO, and other styles

20

Németh, Boldizsár, and Zoltán Csörnyei. "Stackless programming in Miller." Acta Universitatis Sapientiae, Informatica 5, no. 2 (December 1, 2013): 167–83. http://dx.doi.org/10.2478/ausi-2014-0009.

Full text

Abstract:

Abstract Compilers generate from the procedure or function call instruction a code that builds up an ”activation record” into the stack memory in run time. At execution of this code the formal parameters, local variables, data of visibility and the scope are pushed into the activation record, and in this record there are fields for the return address and the return value as well. In case of intensive recursive calls this is the reason of the frequent occurrences of the stack-overflow error messages. The classical technique for fixing such stack-overflows is to write programs in stackless programming style using tail recursive calls; the method is usually realised by Continuation Passing Style. This paper describes this style and gives an introduction to the new, special purpose stackless programming language Miller, which provides methods to avoid stack-overflow errors.

APA, Harvard, Vancouver, ISO, and other styles

21

JEANNIN, JEAN-BAPTISTE, DEXTER KOZEN, and ALEXANDRA SILVA. "Well-founded coalgebras, revisited." Mathematical Structures in Computer Science 27, no. 7 (February 9, 2016): 1111–31. http://dx.doi.org/10.1017/s0960129515000481.

Full text

Abstract:

Theoretical models of recursion schemes have been well studied under the names well-founded coalgebras, recursive coalgebras, corecursive algebras and Elgot algebras. Much of this work focuses on conditions ensuring unique or canonical solutions, e.g. when the coalgebra is well founded.If the coalgebra is not well founded, then there can be multiple solutions. The standard semantics of recursive programs gives a particular solution, typically the least fixpoint of a certain monotone map on a domain whose least element is the totally undefined function; but this solution may not be the desired one. We have recently proposed programming language constructs to allow the specification of alternative solutions and methods to compute them. We have implemented these new constructs as an extension of OCaml.In this paper, we prove some theoretical results characterizing well-founded coalgebras, along with several examples for which this extension is useful. We also give several examples that are not well founded but still have a desired solution. In each case, the function would diverge under the standard semantics of recursion, but can be specified and computed with the programming language constructs we have proposed.

APA, Harvard, Vancouver, ISO, and other styles

22

Alviano, Mario. "Efficient recursive aggregate evaluation in logic programming." Intelligenza Artificiale 5, no. 2 (2011): 207–15. http://dx.doi.org/10.3233/ia-2011-0023.

Full text

APA, Harvard, Vancouver, ISO, and other styles

23

Aoki, K., A. Nishikori, and R. Yokoyama. "Constrained Load Flow Using Recursive Quadratic Programming." IEEE Power Engineering Review PER-7, no. 2 (February 1987): 24–25. http://dx.doi.org/10.1109/mper.1987.5527528.

Full text

APA, Harvard, Vancouver, ISO, and other styles

24

Liu, Jianyong, and Ke Liu. "Markovian decision programming with recursive vector-reward." Acta Mathematicae Applicatae Sinica 6, no. 2 (April 1990): 158–65. http://dx.doi.org/10.1007/bf02006752.

Full text

APA, Harvard, Vancouver, ISO, and other styles

25

Aoki, K., A. Nishikori, and R. Yokoyama. "Constrained Load Flow Using Recursive Quadratic Programming." IEEE Transactions on Power Systems 2, no. 1 (1987): 8–16. http://dx.doi.org/10.1109/tpwrs.1987.4335064.

Full text

APA, Harvard, Vancouver, ISO, and other styles

26

Bloise, Gaetano, and Yiannis Vailakis. "Convex dynamic programming with (bounded) recursive utility." Journal of Economic Theory 173 (January 2018): 118–41. http://dx.doi.org/10.1016/j.jet.2017.10.008.

Full text

APA, Harvard, Vancouver, ISO, and other styles

27

Cogno, J. A. "Recursive quadratic programming algorithm for color matching." Color Research & Application 13, no. 2 (April 1988): 124–26. http://dx.doi.org/10.1002/col.5080130211.

Full text

APA, Harvard, Vancouver, ISO, and other styles

28

GAPEYEV, VLADIMIR, MICHAEL Y. LEVIN, and BENJAMIN C. PIERCE. "Recursive subtyping revealed." Journal of Functional Programming 12, no. 6 (November 2002): 511–48. http://dx.doi.org/10.1017/s0956796802004318.

Full text

Abstract:

Algorithms for checking subtyping between recursive types lie at the core of many programming language implementations. But the fundamental theory of these algorithms and how they relate to simpler declarative specifications is not widely understood, due in part to the difficulty of the available introductions to the area. This tutorial paper offers an ‘end-to-end’ introduction to recursive types and subtyping algorithms, from basic theory to efficient implementation, set in the unifying mathematical framework of coinduction.

APA, Harvard, Vancouver, ISO, and other styles

29

Ocampo-Toro, Jauder Alexander, Oscar Danilo Montoya, and Luis Fernando Grisales-Noreña. "Recursive convex approximations for optimal power flow solution in direct current networks." International Journal of Electrical and Computer Engineering (IJECE) 12, no. 6 (December 1, 2022): 5674. http://dx.doi.org/10.11591/ijece.v12i6.pp5674-5682.

Full text

Abstract:

<p>The optimal power flow problem in direct current (DC) networks considering dispersal generation is addressed in this paper from the recursive programming point of view. The nonlinear programming model is transformed into two quadratic programming approximations that are convex since the power balance constraint is approximated between affine equivalents. These models are recursively (iteratively) solved from the initial point v<sup>t</sup> equal to 1.0 pu with t equal to 0, until that the error between both consecutive voltage iterations reaches the desired convergence criteria. The main advantage of the proposed quadratic programming models is that the global optimum finding is ensured due to the convexity of the solution space around v<sup>t</sup>. Numerical results in the DC version of the IEEE 69-bus system demonstrate the effectiveness and robustness of both proposals when compared with classical metaheuristic approaches such as particle swarm and antlion optimizers, among others. All the numerical validations are carried out in the MATLAB programming environment version 2021b with the software for disciplined convex programming known as CVX tool in conjuction with the Gurobi solver version 9.0; while the metaheuristic optimizers are directly implemented in the MATLAB scripts.</p>

APA, Harvard, Vancouver, ISO, and other styles

30

Wang, Peixin, Tengshun Yang, Hongfei Fu, Guanyan Li, and C. H. Luke Ong. "Static Posterior Inference of Bayesian Probabilistic Programming via Polynomial Solving." Proceedings of the ACM on Programming Languages 8, PLDI (June 20, 2024): 1361–86. http://dx.doi.org/10.1145/3656432.

Full text

Abstract:

In Bayesian probabilistic programming, a central problem is to estimate the normalised posterior distribution (NPD) of a probabilistic program with conditioning via score (a.k.a. observe) statements. Most previous approaches address this problem by Markov Chain Monte Carlo and variational inference, and therefore could not generate guaranteed outcomes within a finite time limit. Moreover, existing methods for exact inference either impose syntactic restrictions or cannot guarantee successful inference in general. In this work, we propose a novel automated approach to derive guaranteed bounds for NPD via polynomial solving. We first establish a fixed-point theorem for the wide class of score-at-end Bayesian probabilistic programs that terminate almost-surely and have a single bounded score statement at program termination. Then, we propose a multiplicative variant of Optional Stopping Theorem (OST) to address score-recursive Bayesian programs where score statements with weights greater than one could appear inside a loop. Bayesian nonparametric models, enjoying a renaissance in statistics and machine learning, can be represented by score-recursive Bayesian programs and are difficult to handle due to an integrability issue. Finally, we use polynomial solving to implement our fixed-point theorem and OST variant. To improve the accuracy of the polynomial solving, we further propose a truncation operation and the synthesis of multiple bounds over various program inputs. Our approach can handle Bayesian probabilistic programs with unbounded while loops and continuous distributions with infinite supports. Experiments over a wide range of benchmarks show that compared with the most relevant approach (Beutner et al., PLDI 2022) for guaranteed NPD analysis via recursion unrolling, our approach is more time efficient and derives comparable or even tighter NPD bounds. Furthermore, our approach can handle score-recursive programs which previous approaches could not.

APA, Harvard, Vancouver, ISO, and other styles

31

ABADI, MARTÍN, BENJAMIN PIERCE, and GORDON PLOTKIN. "FAITHFUL IDEAL MODELS FOR RECURSIVE POLYMORPHIC TYPES." International Journal of Foundations of Computer Science 02, no. 01 (March 1991): 1–21. http://dx.doi.org/10.1142/s0129054191000029.

Full text

Abstract:

We explore ideal models for a programming language with recursive polymorphic types, variants of the model studied by MacQueen, Plotkin, and Sethi. The use of suitable ideals yields a close fit between models and programming language. Two of our semantics of type expressions are faithful, in the sense that programs that behave identically in all contexts have exactly the same types.

APA, Harvard, Vancouver, ISO, and other styles

32

Avanzini, Martin, Georg Moser, and Michael Schaper. "Automated Expected Value Analysis of Recursive Programs." Proceedings of the ACM on Programming Languages 7, PLDI (June 6, 2023): 1050–72. http://dx.doi.org/10.1145/3591263.

Full text

Abstract:

In this work, we study the fully automated inference of expected result values of probabilistic programs in the presence of natural programming constructs such as procedures, local variables and recursion. While crucial, capturing these constructs becomes highly non-trivial. The key contribution is the definition of a term representation, denoted as infer[.], translating a pre-expectation semantics into first-order constraints, susceptible to automation via standard methods. A crucial step is the use of logical variables, inspired by previous work on Hoare logics for recursive programs. Noteworthy, our methodology is not restricted to tail-recursion, which could unarguably be replaced by iteration and wouldn't need additional insights. We have implemented this analysis in our prototype ev-imp. We provide ample experimental evidence of the prototype's algorithmic expressibility.

APA, Harvard, Vancouver, ISO, and other styles

33

Li, Jing, and Yong Bo Lv. "Optimizing Container Reshuffle Operations in Container Yards Based on Dynamic Programming." Applied Mechanics and Materials 556-562 (May 2014): 5972–75. http://dx.doi.org/10.4028/www.scientific.net/amm.556-562.5972.

Full text

Abstract:

Based on the multiple phase characteristics of container reshuffle operations, the paper establishes a dynamic programming model according to both the initial stock positions and the picking sequence of containers. Then a directed weight figure is put forward through connecting different states by the order. The paper uses the bi-recursive algorithm, which combines the sequential recursive algorithm with the inverted recursive algorithm, to solve the problem. The optimization of container relocation scheduling is realized by avoiding the second relocation for the same container and minimizing the total relocating time.

APA, Harvard, Vancouver, ISO, and other styles

34

Hong, Qiantan, and Alex Aiken. "Recursive Program Synthesis using Paramorphisms." Proceedings of the ACM on Programming Languages 8, PLDI (June 20, 2024): 102–25. http://dx.doi.org/10.1145/3656381.

Full text

Abstract:

We show that synthesizing recursive functional programs using a class of primitive recursive combinators is both simpler and solves more benchmarks from the literature than previously proposed approaches. Our method synthesizes paramorphisms, a class of programs that includes the most common recursive programming patterns on algebraic data types. The crux of our approach is to split the synthesis problem into two parts: a multi-hole template that fixes the recursive structure, and a search for non-recursive program fragments to fill the template holes.

APA, Harvard, Vancouver, ISO, and other styles

35

Kurland, D. Midian, and Roy D. Pea. "Children's Mental Models of Recursive Logo Programs." Journal of Educational Computing Research 1, no. 2 (May 1985): 235–43. http://dx.doi.org/10.2190/jv9y-5pd0-mx22-9j4y.

Full text

Abstract:

Children who had a year of Logo programming experience were asked to think-aloud about what brief Logo recursive programs will do, and then to predict with a hand-simulation of the programs what the Logo graphics turtle will draw when the program is executed. If discrepancies arose in this last phase, children were asked to explain them. A prevalent but misguided “looping” interpretation of Logo recursion was identified, and this robust mental model persisted even in the face of contradiction between what the program did when executed and the child's predictions for what it would do.

APA, Harvard, Vancouver, ISO, and other styles

36

Streicher, Thomas. "A universality theorem for PCF with recursive types, parallel-or and ∃." Mathematical Structures in Computer Science 4, no. 1 (March 1994): 111–15. http://dx.doi.org/10.1017/s0960129500000384.

Full text

Abstract:

In a PCF-like call-by-name typed λ-calculus with a minimal fixpoint operator, ‘parallelor’, Plotkin's ‘continuous existential quantifier’ ∃ and recursive types together with constructors and destructors, all computable objects can be denoted by terms of the programming language. According to A. Meyer's terminology (cf. Meyer (1988)), such a programming language is called universal in the sense that any extension of it must be conservative, as all computable objects can already be expressed by program terms.As a byproduct, we get that, in principle, recursive types could be totally avoided, as they appear as syntactically expressible retracts of the non-recursive type → , where and are the flat domains of natural numbers and boolean values, respectively.

APA, Harvard, Vancouver, ISO, and other styles

37

Vasilev, Vladimir S., and Alexander I. Legalov. "Loop-invariant Optimization in the Pifagor Language." Modeling and Analysis of Information Systems 25, no. 4 (August 27, 2018): 347–57. http://dx.doi.org/10.18255/1818-1015-2018-4-347-357.

Full text

Abstract:

The paper considers methods of program transformation equivalent to optimizing the cycle invariant, applied to the functional data-flow model implemented in the Pifagor programming language. Optimization of the cycle invariant in imperative programming languages is reduced to a displacement from the cycle of computations that do not depend on variables that are changes in the loop. A feature of the functional data flow parallel programming language Pifagor is the absence of explicitly specified cyclic computations (the loop operator). However, recurring calculations in this language can be specified recursively or by applying specific language constructs (parallel lists). Both mechanisms provide the possibility of parallel execution. In the case of optimizing a recursive function, repeated calculations are carried out into an auxiliary function, the main function performing only the calculation of the invariant. When optimizing the invariant in computations over parallel lists, the calculation of the invariant moves from the function that executes over the list items to the function containing the call. The paper provides a definition of ”invariant” applied to the Pifagor language, algorithms for its optimization, and examples of program source codes, their graph representations (the program dependence graph) before and after optimization. The algorithm shown for computations over parallel lists is applicable only to the Pifagor language, because it rests upon specific data structures and the computational model of this language. However, the algorithm for transforming recursive functions may be applied to other programming languages.

APA, Harvard, Vancouver, ISO, and other styles

38

Amin, Nada, John Burnham, François Garillot, Rosario Gennaro, Chhi’mèd Künzang, Daniel Rogozin, and Cameron Wong. "LURK: Lambda, the Ultimate Recursive Knowledge (Experience Report)." Proceedings of the ACM on Programming Languages 7, ICFP (August 30, 2023): 259–74. http://dx.doi.org/10.1145/3607839.

Full text

Abstract:

We introduce Lurk, a new LISP-based programming language for zk-SNARKs. Traditional approaches to programming over zero-knowledge proofs require compiling the desired computation into a flat circuit, imposing serious constraints on the size and complexity of computations that can be achieved in practice. Lurk programs are instead provided as data to the universal Lurk interpreter circuit, allowing the resulting language to be Turing-complete without compromising the size of the resulting proof artifacts. Our work describes the design and theory behind Lurk, along with detailing how its implementation of content addressing can be used to sidestep many of the usual concerns of programming zero-knowledge proofs.

APA, Harvard, Vancouver, ISO, and other styles

39

Tait, David E. "A dynamic programming solution of financial rotation ages for coppicing tree species." Canadian Journal of Forest Research 16, no. 4 (August 1, 1986): 799–801. http://dx.doi.org/10.1139/x86-141.

Full text

Abstract:

The optimal solution to the coppice problem, the problem of when to cut and when to replant a coppice, is shown to satisfy a simple recursive relationship. This recursive relationship is solved using dynamic programming. The approach is illustrated using an example of a eucalyptus plantation.

APA, Harvard, Vancouver, ISO, and other styles

40

RINDERKNECHT, Christian. "A Survey on Teaching and Learning Recursive Programming." Informatics in Education 13, no. 1 (April 15, 2014): 87–119. http://dx.doi.org/10.15388/infedu.2014.06.

Full text

APA, Harvard, Vancouver, ISO, and other styles

41

Lin, Edward Y. H., and Dennis L. Bricker. "Implementing the recursive APL code for dynamic programming." ACM SIGAPL APL Quote Quad 20, no. 4 (May 1990): 239–50. http://dx.doi.org/10.1145/97811.97852.

Full text

APA, Harvard, Vancouver, ISO, and other styles

42

Martínez, J. M., and L. T. Santos. "New Theoretical Results on Recursive Quadratic Programming Algorithms." Journal of Optimization Theory and Applications 97, no. 2 (May 1998): 435–54. http://dx.doi.org/10.1023/a:1022686919295.

Full text

APA, Harvard, Vancouver, ISO, and other styles

43

O'Bagy, J., and R. E. Griswold. "A recursive interpreter for the Icon programming language." ACM SIGPLAN Notices 22, no. 7 (July 1987): 138–49. http://dx.doi.org/10.1145/960114.29665.

Full text

APA, Harvard, Vancouver, ISO, and other styles

44

Liu, Jianyong, and Ke Liu. "On Markovian decision programming with recursive reward functions." Annals of Operations Research 24, no. 1 (December 1990): 145–64. http://dx.doi.org/10.1007/bf02216820.

Full text

APA, Harvard, Vancouver, ISO, and other styles

45

Give'on, Yehoshafat Shafee. "Teaching recursive programming using parallel multi-turtle graphics." Computers & Education 16, no. 3 (January 1991): 267–80. http://dx.doi.org/10.1016/0360-1315(91)90061-u.

Full text

APA, Harvard, Vancouver, ISO, and other styles

46

Harris, B. L. "Recursive stochastic programming applied to dairy cow replacement." Agricultural Systems 34, no. 1 (January 1990): 53–64. http://dx.doi.org/10.1016/0308-521x(90)90093-6.

Full text

APA, Harvard, Vancouver, ISO, and other styles

47

Ozlen, Melih, Benjamin A. Burton, and Cameron A. G. MacRae. "Multi-Objective Integer Programming: An Improved Recursive Algorithm." Journal of Optimization Theory and Applications 160, no. 2 (July 9, 2013): 470–82. http://dx.doi.org/10.1007/s10957-013-0364-y.

Full text

APA, Harvard, Vancouver, ISO, and other styles

48

Bloise, Gaetano, Cuong Le Van, and Yiannis Vailakis. "Do not Blame Bellman: It Is Koopmans' Fault." Econometrica 92, no. 1 (2024): 111–40. http://dx.doi.org/10.3982/ecta20386.

Full text

Abstract:

We provide a unified approach to stochastic dynamic programming with recursive utility based on an elementary application of Tarski's fixed point theorem. We establish that the exclusive source of multiple values is the presence of multiple recursive utilities consistent with the given aggregator, each yielding a legitimate value of the recursive program. We also present sufficient conditions ensuring a unique value of the recursive program in some circumstances. Overall, acknowledging the unavoidable failure of uniqueness in general, we argue that the greatest fixed point of the Bellman operator should have a privileged position.

APA, Harvard, Vancouver, ISO, and other styles

49

Montoya, Oscar Danilo, Walter Gil-González, and Jesus C. Hernández. "Optimal Power Flow Solution for Bipolar DC Networks Using a Recursive Quadratic Approximation." Energies 16, no. 2 (January 4, 2023): 589. http://dx.doi.org/10.3390/en16020589.

Full text

Abstract:

The problem regarding of optimal power flow in bipolar DC networks is addressed in this paper from the recursive programming stand of view. A hyperbolic relationship between constant power terminals and voltage profiles is used to resolve the optimal power flow in bipolar DC networks. The proposed approximation is based on the Taylors’ Taylor series expansion. In addition, nonlinear relationships between dispersed generators and voltage profiles are relaxed based on the small voltage voltage-magnitude variations in contrast with power output. The resulting optimization model transforms the exact nonlinear non-convex formulation into a quadratic convex approximation. The main advantage of the quadratic convex reformulation lies in finding the optimum global via recursive programming, which adjusts the point until the desired convergence is reached. Two test feeders composed of 21 and 33 buses are employed for all the numerical validations. The effectiveness of the proposed recursive convex model is verified through the implementation of different metaheuristic algorithms. All the simulations are carried out in the MATLAB programming environment using the convex disciplined tool known as CVX with the SEDUMI and SDPT3 solvers.

APA, Harvard, Vancouver, ISO, and other styles

50

Jia, Xiaodong, Andre Kornell, Bert Lindenhovius, Michael Mislove, and Vladimir Zamdzhiev. "Semantics for variational Quantum programming." Proceedings of the ACM on Programming Languages 6, POPL (January 16, 2022): 1–31. http://dx.doi.org/10.1145/3498687.

Full text

Abstract:

We consider a programming language that can manipulate both classical and quantum information. Our language is type-safe and designed for variational quantum programming, which is a hybrid classical-quantum computational paradigm. The classical subsystem of the language is the Probabilistic FixPoint Calculus (PFPC), which is a lambda calculus with mixed-variance recursive types, term recursion and probabilistic choice. The quantum subsystem is a first-order linear type system that can manipulate quantum information. The two subsystems are related by mixed classical/quantum terms that specify how classical probabilistic effects are induced by quantum measurements, and conversely, how classical (probabilistic) programs can influence the quantum dynamics. We also describe a sound and computationally adequate denotational semantics for the language. Classical probabilistic effects are interpreted using a recently-described commutative probabilistic monad on DCPO. Quantum effects and resources are interpreted in a category of von Neumann algebras that we show is enriched over (continuous) domains. This strong sense of enrichment allows us to develop novel semantic methods that we use to interpret the relationship between the quantum and classical probabilistic effects. By doing so we provide a very detailed denotational analysis that relates domain-theoretic models of classical probabilistic programming to models of quantum programming.

APA, Harvard, Vancouver, ISO, and other styles

We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!