ASPL Guide to Operations v 1.00
© 2024 by SetSphere.COM


5. 8
   g*& gets the shallow subgroups and elements intersection

 

logo

g*& a1 a2 [a3 .. aN]       where a1 a2 [a3 .. aN] are set variables

g*&`mtm~ a1 a2 [a3 .. aN]

g*&/mtm~ a1 a2 [a3 .. aN]

g*&

When specified by itself then the operation is performed on the object on top of the stack and the one that is one below it, then the result is pushed on the stack

tsetop  asetoid  2**  notcommu        ins:H_H_H  ous:H_H_AH

●  Operator g*& gets the shallow subgroups and the elements intersection

Use the operator g*& to get the intersection of groups in datasets by shallow matching the names of their subdiretories and files. Shallow matching is a match between two strings based on some intermediate function that takes as input both strings and returns true or false based on the function internal processing. ASPL provides shallow matching through an internal module that the user can edit and make changes to it. The shallow module functions are selectable, the ASPL command shallowed displays the current shallow function being used by ASPL, and the command ~shallowed edits the shallowed module.

 

g*& EXAMPLE
In this example we will do a shallow set operation on Java Jar archives to locate the Java transaction classes. We will load the sample JMXJAR workspace then we will issue shallow set operations on the datasets. We will locate the files in JMX Jar files where the word transaction occurs. In particular we will match the subgroups and elements that contain the word "transac" and then we will get the shallow intersection of the groups (subdirectories and classes) found in these datasets (representing the JMX Jar files).

 

g*& OPERATION

# aspl JMXJAR
    (start ASPL loading JMXJAR)

①  aspl> v
    (display the variables.)

②  aspl> shallowed
    (display the shallow processors table.)

③  aspl> setshallowed prcrelem
    (set the shallow processor to prcrelem.)

④  aspl> setprcr transac
    (set the shallow preprocessor to transac.)

⑤  aspl> shallowed
    (display the shallow processors table. notice the change, now the processor is prcrelem, and its preprocessor is transac.)

⑥  aspl> g*& tx1 tx2
    (do a shallow set intersection on the groups (or subdirectories and files) between tx1 and tx2)

⑦  aspl> g*& tx1 tx2 tx3
    (do a shallow set intersection on the groups (or subdirectories and files) between tx1 tx2 and tx3)

 

● Tickable Predicates for g*&

This g*& is tickable with predicates that are shown in the following table:

       a yellow note
g*&`_  gets the shallow subgroups and the elements intersection with one to many matching regex relations 
g*&`c=  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have the same checksum 
g*&`c~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have different checksums 
g*&`c~~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have all over different checksums 
g*&`h=  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have the same entropy 
g*&`h~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have different entropies 
g*&`h~~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have all over different entropies 
g*&`mtm=  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have the same make time 
g*&`mtm~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have different make times 
g*&`mtm~~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have all over different make times 
g*&`mtm<  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have a prior make time 
g*&`mtm<=  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have prior or same make time 
g*&`mtm>  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have more recent make time 
g*&`mtm>=  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have more recent or same make time 
g*&`ks=  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have the same ksum 
g*&`ks~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have different ksums 
g*&`ks~~  gets the shallow subgroups and the elements intersection with one to many matching regex relations such that they have all over different ksums 
(C)2024 ASPL Inc.