PostScript - Comparing values for equality + "if" structure - if-statement

Question

I have previously defined
/smth1 [0 1 0] def
/smth2 [-1 0 0] def
I need to check if they are equal, and if they are, perform some action...
For example, (Equal!) show.
I know that I should use eq and, possibly, something like
... {(Equal!) show} if
But I can't figure out how to correctly compare the previously defined smth1 and smth2.
Please advise.

Answer 1

You don't want to compare the arrays, you want to compare the contents of the arrays. Arrays and other compound objects can be tested for equality in PostScript, but that doesn't test their contents, only whether they are the same object.
Eg:
%!
/Array1 [0 0 0] def
/Array2 [0 0 0] def
/Pointer Array1 def
Array1 Array2 eq
{
(Array1 equals Array2\n) print
}
{
(Array1 does not equal Array2\n) print
}
ifelse
Array1 Pointer eq
{
(Array1 equals Pointer\n) print
}
{
(Array1 does not equal Pointer\n) print
}
ifelse
If you run that, you will see that Array1 and Array2 are not equal, but that Array1 and Pointer are. That's because Pointer is (loosely) a pointer to Array1. In fact, the way PostScript works, both are references to the same object. Whereas Array1 and Array2 are references to different objects, even though their contents are the same.
So in your case, you want to retrieve each element of the array, and compare it against the same element in another array. If they are not equal, abort, otherwise, carry on.
Useful operators we will use: length, for, eq, get, dup, exch, if, ifelse
The examples below are not intended to be a working solution but should give you ways to deal with this problem:
Example 1, check the lengths
%!
%% First let us define two arrays of differing lengths
userdict begin %% We'll define these in user dict
/Array1 [0 0 0] def
/Array2 [0 1] def
% So when testing compound objects for equality, we should first
% start by checking the lengths (sizes) of the two objects
Array1 length % Put array1 on the stack then call the 'length' operator
% stack now contains the length of Array1
Array2 length % Put array2 on the stack then call the 'length' operator
% stack now contains the lengths of Array1 and Array2
eq % The eq operator tests the two objects on the stack to
% see if they are equal and returns a boolean
% stack now contains a boolean
% So now we declare some executable arrays, each executable array
% can be thought of as an inline function. We define one for each possible
% value; true or false
{
(Array1 and Array2 are equal!\n) print
}
{
(Array1 and Array2 are not equal!\n) print
}
% The ifelse operator consumes two executable arrays, and a boolean, from
% the operand stack. If the boolean is true it executes the first
% array, otherwise it executes the second.
ifelse
Example 2, now check the contents
%!
%% First let us define two arrays with the same contents
userdict begin %% We'll define these in user dict
/Array1 [0 0 0] def
/Array2 [0 0 0] def
Array1 length Array2 length eq
{
% The 'for' operator consumes 4 operands, the initial value of the loop counter,
% the amount to increment the counter by on each pass, and the terminating
% value of the counter, finally the executable array to execute on each pass.
% So, starting at loop count = 0, incrementing by 1 each time, and stopping
% when the counter is the length of the array. Note! Because we start at 0
% The counter is the array length - 1.
0 1 Array1 length 1 sub
{
%% Now on each pass the top element on the stack is the loop counter
%% We're going to need that twice, once for each array. So we start by
%% taking a copy and putting it on the stack
dup
%% The stack now contains: <loop count> <loop count>
%% Now get the n'th element from the first array:
get
%% The stack now contains: <loop count> <array1 element 'n'>
%% We want to use the loop counter to index the second array, but its not
%% on top of the stack, so swap the top two elements:
exch
%% Stack now contains: <array1 element 'n'> <loop count>
%% Now use the counter to get the n'th element from the second array
get
%% stack now contains: <array1 element n><array 2 element n>
%% check for equality
eq not
{
(Arrays are not equal!\n) print
} if
}
for
}{
(Arrays are not equal in length\n) print
} ifelse
Now there are some obvious corollaries here; arrays are just containers, there is nothing to prevent an array containing another array, or a dictionary, or a string.....
To deal with this, it would be better to define a number of functions to test equality, and call them as required, potentially recursively.
The function above doesn't return anything to indicate success or failure (except output on the back channel). Clearly a boolean result is required. The easiest way to do that is to stick a 'true' on the stack, if the equality fails, pop the true and replace it with a false.
The function doesn't terminate when it finds an inequality, the exit operator could be used to do that (you'll probably want to implement the boolean above first though)
Finally, the function is inefficient, since it constantly copies the same objects out of the current dictionary. Its possible to rewrite the function to do all the operations on the stack, which would be quicker.
Caveat: I haven't actually tested the PostScript programs here, typos are entirely possible :-)