topic Re: Sort only part of a _temporary_ Array in SAS Programming

Sort only part of a _temporary_ Array

AndersS — Fri, 09 Feb 2024 18:03:37 GMT

Hi! In the Data-step we can use CALL SORTN( of ARRN(*)); to sort all elements in the array ARRN in increasing order. It works fine for both ordinary arrays and _temporary_ arrays.

If the array is not _temporary_ then we can specify the variable names, like CALL SORTN( of ARRN3-ARRN10); to sort only elements 3 to 10. (Note that it is not possible to specify the array element names. CALL SORTN( of ARRN(3) -ARRN(10)); gives ERROR!)

My question: Is it possible to sort only PART of the _temporary_ array in some way. This can be useful.
I have tried a number of different ways, but it did not work.

_Temporary_ arrays are VERY much faster than ordinary arrays. (A way of speeding up ordinary arrays is NOT to include them in the output data set. i.e. they are not included in the file buffer).
Many thanks in advance! /Br Anders

Re: Sort only part of a _temporary_ Array

data_null__ — Fri, 09 Feb 2024 22:10:13 GMT

You cannot use a SAS-Variable-List to reference elements of a temporary array, because they are not variables.

But you can sort elements of a temporary array if you reference them properly. array-name[subscript]. I don't know if my example is adequate but seems reasonable.

48         data _null_;
49            array a[5] _temporary_ (1 1 4 3 2);
50            do i = 1 to dim(a); put (a[i])(=); end;
51            put ' ';
52            call sortn(a[3],a[4],a[5]);
53            do i = 1 to dim(a); put (a[i])(=); end;
54            run;

a[1]=1
a[2]=1
a[3]=4
a[4]=3
a[5]=2

a[1]=1
a[2]=1
a[3]=2
a[4]=3
a[5]=4

Re: Sort only part of a _temporary_ Array

Ksharp — Sat, 10 Feb 2024 02:44:00 GMT

Just code it on your own ,if you have too many members in _temporary_ array.

data _null_;
array a[10] _temporary_ (1 1 4 3 2   5 4 3 2 1);
/*sort the member of arrary from 6th to 10th*/
do i=6 to 10;
 do j=i+1 to 10;
  if a{i}>a{j} then do;temp=a{i};a{i}=a{j};a{j}=temp; end;
 end;
end;
drop i j temp;

/*print this array*/
do i=1 to 10;
 put a{i}= ;
end;
run;

344  data _null_;
345  array a[10] _temporary_ (1 1 4 3 2   5 4 3 2 1);
346  /*sort the member of arrary from 6th to 10th*/
347  do i=6 to 10;
348   do j=i+1 to 10;
349    if a{i}>a{j} then do;temp=a{i};a{i}=a{j};a{j}=temp; end;
350   end;
351  end;
352  drop i j temp;
353
354  /*print this array*/
355  do i=1 to 10;
356   put a{i}= ;
357  end;
358  run;

a[1]=1
a[2]=1
a[3]=4
a[4]=3
a[5]=2
a[6]=1
a[7]=2
a[8]=3
a[9]=4
a[10]=5
NOTE: “DATA 语句”所用时间（总处理时间）:
      实际时间          0.03 秒
      CPU 时间          0.00 秒

Re: Sort only part of a _temporary_ Array

AndersS — Sat, 10 Feb 2024 09:42:51 GMT

Hi! It works for a few elements. But I have several thousand. /Br Anders

Re: Sort only part of a _temporary_ Array

AndersS — Sat, 10 Feb 2024 09:47:28 GMT

Hi! This is a version of the classical "Bubble sort". Yes it works. /Br Anders

Re: Sort only part of a _temporary_ Array

FreelanceReinh — Sat, 10 Feb 2024 10:17:19 GMT

Hi @AndersS,

@AndersS wrote:

Hi! It works for a few elements. But I have several thousand. /Br Anders

This should not be an obstacle. You can build the list for the argument of CALL SORTN programmatically.

Example:

/* Create two lists of array elements */

data _null_;
length g1 g2 $80;
do i=37 to 45;
  g1=catx(',',g1,cat('a[',i,']'));
end;
call symputx('group1',g1);
do i=5 to 77 by 9;
  g2=catx(',',g2,cat('a[',i,']'));
end;
call symputx('group2',g2);
run;

/* Sort those parts of a temporary array */

data _null_;
array a[81] _temporary_;
do i=1 to dim(a);
  a[i]=82-i;
end;
call sortn(&group1);
call sortn(&group2);
do i=1 to dim(a);
  put a[i] 3. @;
  if ~mod(i,9) then put;
end;
run;

Result:

 81 80 79 78  5 76 75 74 73
 72 71 70 69 14 67 66 65 64
 63 62 61 60 23 58 57 56 55
 54 53 52 51 32 49 48 47 46
 37 38 39 40 41 42 43 44 45
 36 35 34 33 50 31 30 29 28
 27 26 25 24 59 22 21 20 19
 18 17 16 15 68 13 12 11 10
  9  8  7  6 77  4  3  2  1

Re: Sort only part of a _temporary_ Array

yabwon — Sat, 10 Feb 2024 12:24:58 GMT

You already have a solution for your question, but just for fun one more:

/* just to print arrays elements */
/* EDIT: */
/* just to print arrays elements */
%macro prArr(A,s=LBound(&A.),e=HBound(&A.),b=1,i=i);
put; do &i. = &s. to &e. by &b.; put &A.[i]=; end;
%mend prArr;

/* list part of array you want to sort */
%macro ArrElem(A,s,e,b=1);
%local i;
%do i = &s. %to &e. %by &b.; %if (&i. NE &s.) %then,; &A.[&i.] %end;
%mend ArrElem;



data _null_;
  array a[10] _temporary_ (5 4 3 2 1  5 4 3 2 1);

  %prArr(a)

  /* one part... */
  call sortn(%ArrElem(a,6,10));

  %prArr(a)
  
  /* [EDIT:] */
  /* or even two parts */
  call sortn(%ArrElem(a,1,3),%ArrElem(a,8,10));

  %prArr(a)
run;

Bart

Re: Sort only part of a _temporary_ Array

yabwon — Sat, 10 Feb 2024 12:38:39 GMT

One more, just for fun, extension, a bit of "syntactic sugar"

%macro ArrElem(A,elements);
%local i n k o s e b;
%let n=%sysfunc(countw(&elements., %str( )));
%do k=1 %to &n.;
  %let o = %scan(&elements.,&k.,%str( ));
  %let s = %scan(&o.,1,:);
  %let e = %scan(&o.,2,:);
  %let b = %scan(&o.,3,:);
  %if &e.= %then %let e=&s.;
  %if &b.= %then %let b=1;
  %if (&k. NE 1) %then,;
  %do i = &s. %to &e. %by &b.; %if (&i. NE &s.) %then,; &A.[&i.] %end;
%end;
%mend ArrElem;

options mprint;
data _null_;
  array a[10] _temporary_ (5 4 3 2 1  5 4 3 2 1);

  %prArr(a)

  /* one part... */
  call sortn( %ArrElem(a,6:10) );

  %prArr(a)

  /* or even two parts */
  call sortn( %ArrElem(a,1:5:2 8:10) );

  %prArr(a)
run;


data _null_;
  array a[10] _temporary_ (50 5 40 4 30 3 20 2 10 1);

  %prArr(a)

  /* sort even and odd */
  call sortn( %ArrElem(a,1:9:2 2:10:2) );

  %prArr(a)
run;

Bart

Re: Sort only part of a _temporary_ Array

AndersS — Sat, 10 Feb 2024 14:23:25 GMT

Hi! VERY interesting solution. I can not use it, but quite good! /Br Anders

Re: Sort only part of a _temporary_ Array

AndersS — Sat, 10 Feb 2024 14:32:42 GMT

Hi! VERY interesting solution by Bart. Yes it works. I have just tested it.

I dont have any use if ths solution just now.

But I think that these discussions are REALLY GREAT!

/Br Anders

Re: Sort only part of a _temporary_ Array

PeterClemmensen — Mon, 12 Feb 2024 20:03:06 GMT

@AndersS , I see you found your answer.

However, I will chime in and refer you to the article QuickSorting An Array by Paul Dorfman (aka the @hashman).

The %Qsort macro takes an array and sorts it using the Quicksort algorithm. Also, the macro takes the optional parameters lb and hb, so you can easily sort elements 3 to 10.

I recommend reading the entire article. Pure gold 🙂

Re: Sort only part of a _temporary_ Array

AndersS — Mon, 12 Feb 2024 20:18:01 GMT

Hi! Many thanks!

BUT, %QSORT does NOT work in SAS ODA.

Solution: Find the code for %QSORT and include it.

Perhaps later on I will do that.

CALL SORTN is rather good. Good enough now for my needs.
/Br Anders

Anders Sköllermo fil.dr., Sandgränd 13, 178 40 Ekerö, 073-5077373,
anders.skollermo@one.se

Re: Sort only part of a _temporary_ Array

yabwon — Mon, 12 Feb 2024 21:35:30 GMT

100% agree, pure gold! Like all from the man.

Bart

Re: Sort only part of a _temporary_ Array

AndersS — Mon, 12 Feb 2024 21:47:07 GMT

Hi!

(Perhaps stupid question)

Is the SAS code for the macro %QSORT avaiable, as SAS code than can be included directly in the Data-step?

I am using SAS ODA .
I do not know proc fcmp. (Would be nice to learn, but I am writing a paper, and do not have the time).

Does anyone have a good version of %QSORT, that I can download?

MANY THANKS in advance!

/Br Anders

(Age and IQ are 76+. Trying to understand quantile confidence interval estimates).

Re: Sort only part of a _temporary_ Array

hashman — Tue, 13 Feb 2024 01:21:05 GMT

Hi, Anders:

You can copy the entire QSORT macro directly from the pdf paper Peter Clemmensen has linked, then use it as described in the (pretty extensive) comments in the header. Another advantages of using qsort or another method not based on SORTN/C is that you can also sort descending and control what to do with duplicates.

If you don't like to use QSORT for any reason, you can use the hash object to do what you need:

data _null_ ;                                                                                                                                                                                                                                                   
  retain lb 3 hb 8 order "a" ; * use d for descending ;                                                                                                                                                                                                       
  array arr [10] (2 10 444 333 111 888 777 666 4 5) ;                                                                                                                                                                                                          
  if _n_ = 1 then do ;                                                                                                                                                                                                                                          
    dcl hash h (ordered:order, multidata:"y") ;                                                                                                                                                                                                                 
    h.definekey ("k") ;                                                                                                                                                                                                                                         
    h.definedone () ;                                                                                                                                                                                                                                           
    dcl hiter hi ("h") ;                                                                                                                                                                                                                                        
  end ;                                                                                                                                                                                                                                                         
  do _n_ = lb to hb ;                                                                                                                                                                                                                                           
    k = arr[_n_] ;                                                                                                                                                                                                                                              
    h.add() ;                                                                                                                                                                                                                                                   
  end ;                                                                                                                                                                                                                                                         
  do _n_ = lb by 1 while (hi.next() = 0) ;                                                                                                                                                                                                                      
    arr[_n_] = k ;                                                                                                                                                                                                                                              
  end ;                                                                                                                                                                                                                                                        
  put arr(*) ;                                                                                                                                                                                                                                                  
run ;

Alternatively, you can use CALL SORTN against an auxiliary array with the required range and then copy the sorted items back into the array in question, for example:

%let range = 3:8 ; 
data _null_ ; 
  array arr [10] (2 10 444 333 111 888 777 666 4 5) ;
  array aux [&range] _temporary_ ; 
  do _n_ = lbound (aux) to hbound (aux) ; 
    aux [_n_] = arr [_n_] ; 
  end ; 
  call sortn (of aux[*]) ; 
  do _n_ = lbound (aux) to hbound (aux) ; 
    arr [_n_] = aux [_n_] ; 
  end ; 
  put arr(*) ; 
run ;

As far as KSharp's bubble sort is concerned, it's okay for a few items but will get painfully slow even for a thousand since its running time is O(N**2), while all of the above approaches can handle millions of array items in a second or so.

Kind regards

Paul D.

Re: Sort only part of a _temporary_ Array

hashman — Tue, 13 Feb 2024 01:22:30 GMT

Hey Peter,

Thanks 1E6 for your generous plug.

😀

Kind regards

Paul D.

Re: Sort only part of a _temporary_ Array

AndersS — Tue, 13 Feb 2024 09:38:47 GMT

Hi Paul! GREAT. I will use the code from the paper.

The SAS Community and all these discussions are VERY useful. I have used SAS since 1981. I am writing another paper about quantiles, and try NOT to use very SAS specific solutions. /BR Anders

Re: Sort only part of a _temporary_ Array

KachiM — Tue, 13 Feb 2024 11:54:01 GMT

Here is a FCMP based Quick Sort Routine just for your reference.

proc fcmp outlib = work.cmpar.lib;
   subroutine qsort(v[*], left, right); 
   outargs v; 
   if left >= right then return; 
   call swap(v, left, ceil((left + right) / 2));
   last = left;
   do i = left to right;
      if v[i] < v[left] then call swap(v, last, i);
   end;
   call swap(v, left, last);
   call qsort(v, left, last - 1);
   call qsort(v, last + 1, right);
   endsub;
   subroutine swap(v[*], i, j); 
     outargs v;
     temp = v[i];
     v[i] = v[j];
     v[j] = temp;
   endsub;
quit;

options cmplib = work.cmpar;
/* Sort values from 2 to end of the Array k[*] */
data _null_;
   array k[5] _temporary_ (100, 2, 70, 12, 50); 
   call qsort(k, 2, dim(k)); 
   SORTED = catq('d',' ', of k[*]);
   put SORTED =; /* SORTED=100 2 12 50 70 */
run;

Re: Sort only part of a _temporary_ Array

AndersS — Tue, 13 Feb 2024 12:46:24 GMT

Hi! Very nice! I will try it in SAS ODA. /Br Anders

Re: Sort only part of a _temporary_ Array

AndersS — Tue, 13 Feb 2024 18:26:19 GMT

Hi! The hash solution works nicely in SAS ODA. /Br Anders