tree functions daily exercise: Range

[Xah Lee]

Here's the belated Java solution.

import java.util.List;
import java.util.Array List;
import java.lang.Math;

class math {
public static List range(double n) {
return range(1,n,1);
}

public static List range(double n, double m) {
return range(n,m,1);
}

public static List range(double iMin, double iMax, double iStep) {
List ll = new ArrayList();
if (iMin <= iMax && iStep > 0) {
for (int i=0; i <= Math.floor((iMa x-iMin)/iStep); i++) {
ll.add(new Double(iMin+i*i Step));
}
return ll;
}
if (iMin >= iMax && iStep < 0) {
for (int i=0; i <= Math.floor((iMi n-iMax)/-iStep); i++) {
ll.add(new Double(iMin+i*i Step));
}
return ll;
}
// need to raise exception here
return ll;
}
}

class Range {
public static void main(String[] arg) {
System.out.prin tln(math.range( 5));
System.out.prin tln(math.range( 5,10));
System.out.prin tln(math.range( 5,7, 0.3));
System.out.prin tln(math.range( 5,-4, -2));
}
}

Perl & Python versions archived here:
http://xahlee.org/tree/tree.html

Xah
xa*@xahlee.org
∑ http://xahlee.org/
Dear functional programers,

i run services called a-python-a-day and a-java-a-day, where each day i

give a tip or snippet of code in these languages, also as a way for me

to learn these languages.

I've been running this perl-python a-day mailing list for several
months, and have accumulated a sizable tutorial here:
http://xahlee.org/perl-python/python.html

In the coming days, i'll be starting to translate a complete set of
tree processing functions. These functions, always takes a tree as
input (arbitrary nested list) and always returns a list of a definite
structure. Together, they form a particular functional programing
paradigm. See this page for the complete documentation as it exists
now:
http://xahlee.org/PerlMathemat ica_dir/Matica.html

As usuall, each day we will be spending about 20 minutes enjoying these

little exercises. If past experience is a good indication, then i
presume that in a month or two we will have built a complete set of
functions that manipulates tress, in languages Python and Java and
Perl. (the Perl set is already written)

I'm always interested in LISP and Haskell languages, but never
seriously learned them. I'm hoping that you functional programers in
these languages or learners, join me in these 15 minutes daily
exercises as a fun routine to learn languages or functional
programing.

I'm in particular very interested in the daily discussions of these
topics by functional programers, as well seeing such set of complete
code in scsh and Haskell. (Common Lisp or other functional languages
are always welcome of course)

Â* Xah
Â* [e-mail]
∑ http://xahlee.org/

[alex goldman]

Xah Lee wrote:

well yes... but this was emulation of Mathematica functions.
(Disclaimer: Mathematica is a trademark of Wolfram Research Inc, who is
not affliated with this project)

You could have fooled me.

[Xah Lee]

Very very nice! I don't know scheme well... but oh the macros, such a
wonderful facility...

Functional lang never let me down.

I haven't worked on a Java version yet... but i wonder what pain i'll
have to endure for a lang that lacks eval. Since i'm not Java expert...
i wonder if i can even do it in a few days.

Xah
xa*@xahlee.org
∑ http://xahlee.org/

David Van Horn wrote:

Xah Lee wrote:

here's the Python spec for the Table function:

...

References:

• for a context of this message, see: http://xahlee.org/tree/tree.htm

Here is a Scheme implementation of Table. As noted on your web page and the
Mathematica documentation, the first argument of Table "evaluates in a
non-standard way". Thus we use Scheme macros to control the evaluation of
this expression. The first three clauses in this syntax definition take care
to fill in the default values for i, imin, and di when they are not provided.
The fourth clause iterates over one variable constructing a list. Notice
this is done tail-recursively. The last clause handles the multiple variable
case by rewriting the term into a simpler form.

(define-syntax table
(syntax-rules ()
((table exp (imax))
(table exp (i 1 imax 1)))

((table exp (i imax))
(table exp (i 1 imax 1)))

((table exp (i imin imax))
(table exp (i imin imax 1)))

((table exp (i imin imax di))
(let loop ((n imin) (accum '()))
(if (< imax n)
(reverse accum)
(loop (+ n di) (cons ((lambda (i) exp) n) accum)))))

((table exp i j ...)
(table (table exp j ...) i))))
;; Examples

(table #t (0)) ;; => '()
(table #t (5)) ;; => '(#t #t #t #t #t)
(table i (i 5)) ;; => '(1 2 3 4 5)
(table i (i 2 5)) ;; => '(2 3 4 5)
(table i (i 2 5 2)) ;; => '(2 4)
(table i (i 2 6 2)) ;; => '(2 4 6)
(table (add1 i) (i 2 6 2)) ;; => '(3 5 7)
(table (- i j) (i 2) (j 2)) ;; => '((0 -1) (1 0))

(table (list i j k) (i 2) (j 100 200 100) (k 5 6))
;; =>
'((((1 100 5) (1 100 6)) ((1 200 5) (1 200 6)))
(((2 100 5) (2 100 6)) ((2 200 5) (2 200 6))))

[Jeremy Jones]

Xah Lee wrote:

Very very nice! I don't know scheme well... but oh the macros, such a
wonderful facility...

Macros suck. They created by moron so-called computer scientists and IT
puntits in order opress the programming masses. But I say we must bring
freedom to all programmers. In order abolish this criminality against
humanity and even programmers, I recommend creating a flurry of
irrelevant messages cross-posting to noncommonalitou s groups. If you
need dictionary to find what that word means, you a moron! F*ck
dictionaries! F*ck macros! F*ck ignoramous computer scientists! F*ck
so-called netiquette! Power to programmers!

Only when we have created sufficient confusion and frustration among all
programming entities, then they will beg us to shut up. Only then they
be willing remove macros from all languages if we willing shut up. Then
we shut up and see macros removed. But only for a little while. Then
we campaign to get floating point roman numerals implemented.
Functional lang never let me down.

Functional languages evil. Any language support functions come from
ivory tower brain lacking idiots who think they know something. All
other languages should take a lesson from Python which does not support
functions. If Python supports functions, I have not read that informations.
I haven't worked on a Java version yet... but i wonder what pain i'll
have to endure for a lang that lacks eval. Since i'm not Java expert...
i wonder if i can even do it in a few days.

Xah
xa*@xahlee.org
∑ http://xahlee.org/

Power to programmers!

JJ

[gene tani]

Dear Mr. Jones:

Our team of 3,972 expert testers judged the output of your
troll-spewing neural net virtually indistinguishab le from the original.
Given this, I am please to announce that our firm is willing to
discuss arrangements for an exclusive license that you would likely
find financially compelling. Please do not post the code on
sourcefurge or whatever you call that open source thing until you speak
with us.

S. Ballmer

[Duncan Booth]

Xah Lee wrote:

oops, another error. The example should be:

Table(f,[1,2,1],[2,6,2]) returns
[[f(1,2),f(1,4),f (1,6)],[f(2,2),f(2,4),f (2,6)]]

Wouldn't it be more sensible just to take the iterators directly as
arguments, so for this example you would do:

Table(f, range(1,3), range(2,7,2))

well yes... but this was emulation of Mathematica functions.
(Disclaimer: Mathematica is a trademark of Wolfram Research Inc, who is
not affliated with this project)

What you suggested is a function called Outer in Mathematica. The Table
function is in a sense multi-dimentional version of Range, so they
share syntax form.

Ok, so, if I understand you, the definition of Table is just:

def Table(f, *lists):
return Outer(f,
*[range(start,end +1,step) for (start,end,step ) in lists])

Is that about right?

[Duncan Booth]

Duncan Booth wrote:

Ok, so, if I understand you, the definition of Table is just:

def Table(f, *lists):
return Outer(f,
*[range(start,end +1,step) for (start,end,step ) in lists])

Is that about right?

And lest you think I left a bit too much as an "exercise for the
reader":

-------------- xah.py --------------------
def Table(f, *lists):
"""Xah Lee's Table function

Table(f,[3,10,2]) [f(3), f(5), f(7), f(9)] Table(f,[1,2,1],[2,6,2]) [[f(1, 2), f(1, 4), f(1, 6)], [f(2, 2), f(2, 4), f(2, 6)]]
"""
return Outer(f, *[range(start,end +1,step) for (start,end,step ) in lists])

def explode(lists):
"""Form all combinations of 1 element from each list. explode([[1,2], [3]]) [(1, 3), (2, 3)] explode([[1,2], [3,4]]) [(1, 3), (1, 4), (2, 3), (2, 4)] explode([[1,2], [3,4], [5]]) [(1, 3, 5), (1, 4, 5), (2, 3, 5), (2, 4, 5)]
"""
result = [()]
for l in lists[::-1]:
result = [ (val,) + tail for val in l for tail in result ]

return result

def groupsOfN(it, n):
"""Returns tuples of length n taken from it. groupsOfN(range (12), 3) [(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11)] groupsOfN(range (12), 1) [(0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,), (10,), (11,)]
"""
it = iter(it)
return zip(*([it]*n))

def Outer(f, *lists):
""" Outer(f, range(1,3), range(2,7,2))

[[f(1, 2), f(1, 4), f(1, 6)], [f(2, 2), f(2, 4), f(2, 6)]]
"""
result = [f(*args) for args in explode(lists)]
for l in lists[:0:-1]:
result =[list(v) for v in groupsOfN(resul t, len(l))]
return result

def _test():
global f
class f:
def __init__(self, *args):
self.args = args
def __repr__(self):
if len(self.args) == 1:
return "%s(%r)" % (self.__class__ .__name__.split ('.')[-1], self.args[0])
else:
return "%s%r" % (self.__class__ .__name__.split ('.')[-1], self.args)

import doctest
doctest.testmod ()

if __name__ == "__main__":
_test()
------------------------------------------