Operations with sets

  Objective: To implement operations with sets:

Intersection of sets

Union of sets

Subtraction of sets

The symmetric difference

A⋃B={x|x∊A or x∊B}

  The intersection of sets A and B is the set

A⋂B={x|x∊A and x∊B}

  The difference of sets A and B is the set

A\B={x|x∊A and x∉B}

  Symmetric difference of sets A and B is the set

A-B=(A\B)⋃(B\A)

  For convenience and clarity creates a class multitude.

('multitude defclass)
('multitude defvar  list)
('multitude defmethod list  ()  list)
('multitude defmethod multitude (x)
  (nil  setq  list
    (nil  if  ((nil type-of x)  = 'multitude)
      (x  list)
      x)))
('multitude defmethod push  (x)
  (nil  setq  list  (nil  cons  x list)))
('multitude defmethod contain (x)
  (nil  let (found)
    (nil  try
      (list for i
        (nil  if  (x  = i)
          (nil  throw 'break)))
      break (nil  setq  found true))
    found))
('multitude defmethod ⋃ (m)
  (nil  let ((union ('multitude newobject m)))
    (list for*  x
      (nil  if  (nil  not (union  contain x))
        (union  push  x)))
    union))
('multitude defmethod ⋂ (m)
  (nil  let ((inter ('multitude newobject)) (lockinter  ('lock  newobject)))
    (list for x
      (nil  if  (m  contain x)
        (lockinter  progn
          (inter  push  x))))
    inter))
('multitude defmethod \ (m)
  (nil  let ((diff  ('multitude newobject)) (lockdiff ('lock  newobject)))
    (list for x
      (nil  if  (nil  not (m  contain x))
        (lockdiff progn
          (diff push  x))))
    diff))
('multitude defmethod - (m)
  (nil  let ((a (this \ m)) (b  (m  \ this)))
    (a  ⋃ b)))

  The constructor can take an argument as a list or set.
  Function contain uses parallelism. Way out of the parallel loop is implemented using exceptions.
  Function ⋃ implements the sequential algorithm. In this task parallelism not available.
  The function ⋂ can find control elements in parallel using the contain. But changing the result inter is protected by a lock lockinter.
  Similarly, the function \ is implemented.
  In the function - parallelism is achieved in the computation of variables a and b.