SETL(ID:1268/set002)

Set based programming language 

• Courant usAcademic

• Set

program primes;

$ This program prints out a list of prime numbers
$ which includes all primes less than 200

  n := 200;
  print('Primes less than ',n,' are:');
  primes := {};         $ set of primes output so far
  p := 2;               $ initial value to test
  c := 0;

$ Loop to test successive values

  loop while p < n do   $ loop as long as p less than n
    if notexists t in primes | p mod t = 0 then
      print(p);
      primes with:= p;
      c := c + 1;
    end if;
    p := p + 1;
  end loop;
  print('Number of primes < 200 = ', c);
end program;


Close
Primes
program main;
proc fact;
n:=4;
num:=fact(n);
print(n,' factorial is: ',num);

proc fact(n);
if n=1 then return 1;
else return n*fact(n-1);
end if;
end proc;
end prog;
Close
Factorial
$Sample program - Chapter 11.1
program euler;                  $ Eulerian path construction
proc euler_path,build_path;     $SETLS proc predeclarations
g := {[1,2],[2,3],[3,4],[4,1],[4,2],[3,5],[3,6],[5,6]};
print('initial graph: ',g);
g +:= {[y,x]: [x,y] in g};      $form undirected graph
print('Euler path: ',euler_path(g));

proc 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
      print('too many odd ordered nodes');
      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
    [start_p,g] := build_path(x,g);
    path := [x] + start_p;

    (while exists z = path(i) | g{z}/={})
      [new_p,g] := build_path(z,g);     $insert new section into path
      path := path(1..i) + new_p + path(i+1 ..);
    end;

    return path;
end proc;

proc build_path(x,g);           $builds maximal path section starting
                                $at x, and deletes all edges traversed
  p := [];
  (while (y := arb g{x}) /= om) $while there exists an edge leaving
                                $the last point traversed
     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;
  return [p,g];                 $since g modified, return both
end proc;

end prog;

Close
Euler
program topsort1;
proc tsort1;
  g:= {[1,4],[1,2],[2,4],[3,4],[2,3]};
  nodes := domain g + range g;
  sorted := tsort1(g,nodes);
  print('Sorted list: ',sorted);

procedure tsort1(g,nodes);
           $topological sorting procedure, recursive form
  return
    if exists n in nodes | n notin range g then
      [n]+tsort1(g lessf n,nodes less n)
    else
      []
    end;
end proc;

end prog;
Close
Sort
program topsort2;
proc tsort2;
  g:= {[1,4],[1,2],[2,4],[3,4],[2,3]};
  print('Sorted list: ',tsort2(g));

proc tsort2(g);
        $first iterative form of topological sort
  nodes := domain g + range g;
  t := [];     $initialize tuple to be returned
  (while exists n in nodes | n notin range g)
        t with:=n;
        g lessf:=n;
        nodes less:= n;
  end;
  return t;
end proc;

end prog;
Close
Sort
program prime2;
   $ number is prime if no smaller integer divides it evenly
   print({x:x in [2..200] | (notexists k in [2..x-1] | x mod k = 0)});
end program;
Close
Primes
$Sample program - Chapter 11.1
program euler;                  $ Eulerian path construction
proc euler_path,build_path;     $SETLS proc predeclarations
var g;                          $permit use of g in procs
g := {[1,2],[2,3],[3,4],[4,1],[4,2],[3,5],[3,6],[5,6]};
print('initial graph: ',g);
g +:= {[y,x]: [x,y] in g};      $form undirected graph
print('Euler path: ',euler_path);

proc euler_path;                $constructs eulerian path for graph g
  nodes := domain g;            $all nodes in the graph
    if #(odds := {x in nodes | odd(#g{x})}) > 2 then
      print('too many odd ordered nodes');
      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);

    (while exists z = path(i) | g{z}/={})
      new_p:=build_path(z);     $insert new section into path
      path := path(1..i) + new_p + path(i+1 ..);
    end;

    return path;
end proc;

proc build_path(x);             $builds maximal path section starting
                                $at x, and deletes all edges traversed
  p := [];
  (while (y := arb g{x}) /= om) $while there exists an edge leaving
                                $the last point traversed
     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;
  return p;
end proc;

end prog;

Close
Euler