Difference between revisions of "Publications/newton.20.tfp"

From LRDE

Line 2: Line 2:
 
| published = true
 
| published = true
 
| date = 2020-01-14
 
| date = 2020-01-14
| title = Performance Comparison of Several Folding Strategies
 
 
| authors = Jim Newton
 
| authors = Jim Newton
 
| title = Performance Comparison of Several Folding Strategies
 
| booktitle = Trends in Functional Programming
 
| booktitle = Trends in Functional Programming
 
| lrdeprojects = Spot
 
| lrdepaper = http://www.lrde.epita.fr/dload/papers/newton.20.tfp.pdf
 
| lrdestatus = accepted
 
| lrdestatus = accepted
 
| lrdekeywords = fold, binary decision diagram, scala, lisp, rational numbers, functional programming
 
| lrdekeywords = fold, binary decision diagram, scala, lisp, rational numbers, functional programming
 
| lrdenewsdate = 2020-01-14
 
| lrdenewsdate = 2020-01-14
  +
| note = Accepted
| lrdepaper = http://www.lrde.epita.fr/dload/papers/newton.20.tfp.pdf
 
 
| address = Kraków, Poland
| lrdeprojects = Spot
 
| address = Krakow, Poland
 
 
| abstract = In this article we examine the computation order and consequent performance of three different conceptual implementations of the fold function. We explore a set of performance based experiments on different implementations of this function. In particular, we contrast the fold-left implementation with two other implements we refer to as pair-wise-fold and tree-like-fold. We explore two application areas: ratio arithmetic and Binary Decisions Diagram construction. We demonstrate several cases where the performance of certain algorithms is very different depending on the approach taken. In particular iterative computations where the object size accumulates are good candidates for the tree-like-fold.
 
| abstract = In this article we examine the computation order and consequent performance of three different conceptual implementations of the fold function. We explore a set of performance based experiments on different implementations of this function. In particular, we contrast the fold-left implementation with two other implements we refer to as pair-wise-fold and tree-like-fold. We explore two application areas: ratio arithmetic and Binary Decisions Diagram construction. We demonstrate several cases where the performance of certain algorithms is very different depending on the approach taken. In particular iterative computations where the object size accumulates are good candidates for the tree-like-fold.
 
| type = inproceedings
 
| type = inproceedings
Line 20: Line 21:
 
booktitle = <nowiki>{</nowiki>Trends in Functional Programming<nowiki>}</nowiki>,
 
booktitle = <nowiki>{</nowiki>Trends in Functional Programming<nowiki>}</nowiki>,
 
year = 2020,
 
year = 2020,
note = <nowiki>{</nowiki>Submitted<nowiki>}</nowiki>,
+
lrdestatus = <nowiki>{</nowiki>accepted<nowiki>}</nowiki>,
 
note = <nowiki>{</nowiki>Accepted<nowiki>}</nowiki>,
 
address = <nowiki>{</nowiki>Krak<nowiki>{</nowiki>\'o<nowiki>}</nowiki>w, Poland<nowiki>}</nowiki>,
 
address = <nowiki>{</nowiki>Krak<nowiki>{</nowiki>\'o<nowiki>}</nowiki>w, Poland<nowiki>}</nowiki>,
 
month = feb,
 
month = feb,
abstract = <nowiki>{</nowiki>In this article we examine the computation order and
 
consequent performance of three different conceptual
 
implementations of the fold function. We explore a set of
 
performance based experiments on different implementations
 
of this function. In particular, we contrast the fold-left
 
implementation with two other implements we refer to as
 
pair-wise-fold and tree-like-fold. We explore two
 
application areas: ratio arithmetic and Binary Decisions
 
Diagram construction. We demonstrate several cases where
 
the performance of certain algorithms is very different
 
depending on the approach taken. In particular iterative
 
computations where the object size accumulates are good
 
candidates for the tree-like-fold.<nowiki>}</nowiki>
 
<nowiki>}</nowiki>
 
 
@InProceedings<nowiki>{</nowiki> newton.20.tfp,
 
title = <nowiki>{</nowiki>Performance Comparison of Several Folding Strategies<nowiki>}</nowiki>,
 
author = <nowiki>{</nowiki>Jim Newton<nowiki>}</nowiki>,
 
booktitle = <nowiki>{</nowiki>Trends in Functional Programming<nowiki>}</nowiki>,
 
year = 2020,
 
lrdestatus = <nowiki>{</nowiki>accepted<nowiki>}</nowiki>,
 
address = <nowiki>{</nowiki>Krakow, Poland<nowiki>}</nowiki>,
 
month = jan,
 
 
abstract = <nowiki>{</nowiki>In this article we examine the computation order and
 
abstract = <nowiki>{</nowiki>In this article we examine the computation order and
 
consequent performance of three different conceptual
 
consequent performance of three different conceptual

Revision as of 14:21, 14 January 2020

Abstract

In this article we examine the computation order and consequent performance of three different conceptual implementations of the fold function. We explore a set of performance based experiments on different implementations of this function. In particular, we contrast the fold-left implementation with two other implements we refer to as pair-wise-fold and tree-like-fold. We explore two application areas: ratio arithmetic and Binary Decisions Diagram construction. We demonstrate several cases where the performance of certain algorithms is very different depending on the approach taken. In particular iterative computations where the object size accumulates are good candidates for the tree-like-fold.

Documents

Bibtex (lrde.bib)

@InProceedings{	  newton.20.tfp,
  author	= {Jim Newton},
  title		= {Performance Comparison of Several Folding Strategies},
  booktitle	= {Trends in Functional Programming},
  year		= 2020,
  lrdestatus	= {accepted},
  note		= {Accepted},
  address	= {Krak{\'o}w, Poland},
  month		= feb,
  abstract	= {In this article we examine the computation order and
		  consequent performance of three different conceptual
		  implementations of the fold function. We explore a set of
		  performance based experiments on different implementations
		  of this function. In particular, we contrast the fold-left
		  implementation with two other implements we refer to as
		  pair-wise-fold and tree-like-fold. We explore two
		  application areas: ratio arithmetic and Binary Decisions
		  Diagram construction. We demonstrate several cases where
		  the performance of certain algorithms is very different
		  depending on the approach taken. In particular iterative
		  computations where the object size accumulates are good
		  candidates for the tree-like-fold.}
}