SlideShare une entreprise Scribd logo

The many ways to effectively utilize array processing

•Télécharger en tant que PPT, PDF•
•
Arthur8898
Arthur8898

Utilizing array processing allows us to reduce the amount of coding in the DATA step. In addition to learning how to create one- and multi-dimensional arrays, this paper will review how to create an explicit loop in the DATA step - the prerequisite of constructing an array. You will also be exposed to what happens in the Program Data Vector (PDV) during array processing. A wide range of applications in using loop structures with array processing, such as recoding missing values for a list of variables, transforming datasets, etc., will be covered in this paper.

FormationTechnologieBusiness
1  sur  191
The Many Ways to Effectively Utilize Array Processing Arthur Li
INTRODUCTION ,[object Object],[object Object],[object Object],[object Object],[object Object]
REVIEW: COMPILATION AND EXECUTION PHASES Compilation phase: Each statement is scanned for syntax errors. Execution phase: The DATA step reads and processes the input data. If there is no syntax error A DATA step is processed in two-phase sequences :
REVIEW IMPLICIT AND EXPLICIT LOOPS REVIEW IMPLICIT LOOP Patient: ,[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],M1240 4 F2340 3 F2390 2 M2390 1 ID
REVIEW IMPLICIT LOOP data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; 1 st iteration: ,[object Object],[object Object],[object Object],Patient: PDV: M1240 4 F2340 3 F2390 2 M2390 1 ID . 0 1 K GROUP D RANNUM K ID D _ERROR_ D _N_
REVIEW IMPLICIT LOOP data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; 1 st iteration: ,[object Object],Patient: PDV: M1240 4 F2340 3 F2390 2 M2390 1 ID . M2390 0 1 K GROUP D RANNUM K ID D _ERROR_ D _N_
REVIEW IMPLICIT LOOP 1 st iteration: ,[object Object],Patient: PDV: data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; M1240 4 F2340 3 F2390 2 M2390 1 ID 0.36993 M2390 0 1 K GROUP D RANNUM K ID D _ERROR_ D _N_
REVIEW IMPLICIT LOOP 1 st iteration: ,[object Object],Patient: PDV: data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; M1240 4 F2340 3 F2390 2 M2390 1 ID P 0.36993 M2390 0 1 K GROUP D RANNUM K ID D _ERROR_ D _N_
REVIEW IMPLICIT LOOP 1 st iteration: ,[object Object],[object Object],Patient: PDV: Trial1: data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; M1240 4 F2340 3 F2390 2 M2390 1 ID P 0.36993 M2390 0 1 K GROUP D RANNUM K ID D _ERROR_ D _N_ M2390 ID P GROUP 1
REVIEW IMPLICIT LOOP 2 nd iteration: ,[object Object],Patient: PDV: Trial1: Variables exist in the input dataset ,[object Object],[object Object],data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; M1240 4 F2340 3 F2390 2 M2390 1 ID . M2390 0 2 K GROUP D RANNUM K ID D _ERROR_ D _N_ M2390 ID P GROUP 1
REVIEW IMPLICIT LOOP 2 nd iteration: Patient: PDV: Trial1: Variables being created in the DATA step ,[object Object],data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; M1240 4 F2340 3 F2390 2 M2390 1 ID . M2390 0 2 K GROUP D RANNUM K ID D _ERROR_ D _N_ M2390 ID P GROUP 1
REVIEW IMPLICIT LOOP 2 nd iteration: ,[object Object],Patient: PDV: Trial1: Skip the rest iterations…. data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; M1240 4 F2340 3 F2390 2 M2390 1 ID . M2390 0 2 K GROUP D RANNUM K ID D _ERROR_ D _N_ M2390 ID P GROUP 1
REVIEW: OUTPUT STATEMENT data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ; ,[object Object],[object Object],[object Object],output ;
REVIEW: OUTPUT STATEMENT ,[object Object],[object Object],[object Object],data trial1 (drop=rannum); set patient; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; run ;
REVIEW: OUTPUT STATEMENT ,[object Object],[object Object],[object Object],[object Object]
REVIEW EXPLICIT LOOP ,[object Object],[object Object],[object Object]
REVIEW EXPLICIT LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2340' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; Assigning IDs in the DATA step
REVIEW EXPLICIT LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2340' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; 4 explicit OUTPUT statements
REVIEW EXPLICIT LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2340' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; 4 almost identical blocks ,[object Object],[object Object],[object Object]
ITERATIVE DO LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; ... id = 'F2340' ; ... id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; DO INDEX-VARIABLE = VALUE1, VALUE2, …, VALUEN ; SAS STATEMENTS END; ,[object Object],[object Object],[object Object],[object Object],rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ;
ITERATIVE DO LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; ... id = 'F2340' ; ... id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; DO INDEX-VARIABLE = VALUE1, VALUE2, …, VALUEN ; SAS STATEMENTS END; data trial2 (drop = rannum); do id = 'M2390' , 'F2390' , 'F2340' , 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; end ; run ;
THE ITERATIVE DO LOOP ALONG A SEQUENCE OF INTEGERS data trial3 (drop = rannum); do id = 1 to 4 ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; end ; run ; ,[object Object],DO INDEX-VARIABLE = START TO STOP < BY INCREMENT> ; SAS STATEMENTS END; ,[object Object],[object Object],[object Object],[object Object]
PURPOSE OF USING ARRAYS ,[object Object],[object Object],[object Object],data sbp1; set sbp; if sbp1 = 999 then sbp1 = . ; if sbp2 = 999 then sbp2 = . ; if sbp3 = 999 then sbp3 = . ; if sbp4 = 999 then sbp4 = . ; if sbp5 = 999 then sbp5 = . ; if sbp6 = 999 then sbp6 = . ; run ; ,[object Object],[object Object],[object Object],123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
PURPOSE OF USING ARRAYS ,[object Object],data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2340' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; data trial2 (drop = rannum); do id = 'M2390' , 'F2390' , 'F2340' , 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; end ; run ; ,[object Object],[object Object],Difference: The values of ID variables
PURPOSE OF USING ARRAYS data sbp1; set sbp; if sbp1 = 999 then sbp1 = . ; if sbp2 = 999 then sbp2 = . ; if sbp3 = 999 then sbp3 = . ; if sbp4 = 999 then sbp4 = . ; if sbp5 = 999 then sbp5 = . ; if sbp6 = 999 then sbp6 = . ; run ; Difference: Variable names If we can group these variables into a single unit  We can loop along these variables ARRAY: a temporary grouping of SAS variables 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 6 5 4 3 2 1 SBP
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; ,[object Object],[object Object],[object Object]
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; ,[object Object],[object Object]
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; ,[object Object],[object Object]
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; ,[object Object],[object Object],[object Object]
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; array sbparray [ 6 ] sbp1 sbp2 sbp3 sbp4 sbp5 sbp6;
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; array sbparray [*] sbp1 sbp2 sbp3 sbp4 sbp5 sbp6; ,[object Object],[object Object]
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; array sbparray ( 6 ) sbp1 sbp2 sbp3 sbp4 sbp5 sbp6; array sbparray { 6 } sbp1 sbp2 sbp3 sbp4 sbp5 sbp6; array sbparray [ 6 ] sbp1 sbp2 sbp3 sbp4 sbp5 sbp6; ,[object Object]
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; array sbp [ 6 ]; = array sbp [ 6 ] sbp1 sbp2 sbp3 sbp4 sbp5 sbp6; ,[object Object],Case1: sbp1 – sbp6 were previously defined in the DATA step Case2: if sbp1 – sbp6 were not previously defined in the DATA step, they will be created by the ARRAY statement
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; array num [*] _numeric_; array char [*] _character_; array allvar [*] _all_; ,[object Object],[object Object],[object Object]
ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; array sbp [ 6 ] sbp1 - sbp6; ,[object Object]
ARRAY DEFINITION AND SYNTAX ARRAYNAME [INDEX]; ,[object Object],[object Object],[object Object],[object Object]
ARRAY DEFINITION AND SYNTAX data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 sbp2 sbp3 sbp4 sbp5 sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; data sbp2 (drop=i); set sbp; array sbp [ 6 ]; do i = 1 to 6 ; if sbp [i] = 999 then sbp [i] = . ; end ; run ; ARRAY: array sbparray [ 6 ] sbp1 - sbp6; array sbp [ 6 ]; = array sbp [ 6 ] sbp1 - sbp6; data sbp1; set sbp; if sbp1 = 999 then sbp1 = . ; if sbp2 = 999 then sbp2 = . ; if sbp3 = 999 then sbp3 = . ; if sbp4 = 999 then sbp4 = . ; if sbp5 = 999 then sbp5 = . ; if sbp6 = 999 then sbp6 = . ; run ; 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
THE DIM FUNCTION data sbp3 (drop=i); set sbp; array sbparray [*] sbp1 - sbp6; do i = 1 to dim(sbparray); if sbparray [i] = 999 then sbparray [i] = . ; end ; run ; ,[object Object],[object Object],DIM (ARRAYNAME)
ASSIGNING INITIAL VALUES TO AN ARRAY ,[object Object],array num[ 3 ] n1 n2 n3 ( 1 2 3 ); array chr[ 3 ] $ ( 'A' , 'B' , 'C' );
TEMPORARY ARRAYS ,[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],array num[ 3 ] _temporary_ ( 1 2 3 );
COMPILATION AND EXECUTION PHASES COMPILATION PHASE data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; ,[object Object],[object Object],[object Object],[object Object],SBP6 K SBP5 K SBP4 K D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE ,[object Object],[object Object],1 st iteration of the DATA step: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; . SBP6 K . SBP5 K . SBP4 K . . . . 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE ,[object Object],1 st iteration of the DATA step: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K . 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE ,[object Object],1 st iteration of the DATA step: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K . 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE ,[object Object],1 st iteration of the DATA step: 1 st iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K 1 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE ,[object Object],[object Object],[object Object],1 st iteration of the DATA step: 1 st iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K 1 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE ,[object Object],1 st iteration of the DATA step: 1 st iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K 1 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE ,[object Object],[object Object],1 st iteration of the DATA step: 2 nd iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K 2 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE 1 st iteration of the DATA step: 2 nd iteration of the DO loop: ,[object Object],[object Object],[object Object],data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K 2 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE 1 st iteration of the DATA step: 2 nd iteration of the DO loop: ,[object Object],[object Object],data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K 2 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1]
EXECUTION PHASE 1 st iteration of the DATA step: ,[object Object],[object Object],data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K 7 137 142 141 1 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE 2 nd iteration of the DATA step: ,[object Object],[object Object],[object Object],data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 124 SBP6 K 116 SBP5 K 117 SBP4 K . 137 142 141 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE 2 nd iteration of the DATA step: ,[object Object],data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 122 SBP6 K 119 SBP5 K 119 SBP4 K . 138 141 999 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE 2 nd iteration of the DATA step: ,[object Object],1 st iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 122 SBP6 K 119 SBP5 K 119 SBP4 K 1 138 141 999 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE ,[object Object],[object Object],2 nd iteration of the DATA step: 1 st iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 122 SBP6 K 119 SBP5 K 119 SBP4 K 1 138 141 999 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE ,[object Object],[object Object],[object Object],2 nd iteration of the DATA step: 1 st iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 122 SBP6 K 119 SBP5 K 119 SBP4 K 1 138 141 . 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE ,[object Object],[object Object],2 nd iteration of the DATA step: 1 st iteration of the DO loop: data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 122 SBP6 K 119 SBP5 K 119 SBP4 K 1 138 141 . 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE 2 nd iteration of the DATA step: ,[object Object],data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 122 SBP6 K 119 SBP5 K 119 SBP4 K 7 138 141 . 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
EXECUTION PHASE 2 nd iteration of the DATA step: ,[object Object],[object Object],[object Object],data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 - sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; 122 SBP6 K 119 SBP5 K 119 SBP4 K 7 138 141 . 2 D I K SBP3 K SBP2 K SBP1 D _N_ 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 SBPARRAY[6] SBPARRAY[5] SBPARRAY[4] SBPARRAY[3] SBPARRAY[2] SBPARRAY[1] 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
SOME ARRAY APPLICATIONS CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; Used to group the existing variables: sbp1 – sbp6 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; Used to create variables: above1 – above6 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; The temporary array is for comparison purposes 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
THE IN OPERATOR data sbp6 (drop = i); set sbp2; array sbp [6]; if . IN sbp then miss = 1 ; else miss = 0 ; run ; 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 0 1 1 0 miss
CALCULATING PRODUCTS OF MULTIPLE VARIABLES data product (drop=i); set test; array num[ 4 ]; if missing(num[ 1 ]) then result = 1 ; else result = num[ 1 ]; do i = 2 to 4 ; if not missing(num[i]) then result =result*num[i]; end ; run ; ,[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],Test: Used to group the existing variables: num1 – num6 1 3 2 . 2 3 2 . 4 1 num4 num3 num2 num1
CALCULATING PRODUCTS OF MULTIPLE VARIABLES data product (drop=i); set test; array num[ 4 ]; if missing(num[ 1 ]) then result = 1 ; else result = num[ 1 ]; do i = 2 to 4 ; if not missing(num[i]) then result =result*num[i]; end ; run ; ,[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],Test: 1 3 2 . 2 3 2 . 4 1 num4 num3 num2 num1
CALCULATING PRODUCTS OF MULTIPLE VARIABLES data product (drop=i); set test; array num[ 4 ]; if missing(num[ 1 ]) then result = 1 ; else result = num[ 1 ]; do i = 2 to 4 ; if not missing(num[i]) then result =result*num[i]; end ; run ; ,[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],Test: 1 3 2 . 2 3 2 . 4 1 num4 num3 num2 num1
RESTRUCTURING DATASETS USING ARRAYS ,[object Object],data with one observation per subject (the wide format) data with multiple observations per subject (the long format) 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
FROM WIDE FORMAT TO LONG FORMAT (WITHOUT USING ARRAYS) Wide: Long: ,[object Object],[object Object],[object Object],[object Object],data long (drop=s1-s3); set wide; time = 1 ; score = s1; if not missing(score) then output ; time = 2 ; score = s2; if not missing(score) then output ; time = 3 ; score = s3; if not missing(score) then output ; run ; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
FROM WIDE FORMAT TO LONG FORMAT(USING ARRAYS) Wide: Long: data long (drop=s1-s3); set wide; time = 1 ; score = s1; if not missing(score) then output ; time = 2 ; score = s2; if not missing(score) then output ; time = 3 ; score = s3; if not missing(score) then output ; run ; array s[ 3 ]; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1]; S[2]; S[3];
FROM WIDE FORMAT TO LONG FORMAT(USING ARRAYS) Wide: Long: data long (drop=s1-s3); set wide; time = 1 ; score = s1; if not missing(score) then output ; time = 2 ; score = s2; if not missing(score) then output ; time = 3 ; score = s3; if not missing(score) then output ; run ; array s[ 3 ]; Create a DO loop – TIME as index variable 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1]; S[2]; S[3];
FROM WIDE FORMAT TO LONG FORMAT(USING ARRAYS) Wide: Long: data long (drop=s1-s3); set wide; time = 1 ; score = s1; if not missing(score) then output ; time = 2 ; score = s2; if not missing(score) then output ; time = 3 ; score = s3; if not missing(score) then output ; run ; array s[ 3 ]; do time = 1 to 3 ; score = s[time]; if not missing(score) then output ; end ; data long (drop=s1-s3); set wide; array s[ 3 ]; run ; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1]; S[2]; S[3];
FROM LONG FORMAT TO WIDE FORMAT ,[object Object],[object Object],[object Object],Wide: Long: 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
REVIEW THE RETAIN STATEMENT ,[object Object],RETAIN VARIABLE <VALUE>; Name of the variable that we will want to retain ,[object Object],[object Object],[object Object]
REVIEW: THE SUM STATEMENT ,[object Object],VARIABLE + EXPRESSION; ,[object Object],[object Object],[object Object],[object Object],[object Object]
REVIEW: FIRST.VARIABLE AND LAST.VARIABLE ,[object Object],[object Object],Wide: Long: 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
REVIEW: FIRST.VARIABLE AND LAST.VARIABLE ,[object Object],proc sort data =b; by by_variable; run ; data a; set b; by by_variable; ... ... run ; ,[object Object],[object Object],[object Object],[object Object],[object Object]
REVIEW: FIRST.VARIABLE AND LAST.VARIABLE ,[object Object],SAS reads the 1 st observation for ID = A01 SAS reads the last observation for ID = A01 2 A02 5 4 A02 4 2 A01 3 3 A01 2 3 A01 1 SCORE ID 0 1 0 0 1 FIRST.ID 1 0 1 0 0 LAST.ID 2 1 “ GROUPING” Grouping based ID
REVIEW SUBSETTING IF STATEMENT ,[object Object],IF EXPRESSION; ,[object Object],[object Object]
REVIEW SUBSETTING IF STATEMENT ,[object Object],IF EXPRESSION; ,[object Object],[object Object],[object Object],[object Object],[object Object]
FROM LONG FORMAT TO WIDE FORMAT (WITHOUT USING ARRAYS) if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; ,[object Object],[object Object],[object Object],RETAIN S3 S1 S3 S2 S1 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID
FROM LONG FORMAT TO WIDE FORMAT (WITHOUT USING ARRAYS) RETAIN proc sort data =long; by id; data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; S3 S1 S3 S2 S1 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID
EXECUTION PHASE data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; ,[object Object],[object Object],[object Object],[object Object],Long: 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID . . . . . 1 1 1 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . . 3 1 A01 1 1 1 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . . 3 1 A01 0 1 1 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . 3 3 1 A01 0 1 1 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . 3 3 1 A01 0 1 1 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . 3 3 1 A01 0 1 2 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . 3 3 1 A01 0 1 2 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . 3 4 2 A01 0 1 2 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . . 3 4 2 A01 0 0 2 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . 4 3 4 2 A01 0 0 2 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . 4 3 4 2 A01 0 0 2 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . 4 3 4 2 A01 0 0 3 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . 4 3 5 3 A01 0 0 3 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; . 4 3 5 3 A01 1 0 3 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 3 5 3 A01 1 0 3 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 3 5 3 A01 1 0 3 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 3 5 3 A01 1 0 3 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 3 5 3 A01 1 0 4 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 3 4 1 A02 1 0 4 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 3 4 1 A02 0 1 4 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 4 4 1 A02 0 1 4 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 4 4 1 A02 0 1 4 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 4 4 1 A02 0 1 5 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 4 2 3 A02 0 1 5 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 5 4 4 2 3 A02 1 0 5 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 2 4 4 2 3 A02 1 0 5 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; 2 4 4 2 3 A02 1 0 5 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE ,[object Object],[object Object],[object Object],data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; How to fix this? 2 4 4 2 3 A02 1 0 5 K S3 K S2 K S1 D SCORE D TIME K ID D LAST.ID D FIRST.ID D _N_ 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 2 4 4 A02 2 3 S1 4 S2 5 A01 1 S3 ID
EXECUTION PHASE data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ;
FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; if first.id then do ; do i = 1 to 3 ; s[i] = . ; end ; end ; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3]
FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3] D LAST.ID D FIRST.ID D _N_ D SCORE D TIME K ID K S3 K S2 K S1 S[3] S[2] S[1] 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; S[TIME] 3 retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3] 0 1 1 D LAST.ID D FIRST.ID D _N_ 3 1 A01 D SCORE D TIME K ID . . . K S3 K S2 K S1 S[3] S[2] S[1]
FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; S[TIME] 3 4 retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3] 0 0 2 D LAST.ID D FIRST.ID D _N_ 4 2 A01 D SCORE D TIME K ID . . . K S3 K S2 K S1 S[3] S[2] S[1]
FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; s[time] = score; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3]
FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; if first.id then do ; do i = 1 to 3 ; s[i] = . ; end ; end ; s[time] = score; if last.id; run ; data wide (drop = time score i); set long; by id; array s[ 3 ]; retain s; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3]
MULTIDIMENSIONAL ARRAYS ARRAY ARRAYNAME[R, C, …] <$> <ELEMENTS>; ,[object Object],[object Object],[object Object],[object Object]
MULTIDIMENSIONAL ARRAYS array a[2,3]; equivalent to … array a[2,3] a1 - a6; a6 a5 a4 2 1 a3 a2 a1 3 2 1 a[2,2] a[1,3]
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: Dat2: ,[object Object],[object Object],[object Object],B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID C C F_ G3 C B F_ G1 D F M_ G3 A B M_ G2 B B 2 2 A A 1 1 F_ G2 M_ G1 ID 0 1 0 1 FIRST.ID 1 0 1 0 LAST.ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: Dat2: G[3]: ALL_G[2,3]: Use to group existing variables Use to create new variables RETAIN i + 1; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID C C F_ G3 C B F_ G1 D F M_ G3 A B M_ G2 B B 2 2 A A 1 1 F_ G2 M_ G1 ID G3 G2 G1 3 2 1 F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1]
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY proc sort data =dat1; by id; run ; data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ;
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; ALL_G [I,J] Dat1: At the beginning of the 1 st iteration: G [J] ARRAY TRACKING B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D . G1 D . G2 D . G3 D . ID K 1 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 1 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 1 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 1 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 2 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 2 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1 ] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 2 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 3 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1 ] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 3 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 3 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (4 th DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 4 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 4 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 1 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 1 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 1 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 2 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 2 0 2 D J D FIRST.ID D _N_ A F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 2 0 2 D J D FIRST.ID D _N_ A F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 3 0 2 D J D FIRST.ID D _N_ A F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 3 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 3 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (4 th DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 2 nd iteration: ALL_G [I,J] G [J] Dat2: B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 1 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 1 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 1 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 2 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 2 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 2 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 3 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 3 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 3 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (4 th DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 4 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 4 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D . 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D . 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D . 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 1 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 1 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 1 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 2 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 2 0 4 D J D FIRST.ID D _N_ B F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 2 0 4 D J D FIRST.ID D _N_ B F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 3 0 4 D J D FIRST.ID D _N_ B F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i =
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing
The many ways to effectively utilize array processing

Recommandé

Get the scoop on the loop how best to write a loop in the data step
Get the scoop on the loop how best to write a loop in the data stepGet the scoop on the loop how best to write a loop in the data step
Get the scoop on the loop how best to write a loop in the data stepArthur8898
 
Optiva-13449_TestResults
Optiva-13449_TestResultsOptiva-13449_TestResults
Optiva-13449_TestResultsHarvey Canaan
 
Session 3
Session 3Session 3
Session 3Shailendra Mathur
 
Lec3 final
Lec3 finalLec3 final
Lec3 finalGichelle Amon
 
Pipelining and vector processing
Pipelining and vector processingPipelining and vector processing
Pipelining and vector processingKamal Acharya
 
Python for Beginners(v2)
Python for Beginners(v2)Python for Beginners(v2)
Python for Beginners(v2)Panimalar Engineering College
 
Selection & Making Decisions in c
Selection & Making Decisions in cSelection & Making Decisions in c
Selection & Making Decisions in cyndaravind
 
Plsql programs
Plsql programsPlsql programs
Plsql programsKnowledge Center Computer
 

Recommandé

Get the scoop on the loop how best to write a loop in the data step
Get the scoop on the loop how best to write a loop in the data stepGet the scoop on the loop how best to write a loop in the data step
Get the scoop on the loop how best to write a loop in the data stepArthur8898
 
Optiva-13449_TestResults
Optiva-13449_TestResultsOptiva-13449_TestResults
Optiva-13449_TestResultsHarvey Canaan
 
Session 3
Session 3Session 3
Session 3Shailendra Mathur
 
Lec3 final
Lec3 finalLec3 final
Lec3 finalGichelle Amon
 
Pipelining and vector processing
Pipelining and vector processingPipelining and vector processing
Pipelining and vector processingKamal Acharya
 
Python for Beginners(v2)
Python for Beginners(v2)Python for Beginners(v2)
Python for Beginners(v2)Panimalar Engineering College
 
Selection & Making Decisions in c
Selection & Making Decisions in cSelection & Making Decisions in c
Selection & Making Decisions in cyndaravind
 
Plsql programs
Plsql programsPlsql programs
Plsql programsKnowledge Center Computer
 
Bikalpa_Thapa_Python_Programming_(Basics).pptx
Bikalpa_Thapa_Python_Programming_(Basics).pptxBikalpa_Thapa_Python_Programming_(Basics).pptx
Bikalpa_Thapa_Python_Programming_(Basics).pptxBikalpa Thapa
 
Oracle - Program with PL/SQL - Lession 04
Oracle - Program with PL/SQL - Lession 04Oracle - Program with PL/SQL - Lession 04
Oracle - Program with PL/SQL - Lession 04Thuan Nguyen
 
Data Match Merging in SAS
Data Match Merging in SASData Match Merging in SAS
Data Match Merging in SASguest2160992
 
Dti2143 chap 4 control statement part 2
Dti2143 chap 4 control statement part 2Dti2143 chap 4 control statement part 2
Dti2143 chap 4 control statement part 2alish sha
 
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docxE2 – Fundamentals, Functions & ArraysPlease refer to announcements.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docxshandicollingwood
 
CONTROLSTRUCTURES.ppt
CONTROLSTRUCTURES.pptCONTROLSTRUCTURES.ppt
CONTROLSTRUCTURES.pptSanjjaayyy
 
ICP - Lecture 7 and 8
ICP - Lecture 7 and 8ICP - Lecture 7 and 8
ICP - Lecture 7 and 8Hassaan Rahman
 
Conditional statements
Conditional statementsConditional statements
Conditional statementsNabishaAK
 
C programming Control Structure.pptx
C programming Control Structure.pptxC programming Control Structure.pptx
C programming Control Structure.pptxDEEPAK948083
 
E1 – FundamentalsPlease refer to announcements for details about.docx
E1 – FundamentalsPlease refer to announcements for details about.docxE1 – FundamentalsPlease refer to announcements for details about.docx
E1 – FundamentalsPlease refer to announcements for details about.docxjacksnathalie
 
C Programming: Control Structure
C Programming: Control StructureC Programming: Control Structure
C Programming: Control StructureSokngim Sa
 
Decision Making and Branching
Decision Making and BranchingDecision Making and Branching
Decision Making and BranchingMunazza-Mah-Jabeen
 
computer programming Control Statements.pptx
computer programming Control Statements.pptxcomputer programming Control Statements.pptx
computer programming Control Statements.pptxeaglesniper008
 
Csci101 lect04 advanced_selection
Csci101 lect04 advanced_selectionCsci101 lect04 advanced_selection
Csci101 lect04 advanced_selectionElsayed Hemayed
 
Decision making and branching in c programming
Decision making and branching in c programmingDecision making and branching in c programming
Decision making and branching in c programmingPriyansh Thakar
 
Control statments in c
Control statments in cControl statments in c
Control statments in cCGC Technical campus,Mohali
 
PL-SQL.pdf
PL-SQL.pdfPL-SQL.pdf
PL-SQL.pdfAnas Nakash
 
Plsql coding conventions
Plsql coding conventionsPlsql coding conventions
Plsql coding conventionsFang Yu
 
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docxE2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docxjacksnathalie
 
Issta13 workshop on debugging
Issta13 workshop on debuggingIssta13 workshop on debugging
Issta13 workshop on debuggingAbhik Roychoudhury
 
PROCESS RECORDING FORMAT.docx
PROCESS RECORDING FORMAT.docxPROCESS RECORDING FORMAT.docx
PROCESS RECORDING FORMAT.docxPoojaSen20
 
Advanced Views - Calendar View in Odoo 17
Advanced Views - Calendar View in Odoo 17Advanced Views - Calendar View in Odoo 17
Advanced Views - Calendar View in Odoo 17Celine George
 

Contenu connexe

Similaire à The many ways to effectively utilize array processing

Bikalpa_Thapa_Python_Programming_(Basics).pptx
Bikalpa_Thapa_Python_Programming_(Basics).pptxBikalpa_Thapa_Python_Programming_(Basics).pptx
Bikalpa_Thapa_Python_Programming_(Basics).pptxBikalpa Thapa
 
Oracle - Program with PL/SQL - Lession 04
Oracle - Program with PL/SQL - Lession 04Oracle - Program with PL/SQL - Lession 04
Oracle - Program with PL/SQL - Lession 04Thuan Nguyen
 
Data Match Merging in SAS
Data Match Merging in SASData Match Merging in SAS
Data Match Merging in SASguest2160992
 
Dti2143 chap 4 control statement part 2
Dti2143 chap 4 control statement part 2Dti2143 chap 4 control statement part 2
Dti2143 chap 4 control statement part 2alish sha
 
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docxE2 – Fundamentals, Functions & ArraysPlease refer to announcements.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docxshandicollingwood
 
CONTROLSTRUCTURES.ppt
CONTROLSTRUCTURES.pptCONTROLSTRUCTURES.ppt
CONTROLSTRUCTURES.pptSanjjaayyy
 
Conditional statements
Conditional statementsConditional statements
Conditional statementsNabishaAK
 
C programming Control Structure.pptx
C programming Control Structure.pptxC programming Control Structure.pptx
C programming Control Structure.pptxDEEPAK948083
 
E1 – FundamentalsPlease refer to announcements for details about.docx
E1 – FundamentalsPlease refer to announcements for details about.docxE1 – FundamentalsPlease refer to announcements for details about.docx
E1 – FundamentalsPlease refer to announcements for details about.docxjacksnathalie
 
C Programming: Control Structure
C Programming: Control StructureC Programming: Control Structure
C Programming: Control StructureSokngim Sa
 
computer programming Control Statements.pptx
computer programming Control Statements.pptxcomputer programming Control Statements.pptx
computer programming Control Statements.pptxeaglesniper008
 
Csci101 lect04 advanced_selection
Csci101 lect04 advanced_selectionCsci101 lect04 advanced_selection
Csci101 lect04 advanced_selectionElsayed Hemayed
 
Decision making and branching in c programming
Decision making and branching in c programmingDecision making and branching in c programming
Decision making and branching in c programmingPriyansh Thakar
 
Plsql coding conventions
Plsql coding conventionsPlsql coding conventions
Plsql coding conventionsFang Yu
 
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docxE2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docxjacksnathalie
 

Similaire à The many ways to effectively utilize array processing (20)

Bikalpa_Thapa_Python_Programming_(Basics).pptx
Bikalpa_Thapa_Python_Programming_(Basics).pptxBikalpa_Thapa_Python_Programming_(Basics).pptx
Bikalpa_Thapa_Python_Programming_(Basics).pptx
 
Oracle - Program with PL/SQL - Lession 04
Oracle - Program with PL/SQL - Lession 04Oracle - Program with PL/SQL - Lession 04
Oracle - Program with PL/SQL - Lession 04
 
Data Match Merging in SAS
Data Match Merging in SASData Match Merging in SAS
Data Match Merging in SAS
 
Dti2143 chap 4 control statement part 2
Dti2143 chap 4 control statement part 2Dti2143 chap 4 control statement part 2
Dti2143 chap 4 control statement part 2
 
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docxE2 – Fundamentals, Functions & ArraysPlease refer to announcements.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcements.docx
 
CONTROLSTRUCTURES.ppt
CONTROLSTRUCTURES.pptCONTROLSTRUCTURES.ppt
CONTROLSTRUCTURES.ppt
 
ICP - Lecture 7 and 8
ICP - Lecture 7 and 8ICP - Lecture 7 and 8
ICP - Lecture 7 and 8
 
Conditional statements
Conditional statementsConditional statements
Conditional statements
 
C programming Control Structure.pptx
C programming Control Structure.pptxC programming Control Structure.pptx
C programming Control Structure.pptx
 
E1 – FundamentalsPlease refer to announcements for details about.docx
E1 – FundamentalsPlease refer to announcements for details about.docxE1 – FundamentalsPlease refer to announcements for details about.docx
E1 – FundamentalsPlease refer to announcements for details about.docx
 
C Programming: Control Structure
C Programming: Control StructureC Programming: Control Structure
C Programming: Control Structure
 
Decision Making and Branching
Decision Making and BranchingDecision Making and Branching
Decision Making and Branching
 
computer programming Control Statements.pptx
computer programming Control Statements.pptxcomputer programming Control Statements.pptx
computer programming Control Statements.pptx
 
Csci101 lect04 advanced_selection
Csci101 lect04 advanced_selectionCsci101 lect04 advanced_selection
Csci101 lect04 advanced_selection
 
Decision making and branching in c programming
Decision making and branching in c programmingDecision making and branching in c programming
Decision making and branching in c programming
 
Control statments in c
Control statments in cControl statments in c
Control statments in c
 
PL-SQL.pdf
PL-SQL.pdfPL-SQL.pdf
PL-SQL.pdf
 
Plsql coding conventions
Plsql coding conventionsPlsql coding conventions
Plsql coding conventions
 
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docxE2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docx
E2 – Fundamentals, Functions & ArraysPlease refer to announcemen.docx
 
Issta13 workshop on debugging
Issta13 workshop on debuggingIssta13 workshop on debugging
Issta13 workshop on debugging
 

Dernier

PROCESS RECORDING FORMAT.docx
PROCESS RECORDING FORMAT.docxPROCESS RECORDING FORMAT.docx
PROCESS RECORDING FORMAT.docxPoojaSen20
 
Advanced Views - Calendar View in Odoo 17
Advanced Views - Calendar View in Odoo 17Advanced Views - Calendar View in Odoo 17
Advanced Views - Calendar View in Odoo 17Celine George
 
Key note speaker Neum_Admir Softic_ENG.pdf
Key note speaker Neum_Admir Softic_ENG.pdfKey note speaker Neum_Admir Softic_ENG.pdf
Key note speaker Neum_Admir Softic_ENG.pdfAdmir Softic
 
Mixin Classes in Odoo 17 How to Extend Models Using Mixin Classes
Mixin Classes in Odoo 17 How to Extend Models Using Mixin ClassesMixin Classes in Odoo 17 How to Extend Models Using Mixin Classes
Mixin Classes in Odoo 17 How to Extend Models Using Mixin ClassesCeline George
 
Role Of Transgenic Animal In Target Validation-1.pptx
Role Of Transgenic Animal In Target Validation-1.pptxRole Of Transgenic Animal In Target Validation-1.pptx
Role Of Transgenic Animal In Target Validation-1.pptxNikitaBankoti2
 
Web & Social Media Analytics Previous Year Question Paper.pdf
Web & Social Media Analytics Previous Year Question Paper.pdfWeb & Social Media Analytics Previous Year Question Paper.pdf
Web & Social Media Analytics Previous Year Question Paper.pdfJayanti Pande
 
Unit-IV; Professional Sales Representative (PSR).pptx
Unit-IV; Professional Sales Representative (PSR).pptxUnit-IV; Professional Sales Representative (PSR).pptx
Unit-IV; Professional Sales Representative (PSR).pptxVishalSingh1417
 
1029 - Danh muc Sach Giao Khoa 10 . pdf
1029 - Danh muc Sach Giao Khoa 10 . pdf1029 - Danh muc Sach Giao Khoa 10 . pdf
1029 - Danh muc Sach Giao Khoa 10 . pdfQucHHunhnh
 
This PowerPoint helps students to consider the concept of infinity.
This PowerPoint helps students to consider the concept of infinity.This PowerPoint helps students to consider the concept of infinity.
This PowerPoint helps students to consider the concept of infinity.christianmathematics
 
Z Score,T Score, Percential Rank and Box Plot Graph
Z Score,T Score, Percential Rank and Box Plot GraphZ Score,T Score, Percential Rank and Box Plot Graph
Z Score,T Score, Percential Rank and Box Plot GraphThiyagu K
 
Measures of Dispersion and Variability: Range, QD, AD and SD
Measures of Dispersion and Variability: Range, QD, AD and SDMeasures of Dispersion and Variability: Range, QD, AD and SD
Measures of Dispersion and Variability: Range, QD, AD and SDThiyagu K
 
Application orientated numerical on hev.ppt
Application orientated numerical on hev.pptApplication orientated numerical on hev.ppt
Application orientated numerical on hev.pptRamjanShidvankar
 
On National Teacher Day, meet the 2024-25 Kenan Fellows
On National Teacher Day, meet the 2024-25 Kenan FellowsOn National Teacher Day, meet the 2024-25 Kenan Fellows
On National Teacher Day, meet the 2024-25 Kenan FellowsMebane Rash
 
Energy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural Resources
Energy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural ResourcesEnergy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural Resources
Energy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural ResourcesShubhangi Sonawane
 
ICT role in 21st century education and it's challenges.
ICT role in 21st century education and it's challenges.ICT role in 21st century education and it's challenges.
ICT role in 21st century education and it's challenges.MaryamAhmad92
 
Beyond the EU: DORA and NIS 2 Directive's Global Impact
Beyond the EU: DORA and NIS 2 Directive's Global ImpactBeyond the EU: DORA and NIS 2 Directive's Global Impact
Beyond the EU: DORA and NIS 2 Directive's Global ImpactPECB
 
The basics of sentences session 2pptx copy.pptx
The basics of sentences session 2pptx copy.pptxThe basics of sentences session 2pptx copy.pptx
The basics of sentences session 2pptx copy.pptxheathfieldcps1
 
The basics of sentences session 3pptx.pptx
The basics of sentences session 3pptx.pptxThe basics of sentences session 3pptx.pptx
The basics of sentences session 3pptx.pptxheathfieldcps1
 

Dernier (20)

PROCESS RECORDING FORMAT.docx
PROCESS RECORDING FORMAT.docxPROCESS RECORDING FORMAT.docx
PROCESS RECORDING FORMAT.docx
 
Advanced Views - Calendar View in Odoo 17
Advanced Views - Calendar View in Odoo 17Advanced Views - Calendar View in Odoo 17
Advanced Views - Calendar View in Odoo 17
 
Key note speaker Neum_Admir Softic_ENG.pdf
Key note speaker Neum_Admir Softic_ENG.pdfKey note speaker Neum_Admir Softic_ENG.pdf
Key note speaker Neum_Admir Softic_ENG.pdf
 
Mixin Classes in Odoo 17 How to Extend Models Using Mixin Classes
Mixin Classes in Odoo 17 How to Extend Models Using Mixin ClassesMixin Classes in Odoo 17 How to Extend Models Using Mixin Classes
Mixin Classes in Odoo 17 How to Extend Models Using Mixin Classes
 
Role Of Transgenic Animal In Target Validation-1.pptx
Role Of Transgenic Animal In Target Validation-1.pptxRole Of Transgenic Animal In Target Validation-1.pptx
Role Of Transgenic Animal In Target Validation-1.pptx
 
Web & Social Media Analytics Previous Year Question Paper.pdf
Web & Social Media Analytics Previous Year Question Paper.pdfWeb & Social Media Analytics Previous Year Question Paper.pdf
Web & Social Media Analytics Previous Year Question Paper.pdf
 
Asian American Pacific Islander Month DDSD 2024.pptx
Asian American Pacific Islander Month DDSD 2024.pptxAsian American Pacific Islander Month DDSD 2024.pptx
Asian American Pacific Islander Month DDSD 2024.pptx
 
INDIA QUIZ 2024 RLAC DELHI UNIVERSITY.pptx
INDIA QUIZ 2024 RLAC DELHI UNIVERSITY.pptxINDIA QUIZ 2024 RLAC DELHI UNIVERSITY.pptx
INDIA QUIZ 2024 RLAC DELHI UNIVERSITY.pptx
 
Unit-IV; Professional Sales Representative (PSR).pptx
Unit-IV; Professional Sales Representative (PSR).pptxUnit-IV; Professional Sales Representative (PSR).pptx
Unit-IV; Professional Sales Representative (PSR).pptx
 
1029 - Danh muc Sach Giao Khoa 10 . pdf
1029 - Danh muc Sach Giao Khoa 10 . pdf1029 - Danh muc Sach Giao Khoa 10 . pdf
1029 - Danh muc Sach Giao Khoa 10 . pdf
 
This PowerPoint helps students to consider the concept of infinity.
This PowerPoint helps students to consider the concept of infinity.This PowerPoint helps students to consider the concept of infinity.
This PowerPoint helps students to consider the concept of infinity.
 
Z Score,T Score, Percential Rank and Box Plot Graph
Z Score,T Score, Percential Rank and Box Plot GraphZ Score,T Score, Percential Rank and Box Plot Graph
Z Score,T Score, Percential Rank and Box Plot Graph
 
Measures of Dispersion and Variability: Range, QD, AD and SD
Measures of Dispersion and Variability: Range, QD, AD and SDMeasures of Dispersion and Variability: Range, QD, AD and SD
Measures of Dispersion and Variability: Range, QD, AD and SD
 
Application orientated numerical on hev.ppt
Application orientated numerical on hev.pptApplication orientated numerical on hev.ppt
Application orientated numerical on hev.ppt
 
On National Teacher Day, meet the 2024-25 Kenan Fellows
On National Teacher Day, meet the 2024-25 Kenan FellowsOn National Teacher Day, meet the 2024-25 Kenan Fellows
On National Teacher Day, meet the 2024-25 Kenan Fellows
 
Energy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural Resources
Energy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural ResourcesEnergy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural Resources
Energy Resources. ( B. Pharmacy, 1st Year, Sem-II) Natural Resources
 
ICT role in 21st century education and it's challenges.
ICT role in 21st century education and it's challenges.ICT role in 21st century education and it's challenges.
ICT role in 21st century education and it's challenges.
 
Beyond the EU: DORA and NIS 2 Directive's Global Impact
Beyond the EU: DORA and NIS 2 Directive's Global ImpactBeyond the EU: DORA and NIS 2 Directive's Global Impact
Beyond the EU: DORA and NIS 2 Directive's Global Impact
 
The basics of sentences session 2pptx copy.pptx
The basics of sentences session 2pptx copy.pptxThe basics of sentences session 2pptx copy.pptx
The basics of sentences session 2pptx copy.pptx
 
The basics of sentences session 3pptx.pptx
The basics of sentences session 3pptx.pptxThe basics of sentences session 3pptx.pptx
The basics of sentences session 3pptx.pptx
 

The many ways to effectively utilize array processing

  • 1. The Many Ways to Effectively Utilize Array Processing Arthur Li
  • 2.
  • 3. REVIEW: COMPILATION AND EXECUTION PHASES Compilation phase: Each statement is scanned for syntax errors. Execution phase: The DATA step reads and processes the input data. If there is no syntax error A DATA step is processed in two-phase sequences :
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17. REVIEW EXPLICIT LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2340' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; Assigning IDs in the DATA step
  • 18. REVIEW EXPLICIT LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2340' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; 4 explicit OUTPUT statements
  • 19.
  • 20.
  • 21. ITERATIVE DO LOOP data trial2(drop = rannum); id = 'M2390' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; id = 'F2390' ; ... id = 'F2340' ; ... id = 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; run ; DO INDEX-VARIABLE = VALUE1, VALUE2, …, VALUEN ; SAS STATEMENTS END; data trial2 (drop = rannum); do id = 'M2390' , 'F2390' , 'F2340' , 'M1240' ; rannum = ranuni( 2 ); if rannum> 0.5 then group = 'D' ; else group = 'P' ; output ; end ; run ;
  • 22.
  • 23.
  • 24.
  • 25. PURPOSE OF USING ARRAYS data sbp1; set sbp; if sbp1 = 999 then sbp1 = . ; if sbp2 = 999 then sbp2 = . ; if sbp3 = 999 then sbp3 = . ; if sbp4 = 999 then sbp4 = . ; if sbp5 = 999 then sbp5 = . ; if sbp6 = 999 then sbp6 = . ; run ; Difference: Variable names If we can group these variables into a single unit  We can loop along these variables ARRAY: a temporary grouping of SAS variables 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 6 5 4 3 2 1 SBP
  • 26.
  • 27.
  • 28.
  • 29.
  • 30. ARRAY DEFINITION AND SYNTAX ARRAY ARRAYNAME [DIMENSION] <$> <ELEMENTS>; array sbparray [ 6 ] sbp1 sbp2 sbp3 sbp4 sbp5 sbp6;
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37. ARRAY DEFINITION AND SYNTAX data sbp2 (drop=i); set sbp; array sbparray[ 6 ] sbp1 sbp2 sbp3 sbp4 sbp5 sbp6; do i = 1 to 6 ; if sbparray[i] = 999 then sbparray[i] = . ; end ; run ; data sbp2 (drop=i); set sbp; array sbp [ 6 ]; do i = 1 to 6 ; if sbp [i] = 999 then sbp [i] = . ; end ; run ; ARRAY: array sbparray [ 6 ] sbp1 - sbp6; array sbp [ 6 ]; = array sbp [ 6 ] sbp1 - sbp6; data sbp1; set sbp; if sbp1 = 999 then sbp1 = . ; if sbp2 = 999 then sbp2 = . ; if sbp3 = 999 then sbp3 = . ; if sbp4 = 999 then sbp4 = . ; if sbp5 = 999 then sbp5 = . ; if sbp6 = 999 then sbp6 = . ; run ; 123 121 118 142 140 136 4 999 120 119 139 999 142 3 122 119 119 138 141 999 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60. SOME ARRAY APPLICATIONS CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; Used to group the existing variables: sbp1 – sbp6 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
  • 61. CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; Used to create variables: above1 – above6 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
  • 62. CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; The temporary array is for comparison purposes 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
  • 63. CREATING A GROUP OF VARIABLES BY USING ARRAYS Pre-treatment Post-treatment MEAN SBP: 140 120 data sbp4 (drop=i); set sbp2; array sbp[ 6 ]; array above[ 6 ]; array threshhold[ 6 ] _temporary_ ( 140 140 140 120 120 120 ); do i = 1 to 6 ; if (not missing(sbp[i])) then above [i] = sbp[i] > threshhold[i]; end ; run ; 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 1 1 0 1 0 0 4 . 0 0 0 . 1 3 1 0 0 0 1 . 2 1 0 0 0 1 1 1 above6 above5 above4 above3 above2 above1
  • 64. THE IN OPERATOR data sbp6 (drop = i); set sbp2; array sbp [6]; if . IN sbp then miss = 1 ; else miss = 0 ; run ; 123 121 118 142 140 136 4 . 120 119 139 . 142 3 122 119 119 138 141 . 2 124 116 117 137 142 141 1 sbp6 sbp5 sbp4 sbp3 sbp2 sbp1 0 1 1 0 miss
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70. FROM WIDE FORMAT TO LONG FORMAT(USING ARRAYS) Wide: Long: data long (drop=s1-s3); set wide; time = 1 ; score = s1; if not missing(score) then output ; time = 2 ; score = s2; if not missing(score) then output ; time = 3 ; score = s3; if not missing(score) then output ; run ; array s[ 3 ]; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1]; S[2]; S[3];
  • 71. FROM WIDE FORMAT TO LONG FORMAT(USING ARRAYS) Wide: Long: data long (drop=s1-s3); set wide; time = 1 ; score = s1; if not missing(score) then output ; time = 2 ; score = s2; if not missing(score) then output ; time = 3 ; score = s3; if not missing(score) then output ; run ; array s[ 3 ]; Create a DO loop – TIME as index variable 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1]; S[2]; S[3];
  • 72. FROM WIDE FORMAT TO LONG FORMAT(USING ARRAYS) Wide: Long: data long (drop=s1-s3); set wide; time = 1 ; score = s1; if not missing(score) then output ; time = 2 ; score = s2; if not missing(score) then output ; time = 3 ; score = s3; if not missing(score) then output ; run ; array s[ 3 ]; do time = 1 to 3 ; score = s[time]; if not missing(score) then output ; end ; data long (drop=s1-s3); set wide; array s[ 3 ]; run ; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1]; S[2]; S[3];
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82. FROM LONG FORMAT TO WIDE FORMAT (WITHOUT USING ARRAYS) RETAIN proc sort data =long; by id; data wide (drop=time score); set long; by id; retain s1 - s3; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; S3 S1 S3 S2 S1 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.
  • 100.
  • 101.
  • 102.
  • 103.
  • 104.
  • 105.
  • 106.
  • 107.
  • 108.
  • 109.
  • 110.
  • 111. EXECUTION PHASE data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ;
  • 112. FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; if first.id then do ; do i = 1 to 3 ; s[i] = . ; end ; end ; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3]
  • 113. FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3] D LAST.ID D FIRST.ID D _N_ D SCORE D TIME K ID K S3 K S2 K S1 S[3] S[2] S[1] 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID
  • 114. FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; S[TIME] 3 retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3] 0 1 1 D LAST.ID D FIRST.ID D _N_ 3 1 A01 D SCORE D TIME K ID . . . K S3 K S2 K S1 S[3] S[2] S[1]
  • 115. FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; S[TIME] 3 4 retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3] 0 0 2 D LAST.ID D FIRST.ID D _N_ 4 2 A01 D SCORE D TIME K ID . . . K S3 K S2 K S1 S[3] S[2] S[1]
  • 116. FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; s[time] = score; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3]
  • 117. FROM LONG FORMAT TO WIDE FORMAT (USING ARRAYS) data wide (drop=time score); set long; by id; retain s1 - s3; if first.id then do ; s1 = . ; s2 = . ; s3 = . ; end ; if time = 1 then s1 = score; else if time = 2 then s2 = score; else s3 = score; if last.id; run ; array s[ 3 ]; if first.id then do ; do i = 1 to 3 ; s[i] = . ; end ; end ; s[time] = score; if last.id; run ; data wide (drop = time score i); set long; by id; array s[ 3 ]; retain s; retain s; 4 3 S1 . 4 S2 2 A02 2 5 A01 1 S3 ID 3 1 3 2 1 TIME 2 A02 5 4 A02 4 5 A01 3 4 A01 2 3 A01 1 SCORE ID [3] [2] [1] S S[1] S[2] S[3] S[1] S[2] S[3] S[1] S[2] S[3]
  • 118.
  • 119. MULTIDIMENSIONAL ARRAYS array a[2,3]; equivalent to … array a[2,3] a1 - a6; a6 a5 a4 2 1 a3 a2 a1 3 2 1 a[2,2] a[1,3]
  • 120.
  • 121. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: Dat2: G[3]: ALL_G[2,3]: Use to group existing variables Use to create new variables RETAIN i + 1; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID C C F_ G3 C B F_ G1 D F M_ G3 A B M_ G2 B B 2 2 A A 1 1 F_ G2 M_ G1 ID G3 G2 G1 3 2 1 F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1]
  • 122. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY proc sort data =dat1; by id; run ; data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ;
  • 123. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; ALL_G [I,J] Dat1: At the beginning of the 1 st iteration: G [J] ARRAY TRACKING B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D . G1 D . G2 D . G3 D . ID K 1 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 124. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 125. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 126. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 127. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 1 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . . K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 128. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 1 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 129. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 1 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 130. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 2 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K . A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 131. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 2 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1 ] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 132. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 2 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 133. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 3 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K . M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1 ] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 134. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 3 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 135. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 3 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 136. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration (4 th DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 4 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 137. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 1 st iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D 4 1 1 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 138. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D A G1 D B G2 D F G3 D 1 ID K 0 LAST.ID D . 1 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 139. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 140. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 141. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 142. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 1 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K . F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 143. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 1 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 144. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (1 st DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 1 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 145. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 2 0 2 D J D FIRST.ID D _N_ . F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 146. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 2 0 2 D J D FIRST.ID D _N_ A F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 147. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (2 nd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 2 0 2 D J D FIRST.ID D _N_ A F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 148. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 3 0 2 D J D FIRST.ID D _N_ A F_G2 K . F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 149. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 3 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 150. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (3 rd DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 3 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 151. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration (4 th DO loop): ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 152. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 153. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY Dat1: 2 nd iteration: ALL_G [I,J] G [J] data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1
  • 154. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 2 nd iteration: ALL_G [I,J] G [J] Dat2: B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D 4 0 2 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 155. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D C G3 D 1 ID K 1 LAST.ID D . 0 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 156. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 157. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 0 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 158. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 159. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 1 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B A K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 160. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 1 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 161. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 1 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 162. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 2 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K B B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 163. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 2 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 164. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 2 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 165. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 3 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K F M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 166. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 3 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 167. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 3 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 168. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration (4 th DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 4 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 169. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 3 rd iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D 4 1 3 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 170. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D B G1 D A G2 D D G3 D 2 ID K 0 LAST.ID D . 1 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 171. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D . 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 172. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 1 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D . 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 173. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration: Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D . 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 174. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 1 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K B F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 175. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 1 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 176. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (1 st DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 1 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 177. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 2 0 4 D J D FIRST.ID D _N_ A F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 178. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 2 0 4 D J D FIRST.ID D _N_ B F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 179. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (2 nd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 2 0 4 D J D FIRST.ID D _N_ B F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 180. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i = 0 ; i + 1 ; do j = 1 to 3 ; all_g[i,j] = g[j]; end ; if last.id; run ; Dat1: 4 th iteration (3 rd DO loop): Dat2: ALL_G [I,J] G [J] B A A B G2 C C 2 4 D B 2 3 C B 1 2 F A 1 1 G3 G1 ID 2 I D C G1 D B G2 D C G3 D 2 ID K 1 LAST.ID D 3 0 4 D J D FIRST.ID D _N_ B F_G2 K C F_G3 K C F_G1 K D M_G3 K A B K M_G2 K M_G1 ALL_G [2,1] ALL_G [2,2] ALL_G [2,3] ALL_G [1,3] ALL_G [1,2] ALL_G [1,1] G[3] G[2] G[1] F_G3 F_G2 F_G1 2 1 M_G3 M_G2 M_G1 3 2 1 G3 G2 G1 C F_G3 B F_G1 F M_G3 B M_G2 A A 1 1 F_G2 M_G1 ID
  • 181. RESTRUCTURING DATASETS BY USING THE MULTIDIMENSIONAL ARRAY data dat2 (drop = i j g1 - g3); set dat1; by id; array all_g [ 2 , 3 ] $ m_g1 - m_g3 f_g1 - f_g3; array g[ 3 ]; retain all_g; if first.id then i =