(FILECREATED "25-Jun-86 01:28:45" {QV}<PEDERSEN>LISP>EARRAY-CMPFNS.;9
 33450  

      changes to:  (FNS EARRAY-GENERIC-NOT-EQUAL EARRAY-GENERIC-MEMBER EARRAY-GENERIC-INDEXOF 
			EARRAY-FLOAT-EQP EARRAY-FLOAT-GEQ EARRAY-FLOAT-GREATERP EARRAY-FLOAT-INDEXOF 
			EARRAY-FLOAT-LEQ EARRAY-FLOAT-LESSP EARRAY-FLOAT-MEMBER EARRAY-FLOAT-NOT-EQP 
			EARRAY-GENERIC-EQUAL EARRAY-GENERIC-GEQ EARRAY-GENERIC-GREATERP 
			EARRAY-GENERIC-LEQ EARRAY-GENERIC-LESSP)

      previous date: "23-Jun-86 14:08:56" {QV}<PEDERSEN>LISP>EARRAY-CMPFNS.;6)


(* Copyright (c) 1986 by Xerox Corporation. All rights reserved.)

(PRETTYCOMPRINT EARRAY-CMPFNSCOMS)

(RPAQQ EARRAY-CMPFNSCOMS
 ((FNS EARRAY-AND EARRAY-AND-FN EARRAY-EQP EARRAY-EQP-FN EARRAY-EQUAL 
				 EARRAY-EQUAL-FN EARRAY-FLOAT-EQP EARRAY-FLOAT-GEQ 
				 EARRAY-FLOAT-GREATERP EARRAY-FLOAT-INDEXOF EARRAY-FLOAT-LEQ 
				 EARRAY-FLOAT-LESSP EARRAY-FLOAT-MEMBER EARRAY-FLOAT-NOT-EQP 
				 EARRAY-GENERIC-EQUAL EARRAY-GENERIC-GEQ EARRAY-GENERIC-GREATERP 
				 EARRAY-GENERIC-INDEXOF EARRAY-GENERIC-LEQ EARRAY-GENERIC-LESSP 
				 EARRAY-GENERIC-MEMBER EARRAY-GENERIC-NOT-EQUAL EARRAY-GEQ 
				 EARRAY-GEQ-FN EARRAY-GREATERP EARRAY-GREATERP-FN EARRAY-INDEXOF 
				 EARRAY-LEQ EARRAY-LEQ-FN EARRAY-LESSP EARRAY-LESSP-FN EARRAY-MEMBER 
				 EARRAY-NAND EARRAY-NAND-FN EARRAY-NOR EARRAY-NOR-FN EARRAY-NOT 
				 EARRAY-NOT-EQP EARRAY-NOT-EQP-FN EARRAY-NOT-EQUAL 
				 EARRAY-NOT-EQUAL-FN EARRAY-NOT-FN EARRAY-OR EARRAY-OR-FN EARRAY-XOR 
				 EARRAY-XOR-FN)
	(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY (LOCALVARS . T))))
(DEFINEQ

(EARRAY-AND

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 15:28")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 
AND
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-AND-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "23-Jun-86 12:09")


          (* *)



    (
EARRAY-GENERIC-DYADIC-APPLY
 (
FUNCTION
 SCALAR-AND)
				   ARRAY1 ARRAY2 RESULT])

(EARRAY-EQP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 14:48")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 EQP
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-EQP-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "15-Jun-86 15:04")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-EQP
 ARRAY1 ARRAY2 RESULT)
      else
 (
EARRAY-GENERIC-DYADIC-APPLY
 (
FUNCTION
 SCALAR-EQP)
					    ARRAY1 ARRAY2 RESULT])

(EARRAY-EQUAL

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 15:12")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 EQUAL
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-EQUAL-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "23-Jun-86 12:08")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-EQP
 ARRAY1 ARRAY2 RESULT)
      else
 (EARRAY-GENERIC-EQUAL
 ARRAY1 ARRAY2 RESULT])

(EARRAY-FLOAT-EQP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
EQP
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
UFEQP
 SCALAR (
\GETBASEFLOATP

								  ARRAYBASE2
								  (MUL2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
UFEQP
 (
\GETBASEFLOATP
 ARRAYBASE1
										  (MUL2 I))
								SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
			      (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
UFEQP
 (
\GETBASEFLOATP
 ARRAYBASE1
										(MUL2 I))
							      (
\GETBASEFLOATP
 ARRAYBASE2
										(MUL2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-FLOAT-GEQ

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
GEQ
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
UFGEQ
 SCALAR (
\GETBASEFLOATP

								  ARRAYBASE2
								  (MUL2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
UFGEQ
 (
\GETBASEFLOATP
 ARRAYBASE1
										  (MUL2 I))
								SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
			      (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
UFGEQ
 (
\GETBASEFLOATP
 ARRAYBASE1
										(MUL2 I))
							      (
\GETBASEFLOATP
 ARRAYBASE2
										(MUL2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-FLOAT-GREATERP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
GREATERP
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
UFGREATERP
 SCALAR (
\GETBASEFLOATP

								       ARRAYBASE2
								       (MUL2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
UFGREATERP
 (
\GETBASEFLOATP
 ARRAYBASE1
										       (MUL2 I))
								     SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
			      (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
UFGREATERP
 (
\GETBASEFLOATP
 ARRAYBASE1
										     (MUL2 I))
								   (
\GETBASEFLOATP
 ARRAYBASE2
										     (MUL2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-FLOAT-INDEXOF

  [LAMBDA (
ARRAY
 VECTOR RESULT)                            (* jop: "23-Jun-86 22:23")


          (* *)



    (LET ((VECTORSIZE (
EARRAY-TOTAL-SIZE
 VECTOR))
	  (VECTORBASE (
ARRAYBASE
 VECTOR)))
         (if
 (EARRAY-SCALARP ARRAY)
	     then
 (
OR
 [bind
 (SCALAR _(
FLOAT
 ARRAY)) declare
 (TYPE FLOATP SCALAR)
			     for
 I from
 0 upto
 VECTORSIZE thereis
 (
UFEQP

									    SCALAR
									    (
\GETBASEFLOATP

									      VECTORBASE
									      (MUL2 I]
			  VECTORSIZE)
	   else
 (bind
 (
ARRAYBASE
 _(
ARRAYBASE
 ARRAY))
			  (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
		     upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
		     do
 (
ASET
 (
OR
 [bind
 (SCALAR _(
\GETBASEFLOATP
 ARRAYBASE (MUL2 I)))
					   declare
 (TYPE FLOATP SCALAR) for
 J from
 0
					   upto
 VECTORSIZE thereis
 (
UFEQP
 SCALAR
										(
\GETBASEFLOATP

										  VECTORBASE
										  (MUL2 J]
					VECTORSIZE)
				  LINEARIZEDRESULT I))
		  RESULT])

(EARRAY-FLOAT-LEQ

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (
LEQ
 ARRAY1 ARRAY2)
      else
 (if
 (LOGICAL-VALUE (EARRAY-SCALARP ARRAY1))
		 then
 (bind
 (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
UFLEQ
 SCALAR (
\GETBASEFLOATP

								  ARRAYBASE2
								  (MUL2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
UFLEQ
 (
\GETBASEFLOATP
 ARRAYBASE1
										  (MUL2 I))
								SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
			      (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
UFLEQ
 (
\GETBASEFLOATP
 ARRAYBASE1
										(MUL2 I))
							      (
\GETBASEFLOATP
 ARRAYBASE2
										(MUL2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-FLOAT-LESSP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
LESSP
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
UFLESSP
 SCALAR (
\GETBASEFLOATP

								    ARRAYBASE2
								    (MUL2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
UFLESSP
 (
\GETBASEFLOATP
 ARRAYBASE1
										    (MUL2 I))
								  SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
			      (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
UFLESSP
 (
\GETBASEFLOATP
 ARRAYBASE1
										  (MUL2 I))
								(
\GETBASEFLOATP
 ARRAYBASE2
										  (MUL2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-FLOAT-MEMBER

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (EARRAY-SCALARP ARRAY1)
	then
 [LOGICAL-VALUE (if
 (EARRAY-SCALARP ARRAY2)
				  then
 (
EQP
 ARRAY1 ARRAY2)
				else
 (bind
 (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
					       (SCALAR _(
FLOAT
 ARRAY1)) declare
 (TYPE FLOATP 
											  SCALAR)
					  for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 ARRAY2)
					  thereis
 (
UFEQP
 SCALAR (
\GETBASEFLOATP
 ARRAYBASE2
										      (MUL2 I]
      else
 (if
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
UFEQP
 (
\GETBASEFLOATP
 ARRAYBASE1
										  (MUL2 I))
								SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
			      (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (bind
 (SCALAR _(
\GETBASEFLOATP
 ARRAYBASE1
											(MUL2 I)))
							declare
 (TYPE FLOATP SCALAR) for
 J
							from
 0 upto
 (
EARRAY-TOTAL-SIZE
 ARRAY2)
							thereis
 (
UFEQP
 SCALAR
									   (
\GETBASEFLOATP

									     ARRAYBASE2
									     (MUL2 J]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-FLOAT-NOT-EQP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
NOT
 (
EQP
 ARRAY1 ARRAY2)))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
NOT
 (
UFEQP
 SCALAR (
\GETBASEFLOATP

									 ARRAYBASE2
									 (MUL2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) declare
 (TYPE FLOATP SCALAR)
			   for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
NOT
 (
UFEQP
 (
\GETBASEFLOATP

									 ARRAYBASE1
									 (MUL2 I))
								       SCALAR)))
					LINEARIZEDRESULT I))
	       else
 (bind
 (ARRAYBASE1 _(
ARRAYBASE
 ARRAY1))
			      (ARRAYBASE2 _(
ARRAYBASE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
NOT
 (
UFEQP
 (
\GETBASEFLOATP
 ARRAYBASE1
										       (MUL2 I))
								     (
\GETBASEFLOATP
 ARRAYBASE2
										       (MUL2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GENERIC-EQUAL

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
NOT
 (
EQUAL
 ARRAY1 ARRAY2)))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			   upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
NOT
 (
EQUAL
 ARRAY1 (
AREF
 
										 LINEARIZEDARRAY2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			   upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
NOT
 (
EQUAL
 (
AREF
 LINEARIZEDARRAY1 I)
								       ARRAY2)))
					LINEARIZEDRESULT I))
	       else
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
			      (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
NOT
 (
EQUAL
 (
AREF
 LINEARIZEDARRAY1 I)
								     (
AREF
 LINEARIZEDARRAY2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GENERIC-GEQ

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
GEQ
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
GEQ
 SCALAR (
AREF
 LINEARIZEDARRAY2 I)))
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
GEQ
 (
AREF
 LINEARIZEDARRAY1 I)
							      SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
			      (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 (LOGICAL-VALUE (
GEQ
 (
AREF
 LINEARIZEDARRAY1 I)
							    (
AREF
 LINEARIZEDARRAY2 I)))
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GENERIC-GREATERP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
GREATERP
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
GREATERP
 SCALAR (
AREF
 LINEARIZEDARRAY2 I))
						       )
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
GREATERP
 (
AREF
 LINEARIZEDARRAY1 I)
								   SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
			      (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 (LOGICAL-VALUE (
GREATERP
 (
AREF
 LINEARIZEDARRAY1 I)
								 (
AREF
 LINEARIZEDARRAY2 I)))
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GENERIC-INDEXOF

  [LAMBDA (
ARRAY
 VECTOR RESULT)                            (* jop: "24-Jun-86 00:28")


          (* *)



    (if
 (EARRAY-SCALARP ARRAY)
	then
 (
OR
 (for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 VECTOR)
			thereis
 (
EQUAL
 ARRAY (
AREF
 VECTOR I)))
		     (
EARRAY-TOTAL-SIZE
 VECTOR))
      else
 (bind
 (LINEARIZEDARRAY _(
EARRAY-LINEARIZE
 ARRAY))
		     (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
		     (VECTORSIZE _(
EARRAY-TOTAL-SIZE
 VECTOR)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

											  RESULT)
		do
 (
ASET
 (
OR
 (bind
 (
ELT
 _(
AREF
 LINEARIZEDARRAY I)) for
 J from
 0
				      upto
 VECTORSIZE thereis
 (
EQUAL
 ELT (
AREF
 VECTOR J)))
				   VECTORSIZE)
			     LINEARIZEDRESULT I))
	     RESULT])

(EARRAY-GENERIC-LEQ

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
LEQ
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
LEQ
 SCALAR (
AREF
 LINEARIZEDARRAY2 I)))
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
LEQ
 (
AREF
 LINEARIZEDARRAY1 I)
							      SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
			      (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 (LOGICAL-VALUE (
LEQ
 (
AREF
 LINEARIZEDARRAY1 I)
							    (
AREF
 LINEARIZEDARRAY2 I)))
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GENERIC-LESSP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "23-Jun-86 22:23")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
LESSP
 ARRAY1 ARRAY2))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY1)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
LESSP
 SCALAR (
AREF
 LINEARIZEDARRAY2 I)))
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT))
				(SCALAR _(
FLOAT
 ARRAY2)) for
 I from
 0 upto
 (


										
EARRAY-TOTAL-SIZE

										     RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
LESSP
 (
AREF
 LINEARIZEDARRAY1 I)
								SCALAR))
					LINEARIZEDRESULT I))
	       else
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
			      (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 (LOGICAL-VALUE (
LESSP
 (
AREF
 LINEARIZEDARRAY1 I)
							      (
AREF
 LINEARIZEDARRAY2 I)))
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GENERIC-MEMBER

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "24-Jun-86 00:28")


          (* *)



    (if
 (EARRAY-SCALARP ARRAY1)
	then
 [LOGICAL-VALUE (if
 (EARRAY-SCALARP ARRAY2)
				  then
 (
EQUAL
 ARRAY1 ARRAY2)
				else
 (bind
 (LINEARIZEDARRAY _(
EARRAY-LINEARIZE
 ARRAY2))
					  for
 I from
 0 upto
 (
EARRAY-TOTAL-SIZE
 ARRAY2)
					  thereis
 (
EQUAL
 ARRAY1 (
AREF
 LINEARIZEDARRAY I]
      else
 (if
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (LINEARIZEDARRAY _(
EARRAY-LINEARIZE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			   upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
EQUAL
 (
AREF
 LINEARIZEDARRAY I)
								ARRAY2))
					LINEARIZEDRESULT I))
	       else
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
			      (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (bind
 (
ELT
 _(
AREF
 LINEARIZEDARRAY1 I))
							for
 J from
 0 upto
 (
EARRAY-TOTAL-SIZE

										  ARRAY2)
							thereis
 (
EQUAL
 ELT (
AREF
 
										 LINEARIZEDARRAY2 J]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GENERIC-NOT-EQUAL

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "25-Jun-86 01:14")


          (* *)



    (if
 (
AND
 (EARRAY-SCALARP ARRAY1)
		 (EARRAY-SCALARP ARRAY2))
	then
 (LOGICAL-VALUE (
NOT
 (
EQUAL
 ARRAY1 ARRAY2)))
      else
 (if
 (EARRAY-SCALARP ARRAY1)
		 then
 (bind
 (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			   upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 [LOGICAL-VALUE (
NOT
 (
EQUAL
 ARRAY1 (
AREF
 
										 LINEARIZEDARRAY2 I]
					LINEARIZEDRESULT I))
	       elseif
 (EARRAY-SCALARP ARRAY2)
		 then
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
				(LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			   upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			   do
 (
ASET
 (LOGICAL-VALUE (
NOT
 (
EQUAL
 (
AREF
 LINEARIZEDARRAY1 I)
								       ARRAY2)))
					LINEARIZEDRESULT I))
	       else
 (bind
 (LINEARIZEDARRAY1 _(
EARRAY-LINEARIZE
 ARRAY1))
			      (LINEARIZEDARRAY2 _(
EARRAY-LINEARIZE
 ARRAY2))
			      (LINEARIZEDRESULT _(
EARRAY-LINEARIZE
 RESULT)) for
 I from
 0
			 upto
 (
EARRAY-TOTAL-SIZE
 RESULT)
			 do
 (
ASET
 [LOGICAL-VALUE (
NOT
 (
EQUAL
 (
AREF
 LINEARIZEDARRAY1 I)
								     (
AREF
 LINEARIZEDARRAY2 I]
				      LINEARIZEDRESULT I)))
	     RESULT])

(EARRAY-GEQ

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "13-Jun-86 12:53")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 GEQ
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-GEQ-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "15-Jun-86 15:25")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-GEQ
 ARRAY1 ARRAY2 RESULT)
      else
 (EARRAY-GENERIC-GEQ
 ARRAY1 ARRAY2 RESULT])

(EARRAY-GREATERP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "13-Jun-86 12:54")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 GREATERP
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-GREATERP-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "15-Jun-86 15:25")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-GREATERP
 ARRAY1 ARRAY2 RESULT)
      else
 (EARRAY-GENERIC-GREATERP
 ARRAY1 ARRAY2 RESULT])

(EARRAY-INDEXOF

  [LAMBDA (
ARRAY
 VECTOR RESULT)                            (* jop: " 9-Jun-86 16:15")


          (* *)



    (if
 (
NOT
 (
EQ
 (
EARRAY-RANK
 VECTOR)
		       1))
	then
 (
ERROR
 "Not a vector" VECTOR))
    (
SETQ
 RESULT (
TEST-RESULT
 RESULT (
EARRAY-DIMENSIONS
 ARRAY)))
    (if
 (
AND
 (
OR
 (
EQ
 (
EARRAY-ELEMENT-TYPE
 ARRAY)
			     (
QUOTE
 SINGLE-FLOAT))
		       (
FIXP
 ARRAY))
		 (
EQ
 (
EARRAY-ELEMENT-TYPE
 VECTOR)
		       (
QUOTE
 SINGLE-FLOAT)))
	then
 (EARRAY-FLOAT-INDEXOF
 ARRAY VECTOR RESULT)
      else
 (EARRAY-GENERIC-INDEXOF
 ARRAY VECTOR RESULT])

(EARRAY-LEQ

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "13-Jun-86 12:55")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 LEQ
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-LEQ-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "15-Jun-86 15:25")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-LEQ
 ARRAY1 ARRAY2 RESULT)
      else
 (EARRAY-GENERIC-LEQ
 ARRAY1 ARRAY2 RESULT])

(EARRAY-LESSP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "13-Jun-86 12:55")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 LESSP
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-LESSP-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "15-Jun-86 15:25")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-LESSP
 ARRAY1 ARRAY2 RESULT)
      else
 (EARRAY-GENERIC-LESSP
 ARRAY1 ARRAY2 RESULT])

(EARRAY-MEMBER

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: " 9-Jun-86 15:52")


          (* *)



    (
SETQ
 RESULT (
EARRAY-TEST-RESULT
 RESULT (
EARRAY-DIMENSIONS
 ARRAY1)))
    (if
 (
AND
 (
OR
 (
EQ
 (
EARRAY-ELEMENT-TYPE
 ARRAY1)
			     (
QUOTE
 SINGLE-FLOAT))
		       (
FIXP
 ARRAY1))
		 (
OR
 (
EQ
 (
EARRAY-ELEMENT-TYPE
 ARRAY2)
			     (
QUOTE
 SINGLE-FLOAT))
		       (
FIXP
 ARRAY2)))
	then
 (EARRAY-FLOAT-MEMBER
 ARRAY1 ARRAY2 RESULT)
      else
 (EARRAY-GENERIC-MEMBER
 ARRAY1 ARRAY2 RESULT])

(EARRAY-NAND

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 15:29")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 NAND)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-NAND-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "23-Jun-86 12:09")


          (* *)



    (
EARRAY-GENERIC-DYADIC-APPLY
 (
FUNCTION
 SCALAR-NAND)
				   ARRAY1 ARRAY2 RESULT])

(EARRAY-NOR

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 15:30")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 NOR
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-NOR-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "23-Jun-86 12:09")


          (* *)



    (
EARRAY-GENERIC-DYADIC-APPLY
 (
FUNCTION
 SCALAR-NOR)
				   ARRAY1 ARRAY2 RESULT])

(EARRAY-NOT

  [LAMBDA (
ARRAY
 RESULT)                                   (* jop: "15-Jun-86 15:31")


          (* *)



    (
EARRAY-MONADIC-APPLY
 (
FUNCTION
 NOT)
			    ARRAY RESULT])

(EARRAY-NOT-EQP

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 14:54")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 NOT-EQP)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-NOT-EQP-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "15-Jun-86 15:07")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-NOT-EQP
 ARRAY1 ARRAY2 RESULT)
      else
 (
EARRAY-GENERIC-DYADIC-APPLY
 (
FUNCTION
 SCALAR-NOT-EQP)
					    ARRAY1 ARRAY2 RESULT])

(EARRAY-NOT-EQUAL

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 15:14")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 NOT-EQUAL)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-NOT-EQUAL-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "23-Jun-86 12:08")


          (* *)



    (if
 (
USE-FLOAT-P
 ARRAY1 ARRAY2)
	then
 (EARRAY-FLOAT-NOT-EQP
 ARRAY1 ARRAY2 RESULT)
      else
 (EARRAY-GENERIC-NOT-EQUAL
 ARRAY1 ARRAY2 RESULT])

(EARRAY-NOT-FN

  [LAMBDA (OP ARRAY RESULT)                                  (* jop: "23-Jun-86 12:05")


          (* *)



    (
EARRAY-GENERIC-MONADIC-APPLY
 (
FUNCTION
 SCALAR-NOT)
				    ARRAY RESULT])

(EARRAY-OR

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 15:31")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 
OR
)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-OR-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "23-Jun-86 12:09")


          (* *)



    (
EARRAY-GENERIC-DYADIC-APPLY
 (
FUNCTION
 SCALAR-OR)
				   ARRAY1 ARRAY2 RESULT])

(EARRAY-XOR

  [LAMBDA (ARRAY1 ARRAY2 RESULT)                             (* jop: "15-Jun-86 15:32")


          (* *)



    (
EARRAY-DYADIC-APPLY
 (
FUNCTION
 XOR)
			   ARRAY1 ARRAY2 RESULT])

(EARRAY-XOR-FN

  [LAMBDA (OP ARRAY1 ARRAY2 RESULT)                          (* jop: "23-Jun-86 12:09")


          (* *)



    (
EARRAY-GENERIC-DYADIC-APPLY
 (
FUNCTION
 SCALAR-XOR)
				   ARRAY1 ARRAY2 RESULT])
)
(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY 
(DECLARE: DOEVAL@COMPILE DONTCOPY

(LOCALVARS . T)
)
)
(PUTPROPS EARRAY-CMPFNS COPYRIGHT ("Xerox Corporation" 1986))
(DECLARE: DONTCOPY
  (FILEMAP (NIL (1560 33262 (EARRAY-AND 1570 . 1781) (EARRAY-AND-FN 1783 . 2009) (EARRAY-EQP 2011 . 2222
) (EARRAY-EQP-FN 2224 . 2561) (EARRAY-EQUAL 2563 . 2778) (EARRAY-EQUAL-FN 2780 . 3077) (
EARRAY-FLOAT-EQP 3079 . 4649) (EARRAY-FLOAT-GEQ 4651 . 6221) (EARRAY-FLOAT-GREATERP 6223 . 7846) (
EARRAY-FLOAT-INDEXOF 7848 . 8938) (EARRAY-FLOAT-LEQ 8940 . 10510) (EARRAY-FLOAT-LESSP 10512 . 12099) (
EARRAY-FLOAT-MEMBER 12101 . 13733) (EARRAY-FLOAT-NOT-EQP 13735 . 15376) (EARRAY-GENERIC-EQUAL 15378 . 
16837) (EARRAY-GENERIC-GEQ 16839 . 18352) (EARRAY-GENERIC-GREATERP 18354 . 19902) (
EARRAY-GENERIC-INDEXOF 19904 . 20767) (EARRAY-GENERIC-LEQ 20769 . 22282) (EARRAY-GENERIC-LESSP 22284
 . 23804) (EARRAY-GENERIC-MEMBER 23806 . 25197) (EARRAY-GENERIC-NOT-EQUAL 25199 . 26662) (EARRAY-GEQ 
26664 . 26875) (EARRAY-GEQ-FN 26877 . 27170) (EARRAY-GREATERP 27172 . 27393) (EARRAY-GREATERP-FN 27395
 . 27703) (EARRAY-INDEXOF 27705 . 28362) (EARRAY-LEQ 28364 . 28575) (EARRAY-LEQ-FN 28577 . 28870) (
EARRAY-LESSP 28872 . 29087) (EARRAY-LESSP-FN 29089 . 29388) (EARRAY-MEMBER 29390 . 29977) (EARRAY-NAND
 29979 . 30188) (EARRAY-NAND-FN 30190 . 30418) (EARRAY-NOR 30420 . 30631) (EARRAY-NOR-FN 30633 . 30859
) (EARRAY-NOT 30861 . 31064) (EARRAY-NOT-EQP 31066 . 31281) (EARRAY-NOT-EQP-FN 31283 . 31632) (
EARRAY-NOT-EQUAL 31634 . 31853) (EARRAY-NOT-EQUAL-FN 31855 . 32164) (EARRAY-NOT-FN 32166 . 32386) (
EARRAY-OR 32388 . 32597) (EARRAY-OR-FN 32599 . 32823) (EARRAY-XOR 32825 . 33032) (EARRAY-XOR-FN 33034
 . 33260)))))
STOP