[2] | 1 | ;+ |
---|
[133] | 2 | ; @file_comments |
---|
| 3 | ; This concatenation function exist in IDL so long |
---|
| 4 | ;as we do not try to stick with a dimension superior or equal at 4. |
---|
[2] | 5 | ; |
---|
[133] | 6 | ; @categories utilities |
---|
[2] | 7 | ; |
---|
[133] | 8 | ; @param a0 {in}{required} |
---|
[2] | 9 | ; |
---|
[133] | 10 | ; @param a1 {in}{required} |
---|
[2] | 11 | ; |
---|
[133] | 12 | ; @param a2 {in}{required} |
---|
[2] | 13 | ; |
---|
[133] | 14 | ; @param a3 {in}{required} |
---|
[2] | 15 | ; |
---|
[133] | 16 | ; @param a4 {in}{required} |
---|
| 17 | ; |
---|
| 18 | ; @param a5 {in}{required} |
---|
| 19 | ; |
---|
| 20 | ; @param a6 {in}{required} |
---|
| 21 | ; |
---|
| 22 | ; @param a7 {in}{required} |
---|
| 23 | ; |
---|
| 24 | ; @param a8 {in}{required} |
---|
| 25 | ; |
---|
| 26 | ; @param a9 {in}{required} |
---|
| 27 | ; |
---|
| 28 | ; @param a10 {in}{required} |
---|
| 29 | ; |
---|
| 30 | ; @param a11 {in}{required} |
---|
| 31 | ; |
---|
| 32 | ; @param a12 {in}{required} |
---|
| 33 | ; |
---|
| 34 | ; @param a13 {in}{required} |
---|
| 35 | ; |
---|
| 36 | ; @param a14 {in}{required} |
---|
| 37 | ; |
---|
| 38 | ; @param a15 {in}{required} |
---|
| 39 | ; |
---|
| 40 | ; @param a16 {in}{required} |
---|
| 41 | ; |
---|
| 42 | ; @param a17 {in}{required} |
---|
| 43 | ; |
---|
| 44 | ; @param a18 {in}{required} |
---|
| 45 | ; |
---|
| 46 | ; @param a19 {in}{required} |
---|
| 47 | ; |
---|
| 48 | ; @param a20 {in}{required} |
---|
| 49 | ; |
---|
| 50 | ; @param CAS 1 {in}{required} |
---|
| 51 | ; table_of_pointer: It is a table of pointers, where each |
---|
| 52 | ; element point on a table to stick |
---|
| 53 | ; |
---|
| 54 | ; For exemple, in a program, we want to stick n table ones with others. |
---|
| 55 | ; |
---|
[2] | 56 | ; tab=ptrarr(n,/allocate_heap) |
---|
| 57 | ; for i=0,n-1 do begin |
---|
| 58 | ; *tab[n]=replicate(n,2,3) |
---|
| 59 | ; endfor |
---|
| 60 | ; res=colle(tab,1) |
---|
| 61 | ; |
---|
[133] | 62 | ; @param CAS 2 {in}{required} |
---|
| 63 | ; we directly give tables to stick |
---|
| 64 | ; Comment: In this case, the plus we can give is 20 tables. |
---|
[2] | 65 | ; |
---|
[133] | 66 | ; BEWARE: whitout the keyword /SAUVE entry arguments are |
---|
| 67 | ; delete when, we build res. In the first case,we |
---|
| 68 | ; delete the table of pointers and variables on which we point. |
---|
[2] | 69 | ; |
---|
[133] | 70 | ; @param direc {in}{required} The direction on which stick them, 1,2,3... |
---|
[2] | 71 | ; |
---|
[133] | 72 | ; @keyword SAUVE mot cle qui force a sauvegarder le tableau de |
---|
[2] | 73 | ; pointeur et les tableaux a coller. |
---|
| 74 | ; |
---|
[133] | 75 | ; @returns res=matrice resultat |
---|
[2] | 76 | ; |
---|
[133] | 77 | ; @examples IDL> print, colle(replicate(1,2,2,2),indgen(2,2,2),2) |
---|
[2] | 78 | ; 1 1 |
---|
| 79 | ; 1 1 |
---|
| 80 | ; 0 1 |
---|
| 81 | ; 2 3 |
---|
| 82 | ; |
---|
| 83 | ; 1 1 |
---|
| 84 | ; 1 1 |
---|
| 85 | ; 4 5 |
---|
| 86 | ; 6 7 |
---|
| 87 | ; |
---|
[133] | 88 | ; @history Sebastien Masson (smasson@lodyc.jussieu.fr) |
---|
[2] | 89 | ; 13/1/98 |
---|
[114] | 90 | ; |
---|
[133] | 91 | ; @version $Id$ |
---|
[114] | 92 | ; |
---|
[133] | 93 | ;- |
---|
[2] | 94 | FUNCTION colle, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, SAUVE = sauve |
---|
[114] | 95 | ; |
---|
| 96 | compile_opt idl2, strictarrsubs |
---|
| 97 | ; |
---|
[2] | 98 | res = -1 |
---|
| 99 | ;------------------------------------------------------------ |
---|
| 100 | ; on met en place ptrtab et direc en fonction des arguments en entree |
---|
| 101 | ;------------------------------------------------------------ |
---|
| 102 | case 1 of |
---|
| 103 | n_params() EQ 2:BEGIN ; cas ou l'on donne directement le tableau de pointeurs |
---|
| 104 | ptrtab = a0 |
---|
| 105 | direc = a1 |
---|
| 106 | if NOT keyword_set(sauve) then undefine, a0 |
---|
| 107 | ; on recupere le nombre de tableaux a coller |
---|
| 108 | nbretab = (size(ptrtab))[1] |
---|
| 109 | end |
---|
| 110 | n_params() GT 2:BEGIN |
---|
| 111 | ; on recupere le nombre de tableaux a coller |
---|
| 112 | nbretab = n_params()-1 |
---|
| 113 | bidon = execute('direc = a'+strtrim(n_params()-1, 2)) |
---|
| 114 | ; on ecrit le tableau de pointeur dont chaque element pointe sur un tableau |
---|
| 115 | ptrtab=ptrarr(nbretab,/allocate_heap) |
---|
| 116 | for n = 0,nbretab-1 do begin |
---|
| 117 | bidon = execute('*ptrtab[n]=a'+strtrim(n, 2)) |
---|
| 118 | if NOT keyword_set(sauve) then bidon = execute('undefine, a'+strtrim(n, 2)) |
---|
| 119 | endfor |
---|
| 120 | sauve = 0 |
---|
| 121 | end |
---|
| 122 | ELSE: |
---|
| 123 | endcase |
---|
| 124 | ;------------------------------------------------------------ |
---|
| 125 | ; case sur la valeure de direc |
---|
| 126 | ;------------------------------------------------------------ |
---|
| 127 | case direc of |
---|
[7] | 128 | 1:BEGIN ; on colle suivant la dimension 1 |
---|
[2] | 129 | res = *ptrtab[0] |
---|
| 130 | if NOT keyword_set(sauve) then ptr_free, ptrtab[0] |
---|
| 131 | FOR n = 1,nbretab-1 DO BEGIN |
---|
| 132 | res = [temporary(res), *ptrtab[n]] |
---|
| 133 | if NOT keyword_set(sauve) then ptr_free, ptrtab[n] |
---|
| 134 | ENDFOR |
---|
| 135 | END |
---|
[7] | 136 | 2:BEGIN ; on colle suivant la dimension 2 |
---|
[2] | 137 | res = *ptrtab[0] |
---|
| 138 | if NOT keyword_set(sauve) then ptr_free, ptrtab[0] |
---|
| 139 | FOR n = 1,nbretab-1 DO BEGIN |
---|
| 140 | res = [[temporary(res)], [*ptrtab[n]]] |
---|
| 141 | if NOT keyword_set(sauve) then ptr_free, ptrtab[n] |
---|
| 142 | ENDFOR |
---|
| 143 | END |
---|
[7] | 144 | 3:BEGIN ; on colle suivant la dimension 3 |
---|
[2] | 145 | res = *ptrtab[0] |
---|
| 146 | if NOT keyword_set(sauve) then ptr_free, ptrtab[0] |
---|
| 147 | FOR n = 1,nbretab-1 DO BEGIN |
---|
| 148 | res = [[[temporary(res)]], [[*ptrtab[n]]]] |
---|
| 149 | if NOT keyword_set(sauve) then ptr_free, ptrtab[n] |
---|
| 150 | ENDFOR |
---|
| 151 | END |
---|
| 152 | ELSE:BEGIN |
---|
| 153 | ; on transpose res de facon a mettre la dimension a coller numero 1. |
---|
| 154 | ; pour cela on contient le vecteur permute qui donne la place que |
---|
| 155 | ; doivent prendre les dimensions ds la matrice transposee |
---|
[31] | 156 | siz = (size(*ptrtab[0]))[0] |
---|
| 157 | if siz LT direc then $ |
---|
| 158 | *ptrtab[0] = reform(*ptrtab[0], [(size(*ptrtab[0]))[1:siz], replicate(1, direc-siz)], /over) |
---|
[2] | 159 | permute = indgen((size(*ptrtab[0]))[0]) |
---|
| 160 | permute[0] = direc-1 |
---|
| 161 | permute[direc-1] = 0 |
---|
| 162 | res = transpose(*ptrtab[0], permute) |
---|
| 163 | if NOT keyword_set(sauve) then ptr_free, ptrtab[0] |
---|
| 164 | FOR n = 1,nbretab-1 DO BEGIN ; on colle suivant la dimension 1 |
---|
[31] | 165 | if (size(*ptrtab[n]))[0] LT direc then $ |
---|
| 166 | *ptrtab[n] = reform(*ptrtab[n], [(size(*ptrtab[n]))[1:siz], replicate(1, direc-siz)]) |
---|
[2] | 167 | res = [temporary(res), transpose(*ptrtab[n], permute)] |
---|
| 168 | if NOT keyword_set(sauve) then ptr_free, ptrtab[n] |
---|
| 169 | ENDFOR |
---|
| 170 | res = transpose(temporary(res), permute) |
---|
| 171 | END |
---|
| 172 | ENDCASE |
---|
| 173 | ;------------------------------------------------------------ |
---|
| 174 | if NOT keyword_set(sauve) then undefine, ptrtab |
---|
| 175 | sortie: |
---|
| 176 | return, res |
---|
| 177 | |
---|
| 178 | |
---|
| 179 | END |
---|
| 180 | |
---|
| 181 | ;------------------------------------------------------------ |
---|