# From SETL to Python translation

cyberian bear cyberian_bear at hotmail.com
Mon Mar 12 05:19:07 CET 2001

```Hi guys I have 2 programs below that I must have in Python but I have them
in SETL(whatever the hell that is) and I don't know anything about it. I
tried finding stuff about it on the web but all I found was two small,
irrelevant pages and no tutorials. The thing is, if at least I knew what the
'Euler path construction', or 'Prime factors' are, I could just program them
on my own without looking at the SETL code, but i don't. Basically I just
want to ask some good soul if he could translate these two programs for me
from SETL to Python. I know chances of finding anyone who knows SETL are
negligibe but i guess it's worth a try.
I just want to thank anyone in advance if someone decides to help me. If not
that's OK I understand it's a lot to ask for.
Well. Thanx a lot guys.
cb
PS: my e-mail is cyberian_bear at yahoo.com
----------------------------------------------------------------------------
-------------------
program Euler;    -- Eulerian path construction

graph := {[1,2], [2,3], [3,4], [4,1], [4,2]};             -- a small
graph
print(euler_path(graph + {[y, x]: [x, y] in graph}));        -- which is
undirected.

procedure Euler_path(G);                -- constructs Eulerian path for
graph G

nodes := domain(G);                        -- all nodes in the
graph.

if #(odds := {x in nodes | odd(#G{x})}) > 2 then
return OM;      -- since more than two nodes are
end if;             -- touched by an odd number of edges

-- odds is the set of all nodes of G that
-- are touched by an odd number of edges
x := arb(odds)?arb(nodes);      -- pick a node of odds if possible
-- otherwise pick any node of G

path := [x] + build_path(x,G);

while exists z = path(i) | G{z} /= {} loop
new_p := build_path(z, G); -- insert new section into path
G -:= ({[y,x]: [x,y] in new_p} + {e: e in new_p});
path := path(i..i - 1) + new_p + path(i..);
end loop;

return path;

end Euler_path;

procedure build_path(x, rw G);        -- builds maximal path section
starting at x,
-- and deletes all edges traversed

p := [ ];

while (y := arb G{x}) /= OM loop
-- while there exists an edge leaving the last point
reached
p with:= y;                 -- extend path to traverse the edge
G -:= {[x, y], [y, x]};        -- delete the edge just traversed
x := y;                        -- step to y
end loop;

return p;

end build_path;

end euler;
----------------------------------------------------------------------------
---------------------
package body prime_factors_pak;

procedure prime_factors(n);            -- get tuple  of prime factors of
n

facts := [];        -- will collect

while even(n) loop facts with:= 2; n /:= 2; end loop;        -- even
factors

while exists k in [3,5..ceil(sqrt(float(n)))] | n mod k = 0 loop

facts with:= k; n /:= k;        -- smallest remaining  factor,
up to sqrt(n)

end loop;

facts with:= n;            -- the final factor

return facts;

end prime_factors;

end prime_factors_pak;

```

More information about the Python-list mailing list