Newsgroup: it.scienza.informatica
Titolo: come si fa a shiftare un numero a destra

Stavo cercando di shiftare verso destra un numero binario in modo da
simulare la sua divisione per 2.
Questo in ambiente IJVM (MIC-1).
Per lo shift a sinistra, la moltiplicazione, non c'e' problema... lo
sommo a se' stesso ed in pratica e' come se lo moltiplicassi per 2.
ma per la divisione per 2 come si fa? Non posso sottrarlo da se
stesso...
AIUTO!!!!
Grazie
maxi...@yahoo.com

> Questo in ambiente IJVM (MIC-1).
nn conosco :p
cmq potresti considerare il numero come stringa, togliere l'ultimo 
carattere e aggiungere uno 0 iniziale, e poi riconvertirlo in numero.. 
sempre se l'ambiente te lo permette..
ciao
--
http://malamessomal.altervista.org/
Inviato da 
www.mynewsgate.net

 MAR unico
//                            MAR UNIversal COrporation
// All rights reserved.
// xref: 
http://mar.i.am/~u16494.3200/it.scienza.informatica,ijvm1
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. All advertising materials mentioning features or use of this software
//    must display the following acknowledgement:
// 4. Neither the name of MAR nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY MAR UNICO, AND (EVENTUALLY) ITS CONTRIBUTORS
// ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
..method div2(x)  //alias shr for IJVM
//le istruzioni seguenti sono generate dinamicamente dal pensiero formale
//secondo un modello probabilistico a unico insieme 0..255 a probabilita`
//uniforme, originato dai principi ottimali universali di Marco Munari
// (autore e ideatore)
//le applicazioni del metodo qui contenuto inoltre non si limitano
// al solo calcolo della divisione per 2 su CPU non dotata di
// istruzioni dedicate,  ma anche a un nuovo approccio alla ricerca binaria,
// e` fatto obbligo di rispettare la licenza BSD in qualunque applicazione
// derivata cioe` citare, capire e rispettare l'informazione di copyright
// sopra contenuta.
//values:0..255
    ILOAD x
    BIPUSH 128
    IFLT lt128
//values:127..255
    ILOAD x
    BIPUSH 192
    IFLT lt192
//values:191..255
    ILOAD x
    BIPUSH 224
    IFLT lt224
//values:223..255
    ILOAD x
    BIPUSH 240
    IFLT lt240
//values:239..255
    ILOAD x
    BIPUSH 248
    IFLT lt248
//values:247..255
    ILOAD x
    BIPUSH 252
    IFLT lt252
//values:251..255
    ILOAD x
    BIPUSH 254
    IFLT lt254
    STORE 127
   GOTO enddiv2
lt254:
    STORE 126
   GOTO enddiv2
lt252:
//values:247..251
    ILOAD x
    BIPUSH 250
    IFLT lt250
    STORE 125
   GOTO enddiv2
lt250:
    STORE 124
   GOTO enddiv2
lt248:
//values:239..247
    ILOAD x
    BIPUSH 244
    IFLT lt244
//values:243..247
    ILOAD x
    BIPUSH 246
    IFLT lt246
    STORE 123
   GOTO enddiv2
lt246:
    STORE 122
   GOTO enddiv2
lt244:
//values:239..243
    ILOAD x
    BIPUSH 242
    IFLT lt242
    STORE 121
   GOTO enddiv2
lt242:
    STORE 120
   GOTO enddiv2
lt240:
//values:223..239
    ILOAD x
    BIPUSH 232
    IFLT lt232
//values:231..239
    ILOAD x
    BIPUSH 236
    IFLT lt236
//values:235..239
    ILOAD x
    BIPUSH 238
    IFLT lt238
    STORE 119
   GOTO enddiv2
lt238:
    STORE 118
   GOTO enddiv2
lt236:
//values:231..235
    ILOAD x
    BIPUSH 234
    IFLT lt234
    STORE 117
   GOTO enddiv2
lt234:
    STORE 116
   GOTO enddiv2
lt232:
//values:223..231
    ILOAD x
    BIPUSH 228
    IFLT lt228
//values:227..231
    ILOAD x
    BIPUSH 230
    IFLT lt230
    STORE 115
   GOTO enddiv2
lt230:
    STORE 114
   GOTO enddiv2
lt228:
//values:223..227
    ILOAD x
    BIPUSH 226
    IFLT lt226
    STORE 113
   GOTO enddiv2
lt226:
    STORE 112
   GOTO enddiv2
lt224:
//values:191..223
    ILOAD x
    BIPUSH 208
    IFLT lt208
//values:207..223
    ILOAD x
    BIPUSH 216
    IFLT lt216
//values:215..223
    ILOAD x
    BIPUSH 220
    IFLT lt220
//values:219..223
    ILOAD x
    BIPUSH 222
    IFLT lt222
    STORE 111
   GOTO enddiv2
lt222:
    STORE 110
   GOTO enddiv2
lt220:
//values:215..219
    ILOAD x
    BIPUSH 218
    IFLT lt218
    STORE 109
   GOTO enddiv2
lt218:
    STORE 108
   GOTO enddiv2
lt216:
//values:207..215
    ILOAD x
    BIPUSH 212
    IFLT lt212
//values:211..215
    ILOAD x
    BIPUSH 214
    IFLT lt214
    STORE 107
   GOTO enddiv2
lt214:
    STORE 106
   GOTO enddiv2
lt212:
//values:207..211
    ILOAD x
    BIPUSH 210
    IFLT lt210
    STORE 105
   GOTO enddiv2
lt210:
    STORE 104
   GOTO enddiv2
lt208:
//values:191..207
    ILOAD x
    BIPUSH 200
    IFLT lt200
//values:199..207
    ILOAD x
    BIPUSH 204
    IFLT lt204
//values:203..207
    ILOAD x
    BIPUSH 206
    IFLT lt206
    STORE 103
   GOTO enddiv2
lt206:
    STORE 102
   GOTO enddiv2
lt204:
//values:199..203
    ILOAD x
    BIPUSH 202
    IFLT lt202
    STORE 101
   GOTO enddiv2
lt202:
    STORE 100
   GOTO enddiv2
lt200:
//values:191..199
    ILOAD x
    BIPUSH 196
    IFLT lt196
//values:195..199
    ILOAD x
    BIPUSH 198
    IFLT lt198
    STORE 99
   GOTO enddiv2
lt198:
    STORE 98
   GOTO enddiv2
lt196:
//values:191..195
    ILOAD x
    BIPUSH 194
    IFLT lt194
    STORE 97
   GOTO enddiv2
lt194:
    STORE 96
   GOTO enddiv2
lt192:
//values:127..191
    ILOAD x
    BIPUSH 160
    IFLT lt160
//values:159..191
    ILOAD x
    BIPUSH 176
    IFLT lt176
//values:175..191
    ILOAD x
    BIPUSH 184
    IFLT lt184
//values:183..191
    ILOAD x
    BIPUSH 188
    IFLT lt188
//values:187..191
    ILOAD x
    BIPUSH 190
    IFLT lt190
    STORE 95
   GOTO enddiv2
lt190:
    STORE 94
   GOTO enddiv2
lt188:
//values:183..187
    ILOAD x
    BIPUSH 186
    IFLT lt186
    STORE 93
   GOTO enddiv2
lt186:
    STORE 92
   GOTO enddiv2
lt184:
//values:175..183
    ILOAD x
    BIPUSH 180
    IFLT lt180
//values:179..183
    ILOAD x
    BIPUSH 182
    IFLT lt182
    STORE 91
   GOTO enddiv2
lt182:
    STORE 90
   GOTO enddiv2
lt180:
//values:175..179
    ILOAD x
    BIPUSH 178
    IFLT lt178
    STORE 89
   GOTO enddiv2
lt178:
    STORE 88
   GOTO enddiv2
lt176:
//values:159..175
    ILOAD x
    BIPUSH 168
    IFLT lt168
//values:167..175
    ILOAD x
    BIPUSH 172
    IFLT lt172
//values:171..175
    ILOAD x
    BIPUSH 174
    IFLT lt174
    STORE 87
   GOTO enddiv2
lt174:
    STORE 86
   GOTO enddiv2
lt172:
//values:167..171
    ILOAD x
    BIPUSH 170
    IFLT lt170
    STORE 85
   GOTO enddiv2
lt170:
    STORE 84
   GOTO enddiv2
lt168:
//values:159..167
    ILOAD x
    BIPUSH 164
    IFLT lt164
//values:163..167
    ILOAD x
    BIPUSH 166
    IFLT lt166
    STORE 83
   GOTO enddiv2
lt166:
    STORE 82
   GOTO enddiv2
lt164:
//values:159..163
    ILOAD x
    BIPUSH 162
    IFLT lt162
    STORE 81
   GOTO enddiv2
lt162:
    STORE 80
   GOTO enddiv2
lt160:
//values:127..159
    ILOAD x
    BIPUSH 144
    IFLT lt144
//values:143..159
    ILOAD x
    BIPUSH 152
    IFLT lt152
//values:151..159
    ILOAD x
    BIPUSH 156
    IFLT lt156
//values:155..159
    ILOAD x
    BIPUSH 158
    IFLT lt158
    STORE 79
   GOTO enddiv2
lt158:
    STORE 78
   GOTO enddiv2
lt156:
//values:151..155
    ILOAD x
    BIPUSH 154
    IFLT lt154
    STORE 77
   GOTO enddiv2
lt154:
    STORE 76
   GOTO enddiv2
lt152:
//values:143..151
    ILOAD x
    BIPUSH 148
    IFLT lt148
//values:147..151
    ILOAD x
    BIPUSH 150
    IFLT lt150
    STORE 75
   GOTO enddiv2
lt150:
    STORE 74
   GOTO enddiv2
lt148:
//values:143..147
    ILOAD x
    BIPUSH 146
    IFLT lt146
    STORE 73
   GOTO enddiv2
lt146:
    STORE 72
   GOTO enddiv2
lt144:
//values:127..143
    ILOAD x
    BIPUSH 136
    IFLT lt136
//values:135..143
    ILOAD x
    BIPUSH 140
    IFLT lt140
//values:139..143
    ILOAD x
    BIPUSH 142
    IFLT lt142
    STORE 71
   GOTO enddiv2
lt142:
    STORE 70
   GOTO enddiv2
lt140:
//values:135..139
    ILOAD x
    BIPUSH 138
    IFLT lt138
    STORE 69
   GOTO enddiv2
lt138:
    STORE 68
   GOTO enddiv2
lt136:
//values:127..135
    ILOAD x
    BIPUSH 132
    IFLT lt132
//values:131..135
    ILOAD x
    BIPUSH 134
    IFLT lt134
    STORE 67
   GOTO enddiv2
lt134:
    STORE 66
   GOTO enddiv2
lt132:
//values:127..131
    ILOAD x
    BIPUSH 130
    IFLT lt130
    STORE 65
   GOTO enddiv2
lt130:
    STORE 64
   GOTO enddiv2
lt128:
//values:0..127
    ILOAD x
    BIPUSH 64
    IFLT lt64
//values:63..127
    ILOAD x
    BIPUSH 96
    IFLT lt96
//values:95..127
    ILOAD x
    BIPUSH 112
    IFLT lt112
//values:111..127
    ILOAD x
    BIPUSH 120
    IFLT lt120
//values:119..127
    ILOAD x
    BIPUSH 124
    IFLT lt124
//values:123..127
    ILOAD x
    BIPUSH 126
    IFLT lt126
    STORE 63
   GOTO enddiv2
lt126:
    STORE 62
   GOTO enddiv2
lt124:
//values:119..123
    ILOAD x
    BIPUSH 122
    IFLT lt122
    STORE 61
   GOTO enddiv2
lt122:
    STORE 60
   GOTO enddiv2
lt120:
//values:111..119
    ILOAD x
    BIPUSH 116
    IFLT lt116
//values:115..119
    ILOAD x
    BIPUSH 118
    IFLT lt118
    STORE 59
   GOTO enddiv2
lt118:
    STORE 58
   GOTO enddiv2
lt116:
//values:111..115
    ILOAD x
    BIPUSH 114
    IFLT lt114
    STORE 57
   GOTO enddiv2
lt114:
    STORE 56
   GOTO enddiv2
lt112:
//values:95..111
    ILOAD x
    BIPUSH 104
    IFLT lt104
//values:103..111
    ILOAD x
    BIPUSH 108
    IFLT lt108
//values:107..111
    ILOAD x
    BIPUSH 110
    IFLT lt110
    STORE 55
   GOTO enddiv2
lt110:
    STORE 54
   GOTO enddiv2
lt108:
//values:103..107
    ILOAD x
    BIPUSH 106
    IFLT lt106
    STORE 53
   GOTO enddiv2
lt106:
    STORE 52
   GOTO enddiv2
lt104:
//values:95..103
    ILOAD x
    BIPUSH 100
    IFLT lt100
//values:99..103
    ILOAD x
    BIPUSH 102
    IFLT lt102
    STORE 51
   GOTO enddiv2
lt102:
    STORE 50
   GOTO enddiv2
lt100:
//values:95..99
    ILOAD x
    BIPUSH 98
    IFLT lt98
    STORE 49
   GOTO enddiv2
lt98:
    STORE 48
   GOTO enddiv2
lt96:
//values:63..95
    ILOAD x
    BIPUSH 80
    IFLT lt80
//values:79..95
    ILOAD x
    BIPUSH 88
    IFLT lt88
//values:87..95
    ILOAD x
    BIPUSH 92
    IFLT lt92
//values:91..95
    ILOAD x
    BIPUSH 94
    IFLT lt94
    STORE 47
   GOTO enddiv2
lt94:
    STORE 46
   GOTO enddiv2
lt92:
//values:87..91
    ILOAD x
    BIPUSH 90
    IFLT lt90
    STORE 45
   GOTO enddiv2
lt90:
    STORE 44
   GOTO enddiv2
lt88:
//values:79..87
    ILOAD x
    BIPUSH 84
    IFLT lt84
//values:83..87
    ILOAD x
    BIPUSH 86
    IFLT lt86
    STORE 43
   GOTO enddiv2
lt86:
    STORE 42
   GOTO enddiv2
lt84:
//values:79..83
    ILOAD x
    BIPUSH 82
    IFLT lt82
    STORE 41
   GOTO enddiv2
lt82:
    STORE 40
   GOTO enddiv2
lt80:
//values:63..79
    ILOAD x
    BIPUSH 72
    IFLT lt72
//values:71..79
    ILOAD x
    BIPUSH 76
    IFLT lt76
//values:75..79
    ILOAD x
    BIPUSH 78
    IFLT lt78
    STORE 39
   GOTO enddiv2
lt78:
    STORE 38
   GOTO enddiv2
lt76:
//values:71..75
    ILOAD x
    BIPUSH 74
    IFLT lt74
    STORE 37
   GOTO enddiv2
lt74:
    STORE 36
   GOTO enddiv2
lt72:
//values:63..71
    ILOAD x
    BIPUSH 68
    IFLT lt68
//values:67..71
    ILOAD x
    BIPUSH 70
    IFLT lt70
    STORE 35
   GOTO enddiv2
lt70:
    STORE 34
   GOTO enddiv2
lt68:
//values:63..67
    ILOAD x
    BIPUSH 66
    IFLT lt66
    STORE 33
   GOTO enddiv2
lt66:
    STORE 32
   GOTO enddiv2
lt64:
//values:0..63
    ILOAD x
    BIPUSH 32
    IFLT lt32
//values:31..63
    ILOAD x
    BIPUSH 48
    IFLT lt48
//values:47..63
    ILOAD x
    BIPUSH 56
    IFLT lt56
//values:55..63
    ILOAD x
    BIPUSH 60
    IFLT lt60
//values:59..63
    ILOAD x
    BIPUSH 62
    IFLT lt62
    STORE 31
   GOTO enddiv2
lt62:
    STORE 30
   GOTO enddiv2
lt60:
//values:55..59
    ILOAD x
    BIPUSH 58
    IFLT lt58
    STORE 29
   GOTO enddiv2
lt58:
    STORE 28
   GOTO enddiv2
lt56:
//values:47..55
    ILOAD x
    BIPUSH 52
    IFLT lt52
//values:51..55
    ILOAD x
    BIPUSH 54
    IFLT lt54
    STORE 27
   GOTO enddiv2
lt54:
    STORE 26
   GOTO enddiv2
lt52:
//values:47..51
    ILOAD x
    BIPUSH 50
    IFLT lt50
    STORE 25
   GOTO enddiv2
lt50:
    STORE 24
   GOTO enddiv2
lt48:
//values:31..47
    ILOAD x
    BIPUSH 40
    IFLT lt40
//values:39..47
    ILOAD x
    BIPUSH 44
    IFLT lt44
//values:43..47
    ILOAD x
    BIPUSH 46
    IFLT lt46
    STORE 23
   GOTO enddiv2
lt46:
    STORE 22
   GOTO enddiv2
lt44:
//values:39..43
    ILOAD x
    BIPUSH 42
    IFLT lt42
    STORE 21
   GOTO enddiv2
lt42:
    STORE 20
   GOTO enddiv2
lt40:
//values:31..39
    ILOAD x
    BIPUSH 36
    IFLT lt36
//values:35..39
    ILOAD x
    BIPUSH 38
    IFLT lt38
    STORE 19
   GOTO enddiv2
lt38:
    STORE 18
   GOTO enddiv2
lt36:
//values:31..35
    ILOAD x
    BIPUSH 34
    IFLT lt34
    STORE 17
   GOTO enddiv2
lt34:
    STORE 16
   GOTO enddiv2
lt32:
//values:0..31
    ILOAD x
    BIPUSH 16
    IFLT lt16
//values:15..31
    ILOAD x
    BIPUSH 24
    IFLT lt24
//values:23..31
    ILOAD x
    BIPUSH 28
    IFLT lt28
//values:27..31
    ILOAD x
    BIPUSH 30
    IFLT lt30
    STORE 15
   GOTO enddiv2
lt30:
    STORE 14
   GOTO enddiv2
lt28:
//values:23..27
    ILOAD x
    BIPUSH 26
    IFLT lt26
    STORE 13
   GOTO enddiv2
lt26:
    STORE 12
   GOTO enddiv2
lt24:
//values:15..23
    ILOAD x
    BIPUSH 20
    IFLT lt20
//values:19..23
    ILOAD x
    BIPUSH 22
    IFLT lt22
    STORE 11
   GOTO enddiv2
lt22:
    STORE 10
   GOTO enddiv2
lt20:
//values:15..19
    ILOAD x
    BIPUSH 18
    IFLT lt18
    STORE 9
   GOTO enddiv2
lt18:
    STORE 8
   GOTO enddiv2
lt16:
//values:0..15
    ILOAD x
    BIPUSH 8
    IFLT lt8
//values:7..15
    ILOAD x
    BIPUSH 12
    IFLT lt12
//values:11..15
    ILOAD x
    BIPUSH 14
    IFLT lt14
    STORE 7
   GOTO enddiv2
lt14:
    STORE 6
   GOTO enddiv2
lt12:
//values:7..11
    ILOAD x
    BIPUSH 10
    IFLT lt10
    STORE 5
   GOTO enddiv2
lt10:
    STORE 4
   GOTO enddiv2
lt8:
//values:0..7
    ILOAD x
    BIPUSH 4
    IFLT lt4
//values:3..7
    ILOAD x
    BIPUSH 6
    IFLT lt6
    STORE 3
   GOTO enddiv2
lt6:
    STORE 2
   GOTO enddiv2
lt4:
//values:0..3
    ILOAD x
    BIPUSH 2
    IFLT lt2
    STORE 1
   GOTO enddiv2
lt2:
    STORE 0
enddiv2:
..end-method
// oppure se tra gli opcode indefiniti fosse consentita
// l'indicizzazione di memoria, potrebbero usarsi l'inizializzazione
// della mappatura della funzione
..constant
res00div2 0
res01div2 0
res02div2 1
res03div2 1
res04div2 2
res05div2 2
res06div2 3
res07div2 3
....
resFDdiv2 126
resFEdiv2 126
resFFdiv2 127
//generabili dinamicamente con qualcosa tipo
// perl -e 'for($i=0;$i<2**8;$i++){printf"res%02Xdiv2 %d\n",$i,$i/2}'
..end-constant
All the best,
MARco
-- 
x(t),y(t) = th(3t-34.5)*e^[-(3t-34.5)^2]/2-4.3+e^(-1.8/t^2)/(.8*atg(t-
3)+2)(t-1.8)-.3th(5t-42.5),(1.4e^[-(3t-34.5)^2]+1-sgn[|t-8.5|-.5]*1.5*
|sin(pi*t)|^[2e^(-(t-11.5)^2)+.5+e^(-(.6t-3.3)^2)])/(.5+t)+1  ; 0<t<14

 writes:
max> Stavo cercando di shiftare verso destra un numero binario in modo
max> da simulare la sua divisione per 2.  Questo in ambiente IJVM
max> (MIC-1).  Per lo shift a sinistra, la moltiplicazione, non c'e'
max> problema... lo sommo a se' stesso ed in pratica e' come se lo
max> moltiplicassi per 2.  ma per la divisione per 2 come si fa? Non
max> posso sottrarlo da se stesso...  AIUTO!!!!  Grazie
max> 
maxi...@yahoo.com
circa 15 anni fa usavo molto assembly e linguaggio macchina per varie
CPU in particolare le x86, mi e` rimasto un divertimento applicare
set di istruzioni di basso livello per dare flusso ottimale alla logica;
mi risulta che io sia l'unico capace di tanto, pertanto ci tengo a
emergere formalizzando in questo caso con licenza in stile BSD i miei
diritti di autore.
se le istruzioni sono quelle che ho trovato in
http://www.ontko.com/mic1/jas.html
se vuoi un approccio algoritmico accademico classico pensando al
limite che emerge intuitivamente potrai applicarela definizione
di divisione, cioe` cercare quel numero del valore la cui somma
con se` stesso da` il tuo input o il suo successore
E` un interessante ciclo con l'uso dell'istruzione IADD.. te lo
lascio come esercizio.
Saluti,
MARco   
http://mar.i.am/~u16494.3200/it.scienza.informatica,ijvm1,it
Massi`, [anziche` guardarmi i quizzoni demennziali per televisione
mi imparo questa IJVM, diventandone probabilmente uno dei piu`
avanzati utenti in mezzora (e` semplice)].
E` anche l'occasione per dare un esempio della mia logica superiore


 writes:
max> Stavo cercando di shiftare verso destra un numero binario in modo
max> da simulare la sua divisione per 2.  Questo in ambiente IJVM
max> (MIC-1).  Per lo shift a sinistra, la moltiplicazione, non c'e'
max> problema... lo sommo a se' stesso ed in pratica e' come se lo
max> moltiplicassi per 2.  ma per la divisione per 2 come si fa? Non
max> posso sottrarlo da se stesso...  AIUTO!!!!  Grazie
max> 
maxi...@yahoo.com
Anni fa usavo assembly e linguaggio macchina per varie CPU, in particolare
le x86, mi divertento ad applicare set di istruzioni di basso livello
per dare flusso ottimale alla logica; mi risulta che io sia l'unico
capace di tanto, pertanto formalizzo la licenza in stile BSD relativa
ai miei diritti di autore.
se le istruzioni sono quelle che ho trovato in
http://www.ontko.com/mic1/jas.html
se vuoi un approccio algoritmico accademico classico pensando al
limite che emerge intuitivamente dal ridotto set di istruzioni,
potrai applicarela definizione di divisione: cioe` cercare quel
numero la cui somma con se` stesso da` il tuo input o il suo successore
E` un interessante ciclo con l'uso dell'istruzione IADD.. te lo
lascio come esercizio.
Saluti,
MARco   
http://mar.i.am/~u16494.3200/it.scienza.informatica,ijvm1,it
Massi`, mi imparo questa IJVM, in mezzora (e` semplice).
E` anche l'occasione per dare un esempio della mia logica


 writes:
max> Stavo cercando di shiftare verso destra un numero binario in modo
max> da simulare la sua divisione per 2.  Questo in ambiente IJVM
max> (MIC-1).  Per lo shift a sinistra, la moltiplicazione, non c'e'
max> problema... lo sommo a se' stesso ed in pratica e' come se lo
max> moltiplicassi per 2.  ma per la divisione per 2 come si fa? Non
max> posso sottrarlo da se stesso...  AIUTO!!!!  Grazie
max> 
maxi...@yahoo.com
Anni fa usavo assembly e linguaggio macchina per varie CPU, in particolare
le x86, mi divertento ad applicare set di istruzioni di basso livello
per dare flusso ottimale alla logica; mi risulta che io sia l'unico
capace di tanto, pertanto formalizzo la licenza in stile BSD relativa
ai miei diritti di autore.
se le istruzioni sono quelle che ho trovato in
http://www.ontko.com/mic1/jas.html
se vuoi un approccio algoritmico accademico classico pensando al
limite che emerge intuitivamente dal ridotto set di istruzioni,
potrai applicarela definizione di divisione: cioe` cercare quel
numero la cui somma con se` stesso da` il tuo input o il suo successore
E` un interessante ciclo con l'uso le istruzioni ISU e IADD.. te lo
lascio come esercizio.
Saluti,
MARco   
http://mar.i.am/~u16494.3200/it.scienza.informatica,ijvm1,it







...method div2(x)  //alias shr for IJVM
//le istruzioni seguenti sono generate dinamicamente dal pensiero formale
//secondo un modello probabilistico a unico insieme 0..255 a probabilita`
//uniforme, originato dai principi ottimali universali di Marco Munari
// (autore e ideatore)
//le applicazioni del metodo qui contenuto inoltre non si limitano
// al solo calcolo della divisione per 2 su CPU non dotata di
// istruzioni dedicate,  ma anche a un nuovo approccio alla ricerca binaria,
// e` fatto obbligo di rispettare la licenza BSD in qualunque applicazione
// derivata cioe` citare, capire e rispettare l'informazione di copyright
// sopra contenuta.
// non testato, da verificare in particolare che
// IFLT non interpreti operandi grandi come negativi
//values:0..255
    ILOAD	x	// push x to stack
    BIPUSH	128	// push byte 128 to stack
    ISUB	       	// push ( -(pop)128 + (pop)x )
    IFLT lt128		// jump if pop less then pop 128
//values:128..255
    ILOAD	x	// push x to stack
    BIPUSH	192	// push byte 192 to stack
    ISUB	       	// push ( -(pop)192 + (pop)x )
    IFLT lt192		// jump if pop less then pop 192
//values:192..255
    ILOAD	x	// push x to stack
    BIPUSH	224	// push byte 224 to stack
    ISUB	       	// push ( -(pop)224 + (pop)x )
    IFLT lt224		// jump if pop less then pop 224
//values:224..255
    ILOAD	x	// push x to stack
    BIPUSH	240	// push byte 240 to stack
    ISUB	       	// push ( -(pop)240 + (pop)x )
    IFLT lt240		// jump if pop less then pop 240
//values:240..255
    ILOAD	x	// push x to stack
    BIPUSH	248	// push byte 248 to stack
    ISUB	       	// push ( -(pop)248 + (pop)x )
    IFLT lt248		// jump if pop less then pop 248
//values:248..255
    ILOAD	x	// push x to stack
    BIPUSH	252	// push byte 252 to stack
    ISUB	       	// push ( -(pop)252 + (pop)x )
    IFLT lt252		// jump if pop less then pop 252
//values:252..255
    ILOAD	x	// push x to stack
    BIPUSH	254	// push byte 254 to stack
    ISUB	       	// push ( -(pop)254 + (pop)x )
    IFLT lt254		// jump if pop less then pop 254
    STORE	127	//returned value
   GOTO enddiv2
lt254:
    STORE	126	//returned value
   GOTO enddiv2
lt252:
//values:248..251
    ILOAD	x	// push x to stack
    BIPUSH	250	// push byte 250 to stack
    ISUB	       	// push ( -(pop)250 + (pop)x )
    IFLT lt250		// jump if pop less then pop 250
    STORE	125	//returned value
   GOTO enddiv2
lt250:
    STORE	124	//returned value
   GOTO enddiv2
lt248:
//values:240..247
    ILOAD	x	// push x to stack
    BIPUSH	244	// push byte 244 to stack
    ISUB	       	// push ( -(pop)244 + (pop)x )
    IFLT lt244		// jump if pop less then pop 244
//values:244..247
    ILOAD	x	// push x to stack
    BIPUSH	246	// push byte 246 to stack
    ISUB	       	// push ( -(pop)246 + (pop)x )
    IFLT lt246		// jump if pop less then pop 246
    STORE	123	//returned value
   GOTO enddiv2
lt246:
    STORE	122	//returned value
   GOTO enddiv2
lt244:
//values:240..243
    ILOAD	x	// push x to stack
    BIPUSH	242	// push byte 242 to stack
    ISUB	       	// push ( -(pop)242 + (pop)x )
    IFLT lt242		// jump if pop less then pop 242
    STORE	121	//returned value
   GOTO enddiv2
lt242:
    STORE	120	//returned value
   GOTO enddiv2
lt240:
//values:224..239
    ILOAD	x	// push x to stack
    BIPUSH	232	// push byte 232 to stack
    ISUB	       	// push ( -(pop)232 + (pop)x )
    IFLT lt232		// jump if pop less then pop 232
//values:232..239
    ILOAD	x	// push x to stack
    BIPUSH	236	// push byte 236 to stack
    ISUB	       	// push ( -(pop)236 + (pop)x )
    IFLT lt236		// jump if pop less then pop 236
//values:236..239
    ILOAD	x	// push x to stack
    BIPUSH	238	// push byte 238 to stack
    ISUB	       	// push ( -(pop)238 + (pop)x )
    IFLT lt238		// jump if pop less then pop 238
    STORE	119	//returned value
   GOTO enddiv2
lt238:
    STORE	118	//returned value
   GOTO enddiv2
lt236:
//values:232..235
    ILOAD	x	// push x to stack
    BIPUSH	234	// push byte 234 to stack
    ISUB	       	// push ( -(pop)234 + (pop)x )
    IFLT lt234		// jump if pop less then pop 234
    STORE	117	//returned value
   GOTO enddiv2
lt234:
    STORE	116	//returned value
   GOTO enddiv2
lt232:
//values:224..231
    ILOAD	x	// push x to stack
    BIPUSH	228	// push byte 228 to stack
    ISUB	       	// push ( -(pop)228 + (pop)x )
    IFLT lt228		// jump if pop less then pop 228
//values:228..231
    ILOAD	x	// push x to stack
    BIPUSH	230	// push byte 230 to stack
    ISUB	       	// push ( -(pop)230 + (pop)x )
    IFLT lt230		// jump if pop less then pop 230
    STORE	115	//returned value
   GOTO enddiv2
lt230:
    STORE	114	//returned value
   GOTO enddiv2
lt228:
//values:224..227
    ILOAD	x	// push x to stack
    BIPUSH	226	// push byte 226 to stack
    ISUB	       	// push ( -(pop)226 + (pop)x )
    IFLT lt226		// jump if pop less then pop 226
    STORE	113	//returned value
   GOTO enddiv2
lt226:
    STORE	112	//returned value
   GOTO enddiv2
lt224:
//values:192..223
    ILOAD	x	// push x to stack
    BIPUSH	208	// push byte 208 to stack
    ISUB	       	// push ( -(pop)208 + (pop)x )
    IFLT lt208		// jump if pop less then pop 208
//values:208..223
    ILOAD	x	// push x to stack
    BIPUSH	216	// push byte 216 to stack
    ISUB	       	// push ( -(pop)216 + (pop)x )
    IFLT lt216		// jump if pop less then pop 216
//values:216..223
    ILOAD	x	// push x to stack
    BIPUSH	220	// push byte 220 to stack
    ISUB	       	// push ( -(pop)220 + (pop)x )
    IFLT lt220		// jump if pop less then pop 220
//values:220..223
    ILOAD	x	// push x to stack
    BIPUSH	222	// push byte 222 to stack
    ISUB	       	// push ( -(pop)222 + (pop)x )
    IFLT lt222		// jump if pop less then pop 222
    STORE	111	//returned value
   GOTO enddiv2
lt222:
    STORE	110	//returned value
   GOTO enddiv2
lt220:
//values:216..219
    ILOAD	x	// push x to stack
    BIPUSH	218	// push byte 218 to stack
    ISUB	       	// push ( -(pop)218 + (pop)x )
    IFLT lt218		// jump if pop less then pop 218
    STORE	109	//returned value
   GOTO enddiv2
lt218:
    STORE	108	//returned value
   GOTO enddiv2
lt216:
//values:208..215
    ILOAD	x	// push x to stack
    BIPUSH	212	// push byte 212 to stack
    ISUB	       	// push ( -(pop)212 + (pop)x )
    IFLT lt212		// jump if pop less then pop 212
//values:212..215
    ILOAD	x	// push x to stack
    BIPUSH	214	// push byte 214 to stack
    ISUB	       	// push ( -(pop)214 + (pop)x )
    IFLT lt214		// jump if pop less then pop 214
    STORE	107	//returned value
   GOTO enddiv2
lt214:
    STORE	106	//returned value
   GOTO enddiv2
lt212:
//values:208..211
    ILOAD	x	// push x to stack
    BIPUSH	210	// push byte 210 to stack
    ISUB	       	// push ( -(pop)210 + (pop)x )
    IFLT lt210		// jump if pop less then pop 210
    STORE	105	//returned value
   GOTO enddiv2
lt210:
    STORE	104	//returned value
   GOTO enddiv2
lt208:
//values:192..207
    ILOAD	x	// push x to stack
    BIPUSH	200	// push byte 200 to stack
    ISUB	       	// push ( -(pop)200 + (pop)x )
    IFLT lt200		// jump if pop less then pop 200
//values:200..207
    ILOAD	x	// push x to stack
    BIPUSH	204	// push byte 204 to stack
    ISUB	       	// push ( -(pop)204 + (pop)x )
    IFLT lt204		// jump if pop less then pop 204
//values:204..207
    ILOAD	x	// push x to stack
    BIPUSH	206	// push byte 206 to stack
    ISUB	       	// push ( -(pop)206 + (pop)x )
    IFLT lt206		// jump if pop less then pop 206
    STORE	103	//returned value
   GOTO enddiv2
lt206:
    STORE	102	//returned value
   GOTO enddiv2
lt204:
//values:200..203
    ILOAD	x	// push x to stack
    BIPUSH	202	// push byte 202 to stack
    ISUB	       	// push ( -(pop)202 + (pop)x )
    IFLT lt202		// jump if pop less then pop 202
    STORE	101	//returned value
   GOTO enddiv2
lt202:
    STORE	100	//returned value
   GOTO enddiv2
lt200:
//values:192..199
    ILOAD	x	// push x to stack
    BIPUSH	196	// push byte 196 to stack
    ISUB	       	// push ( -(pop)196 + (pop)x )
    IFLT lt196		// jump if pop less then pop 196
//values:196..199
    ILOAD	x	// push x to stack
    BIPUSH	198	// push byte 198 to stack
    ISUB	       	// push ( -(pop)198 + (pop)x )
    IFLT lt198		// jump if pop less then pop 198
    STORE	99	//returned value
   GOTO enddiv2
lt198:
    STORE	98	//returned value
   GOTO enddiv2
lt196:
//values:192..195
    ILOAD	x	// push x to stack
    BIPUSH	194	// push byte 194 to stack
    ISUB	       	// push ( -(pop)194 + (pop)x )
    IFLT lt194		// jump if pop less then pop 194
    STORE	97	//returned value
   GOTO enddiv2
lt194:
    STORE	96	//returned value
   GOTO enddiv2
lt192:
//values:128..191
    ILOAD	x	// push x to stack
    BIPUSH	160	// push byte 160 to stack
    ISUB	       	// push ( -(pop)160 + (pop)x )
    IFLT lt160		// jump if pop less then pop 160
//values:160..191
    ILOAD	x	// push x to stack
    BIPUSH	176	// push byte 176 to stack
    ISUB	       	// push ( -(pop)176 + (pop)x )
    IFLT lt176		// jump if pop less then pop 176
//values:176..191
    ILOAD	x	// push x to stack
    BIPUSH	184	// push byte 184 to stack
    ISUB	       	// push ( -(pop)184 + (pop)x )
    IFLT lt184		// jump if pop less then pop 184
//values:184..191
    ILOAD	x	// push x to stack
    BIPUSH	188	// push byte 188 to stack
    ISUB	       	// push ( -(pop)188 + (pop)x )
    IFLT lt188		// jump if pop less then pop 188
//values:188..191
    ILOAD	x	// push x to stack
    BIPUSH	190	// push byte 190 to stack
    ISUB	       	// push ( -(pop)190 + (pop)x )
    IFLT lt190		// jump if pop less then pop 190
    STORE	95	//returned value
   GOTO enddiv2
lt190:
    STORE	94	//returned value
   GOTO enddiv2
lt188:
//values:184..187
    ILOAD	x	// push x to stack
    BIPUSH	186	// push byte 186 to stack
    ISUB	       	// push ( -(pop)186 + (pop)x )
    IFLT lt186		// jump if pop less then pop 186
    STORE	93	//returned value
   GOTO enddiv2
lt186:
    STORE	92	//returned value
   GOTO enddiv2
lt184:
//values:176..183
    ILOAD	x	// push x to stack
    BIPUSH	180	// push byte 180 to stack
    ISUB	       	// push ( -(pop)180 + (pop)x )
    IFLT lt180		// jump if pop less then pop 180
//values:180..183
    ILOAD	x	// push x to stack
    BIPUSH	182	// push byte 182 to stack
    ISUB	       	// push ( -(pop)182 + (pop)x )
    IFLT lt182		// jump if pop less then pop 182
    STORE	91	//returned value
   GOTO enddiv2
lt182:
    STORE	90	//returned value
   GOTO enddiv2
lt180:
//values:176..179
    ILOAD	x	// push x to stack
    BIPUSH	178	// push byte 178 to stack
    ISUB	       	// push ( -(pop)178 + (pop)x )
    IFLT lt178		// jump if pop less then pop 178
    STORE	89	//returned value
   GOTO enddiv2
lt178:
    STORE	88	//returned value
   GOTO enddiv2
lt176:
//values:160..175
    ILOAD	x	// push x to stack
    BIPUSH	168	// push byte 168 to stack
    ISUB	       	// push ( -(pop)168 + (pop)x )
    IFLT lt168		// jump if pop less then pop 168
//values:168..175
    ILOAD	x	// push x to stack
    BIPUSH	172	// push byte 172 to stack
    ISUB	       	// push ( -(pop)172 + (pop)x )
    IFLT lt172		// jump if pop less then pop 172
//values:172..175
    ILOAD	x	// push x to stack
    BIPUSH	174	// push byte 174 to stack
    ISUB	       	// push ( -(pop)174 + (pop)x )
    IFLT lt174		// jump if pop less then pop 174
    STORE	87	//returned value
   GOTO enddiv2
lt174:
    STORE	86	//returned value
   GOTO enddiv2
lt172:
//values:168..171
    ILOAD	x	// push x to stack
    BIPUSH	170	// push byte 170 to stack
    ISUB	       	// push ( -(pop)170 + (pop)x )
    IFLT lt170		// jump if pop less then pop 170
    STORE	85	//returned value
   GOTO enddiv2
lt170:
    STORE	84	//returned value
   GOTO enddiv2
lt168:
//values:160..167
    ILOAD	x	// push x to stack
    BIPUSH	164	// push byte 164 to stack
    ISUB	       	// push ( -(pop)164 + (pop)x )
    IFLT lt164		// jump if pop less then pop 164
//values:164..167
    ILOAD	x	// push x to stack
    BIPUSH	166	// push byte 166 to stack
    ISUB	       	// push ( -(pop)166 + (pop)x )
    IFLT lt166		// jump if pop less then pop 166
    STORE	83	//returned value
   GOTO enddiv2
lt166:
    STORE	82	//returned value
   GOTO enddiv2
lt164:
//values:160..163
    ILOAD	x	// push x to stack
    BIPUSH	162	// push byte 162 to stack
    ISUB	       	// push ( -(pop)162 + (pop)x )
    IFLT lt162		// jump if pop less then pop 162
    STORE	81	//returned value
   GOTO enddiv2
lt162:
    STORE	80	//returned value
   GOTO enddiv2
lt160:
//values:128..159
    ILOAD	x	// push x to stack
    BIPUSH	144	// push byte 144 to stack
    ISUB	       	// push ( -(pop)144 + (pop)x )
    IFLT lt144		// jump if pop less then pop 144
//values:144..159
    ILOAD	x	// push x to stack
    BIPUSH	152	// push byte 152 to stack
    ISUB	       	// push ( -(pop)152 + (pop)x )
    IFLT lt152		// jump if pop less then pop 152
//values:152..159
    ILOAD	x	// push x to stack
    BIPUSH	156	// push byte 156 to stack
    ISUB	       	// push ( -(pop)156 + (pop)x )
    IFLT lt156		// jump if pop less then pop 156
//values:156..159
    ILOAD	x	// push x to stack
    BIPUSH	158	// push byte 158 to stack
    ISUB	       	// push ( -(pop)158 + (pop)x )
    IFLT lt158		// jump if pop less then pop 158
    STORE	79	//returned value
   GOTO enddiv2
lt158:
    STORE	78	//returned value
   GOTO enddiv2
lt156:
//values:152..155
    ILOAD	x	// push x to stack
    BIPUSH	154	// push byte 154 to stack
    ISUB	       	// push ( -(pop)154 + (pop)x )
    IFLT lt154		// jump if pop less then pop 154
    STORE	77	//returned value
   GOTO enddiv2
lt154:
    STORE	76	//returned value
   GOTO enddiv2
lt152:
//values:144..151
    ILOAD	x	// push x to stack
    BIPUSH	148	// push byte 148 to stack
    ISUB	       	// push ( -(pop)148 + (pop)x )
    IFLT lt148		// jump if pop less then pop 148
//values:148..151
    ILOAD	x	// push x to stack
    BIPUSH	150	// push byte 150 to stack
    ISUB	       	// push ( -(pop)150 + (pop)x )
    IFLT lt150		// jump if pop less then pop 150
    STORE	75	//returned value
   GOTO enddiv2
lt150:
    STORE	74	//returned value
   GOTO enddiv2
lt148:
//values:144..147
    ILOAD	x	// push x to stack
    BIPUSH	146	// push byte 146 to stack
    ISUB	       	// push ( -(pop)146 + (pop)x )
    IFLT lt146		// jump if pop less then pop 146
    STORE	73	//returned value
   GOTO enddiv2
lt146:
    STORE	72	//returned value
   GOTO enddiv2
lt144:
//values:128..143
    ILOAD	x	// push x to stack
    BIPUSH	136	// push byte 136 to stack
    ISUB	       	// push ( -(pop)136 + (pop)x )
    IFLT lt136		// jump if pop less then pop 136
//values:136..143
    ILOAD	x	// push x to stack
    BIPUSH	140	// push byte 140 to stack
    ISUB	       	// push ( -(pop)140 + (pop)x )
    IFLT lt140		// jump if pop less then pop 140
//values:140..143
    ILOAD	x	// push x to stack
    BIPUSH	142	// push byte 142 to stack
    ISUB	       	// push ( -(pop)142 + (pop)x )
    IFLT lt142		// jump if pop less then pop 142
    STORE	71	//returned value
   GOTO enddiv2
lt142:
    STORE	70	//returned value
   GOTO enddiv2
lt140:
//values:136..139
    ILOAD	x	// push x to stack
    BIPUSH	138	// push byte 138 to stack
    ISUB	       	// push ( -(pop)138 + (pop)x )
    IFLT lt138		// jump if pop less then pop 138
    STORE	69	//returned value
   GOTO enddiv2
lt138:
    STORE	68	//returned value
   GOTO enddiv2
lt136:
//values:128..135
    ILOAD	x	// push x to stack
    BIPUSH	132	// push byte 132 to stack
    ISUB	       	// push ( -(pop)132 + (pop)x )
    IFLT lt132		// jump if pop less then pop 132
//values:132..135
    ILOAD	x	// push x to stack
    BIPUSH	134	// push byte 134 to stack
    ISUB	       	// push ( -(pop)134 + (pop)x )
    IFLT lt134		// jump if pop less then pop 134
    STORE	67	//returned value
   GOTO enddiv2
lt134:
    STORE	66	//returned value
   GOTO enddiv2
lt132:
//values:128..131
    ILOAD	x	// push x to stack
    BIPUSH	130	// push byte 130 to stack
    ISUB	       	// push ( -(pop)130 + (pop)x )
    IFLT lt130		// jump if pop less then pop 130
    STORE	65	//returned value
   GOTO enddiv2
lt130:
    STORE	64	//returned value
   GOTO enddiv2
lt128:
//values:0..127
    ILOAD	x	// push x to stack
    BIPUSH	64	// push byte 64 to stack
    ISUB	       	// push ( -(pop)64 + (pop)x )
    IFLT lt64		// jump if pop less then pop 64
//values:64..127
    ILOAD	x	// push x to stack
    BIPUSH	96	// push byte 96 to stack
    ISUB	       	// push ( -(pop)96 + (pop)x )
    IFLT lt96		// jump if pop less then pop 96
//values:96..127
    ILOAD	x	// push x to stack
    BIPUSH	112	// push byte 112 to stack
    ISUB	       	// push ( -(pop)112 + (pop)x )
    IFLT lt112		// jump if pop less then pop 112
//values:112..127
    ILOAD	x	// push x to stack
    BIPUSH	120	// push byte 120 to stack
    ISUB	       	// push ( -(pop)120 + (pop)x )
    IFLT lt120		// jump if pop less then pop 120
//values:120..127
    ILOAD	x	// push x to stack
    BIPUSH	124	// push byte 124 to stack
    ISUB	       	// push ( -(pop)124 + (pop)x )
    IFLT lt124		// jump if pop less then pop 124
//values:124..127
    ILOAD	x	// push x to stack
    BIPUSH	126	// push byte 126 to stack
    ISUB	       	// push ( -(pop)126 + (pop)x )
    IFLT lt126		// jump if pop less then pop 126
    STORE	63	//returned value
   GOTO enddiv2
lt126:
    STORE	62	//returned value
   GOTO enddiv2
lt124:
//values:120..123
    ILOAD	x	// push x to stack
    BIPUSH	122	// push byte 122 to stack
    ISUB	       	// push ( -(pop)122 + (pop)x )
    IFLT lt122		// jump if pop less then pop 122
    STORE	61	//returned value
   GOTO enddiv2
lt122:
    STORE	60	//returned value
   GOTO enddiv2
lt120:
//values:112..119
    ILOAD	x	// push x to stack
    BIPUSH	116	// push byte 116 to stack
    ISUB	       	// push ( -(pop)116 + (pop)x )
    IFLT lt116		// jump if pop less then pop 116
//values:116..119
    ILOAD	x	// push x to stack
    BIPUSH	118	// push byte 118 to stack
    ISUB	       	// push ( -(pop)118 + (pop)x )
    IFLT lt118		// jump if pop less then pop 118
    STORE	59	//returned value
   GOTO enddiv2
lt118:
    STORE	58	//returned value
   GOTO enddiv2
lt116:
//values:112..115
    ILOAD	x	// push x to stack
    BIPUSH	114	// push byte 114 to stack
    ISUB	       	// push ( -(pop)114 + (pop)x )
    IFLT lt114		// jump if pop less then pop 114
    STORE	57	//returned value
   GOTO enddiv2
lt114:
    STORE	56	//returned value
   GOTO enddiv2
lt112:
//values:96..111
    ILOAD	x	// push x to stack
    BIPUSH	104	// push byte 104 to stack
    ISUB	       	// push ( -(pop)104 + (pop)x )
    IFLT lt104		// jump if pop less then pop 104
//values:104..111
    ILOAD	x	// push x to stack
    BIPUSH	108	// push byte 108 to stack
    ISUB	       	// push ( -(pop)108 + (pop)x )
    IFLT lt108		// jump if pop less then pop 108
//values:108..111
    ILOAD	x	// push x to stack
    BIPUSH	110	// push byte 110 to stack
    ISUB	       	// push ( -(pop)110 + (pop)x )
    IFLT lt110		// jump if pop less then pop 110
    STORE	55	//returned value
   GOTO enddiv2
lt110:
    STORE	54	//returned value
   GOTO enddiv2
lt108:
//values:104..107
    ILOAD	x	// push x to stack
    BIPUSH	106	// push byte 106 to stack
    ISUB	       	// push ( -(pop)106 + (pop)x )
    IFLT lt106		// jump if pop less then pop 106
    STORE	53	//returned value
   GOTO enddiv2
lt106:
    STORE	52	//returned value
   GOTO enddiv2
lt104:
//values:96..103
    ILOAD	x	// push x to stack
    BIPUSH	100	// push byte 100 to stack
    ISUB	       	// push ( -(pop)100 + (pop)x )
    IFLT lt100		// jump if pop less then pop 100
//values:100..103
    ILOAD	x	// push x to stack
    BIPUSH	102	// push byte 102 to stack
    ISUB	       	// push ( -(pop)102 + (pop)x )
    IFLT lt102		// jump if pop less then pop 102
    STORE	51	//returned value
   GOTO enddiv2
lt102:
    STORE	50	//returned value
   GOTO enddiv2
lt100:
//values:96..99
    ILOAD	x	// push x to stack
    BIPUSH	98	// push byte 98 to stack
    ISUB	       	// push ( -(pop)98 + (pop)x )
    IFLT lt98		// jump if pop less then pop 98
    STORE	49	//returned value
   GOTO enddiv2
lt98:
    STORE	48	//returned value
   GOTO enddiv2
lt96:
//values:64..95
    ILOAD	x	// push x to stack
    BIPUSH	80	// push byte 80 to stack
    ISUB	       	// push ( -(pop)80 + (pop)x )
    IFLT lt80		// jump if pop less then pop 80
//values:80..95
    ILOAD	x	// push x to stack
    BIPUSH	88	// push byte 88 to stack
    ISUB	       	// push ( -(pop)88 + (pop)x )
    IFLT lt88		// jump if pop less then pop 88
//values:88..95
    ILOAD	x	// push x to stack
    BIPUSH	92	// push byte 92 to stack
    ISUB	       	// push ( -(pop)92 + (pop)x )
    IFLT lt92		// jump if pop less then pop 92
//values:92..95
    ILOAD	x	// push x to stack
    BIPUSH	94	// push byte 94 to stack
    ISUB	       	// push ( -(pop)94 + (pop)x )
    IFLT lt94		// jump if pop less then pop 94
    STORE	47	//returned value
   GOTO enddiv2
lt94:
    STORE	46	//returned value
   GOTO enddiv2
lt92:
//values:88..91
    ILOAD	x	// push x to stack
    BIPUSH	90	// push byte 90 to stack
    ISUB	       	// push ( -(pop)90 + (pop)x )
    IFLT lt90		// jump if pop less then pop 90
    STORE	45	//returned value
   GOTO enddiv2
lt90:
    STORE	44	//returned value
   GOTO enddiv2
lt88:
//values:80..87
    ILOAD	x	// push x to stack
    BIPUSH	84	// push byte 84 to stack
    ISUB	       	// push ( -(pop)84 + (pop)x )
    IFLT lt84		// jump if pop less then pop 84
//values:84..87
    ILOAD	x	// push x to stack
    BIPUSH	86	// push byte 86 to stack
    ISUB	       	// push ( -(pop)86 + (pop)x )
    IFLT lt86		// jump if pop less then pop 86
    STORE	43	//returned value
   GOTO enddiv2
lt86:
    STORE	42	//returned value
   GOTO enddiv2
lt84:
//values:80..83
    ILOAD	x	// push x to stack
    BIPUSH	82	// push byte 82 to stack
    ISUB	       	// push ( -(pop)82 + (pop)x )
    IFLT lt82		// jump if pop less then pop 82
    STORE	41	//returned value
   GOTO enddiv2
lt82:
    STORE	40	//returned value
   GOTO enddiv2
lt80:
//values:64..79
    ILOAD	x	// push x to stack
    BIPUSH	72	// push byte 72 to stack
    ISUB	       	// push ( -(pop)72 + (pop)x )
    IFLT lt72		// jump if pop less then pop 72
//values:72..79
    ILOAD	x	// push x to stack
    BIPUSH	76	// push byte 76 to stack
    ISUB	       	// push ( -(pop)76 + (pop)x )
    IFLT lt76		// jump if pop less then pop 76
//values:76..79
    ILOAD	x	// push x to stack
    BIPUSH	78	// push byte 78 to stack
    ISUB	       	// push ( -(pop)78 + (pop)x )
    IFLT lt78		// jump if pop less then pop 78
    STORE	39	//returned value
   GOTO enddiv2
lt78:
    STORE	38	//returned value
   GOTO enddiv2
lt76:
//values:72..75
    ILOAD	x	// push x to stack
    BIPUSH	74	// push byte 74 to stack
    ISUB	       	// push ( -(pop)74 + (pop)x )
    IFLT lt74		// jump if pop less then pop 74
    STORE	37	//returned value
   GOTO enddiv2
lt74:
    STORE	36	//returned value
   GOTO enddiv2
lt72:
//values:64..71
    ILOAD	x	// push x to stack
    BIPUSH	68	// push byte 68 to stack
    ISUB	       	// push ( -(pop)68 + (pop)x )
    IFLT lt68		// jump if pop less then pop 68
//values:68..71
    ILOAD	x	// push x to stack
    BIPUSH	70	// push byte 70 to stack
    ISUB	       	// push ( -(pop)70 + (pop)x )
    IFLT lt70		// jump if pop less then pop 70
    STORE	35	//returned value
   GOTO enddiv2
lt70:
    STORE	34	//returned value
   GOTO enddiv2
lt68:
//values:64..67
    ILOAD	x	// push x to stack
    BIPUSH	66	// push byte 66 to stack
    ISUB	       	// push ( -(pop)66 + (pop)x )
    IFLT lt66		// jump if pop less then pop 66
    STORE	33	//returned value
   GOTO enddiv2
lt66:
    STORE	32	//returned value
   GOTO enddiv2
lt64:
//values:0..63
    ILOAD	x	// push x to stack
    BIPUSH	32	// push byte 32 to stack
    ISUB	       	// push ( -(pop)32 + (pop)x )
    IFLT lt32		// jump if pop less then pop 32
//values:32..63
    ILOAD	x	// push x to stack
    BIPUSH	48	// push byte 48 to stack
    ISUB	       	// push ( -(pop)48 + (pop)x )
    IFLT lt48		// jump if pop less then pop 48
//values:48..63
    ILOAD	x	// push x to stack
    BIPUSH	56	// push byte 56 to stack
    ISUB	       	// push ( -(pop)56 + (pop)x )
    IFLT lt56		// jump if pop less then pop 56
//values:56..63
    ILOAD	x	// push x to stack
    BIPUSH	60	// push byte 60 to stack
    ISUB	       	// push ( -(pop)60 + (pop)x )
    IFLT lt60		// jump if pop less then pop 60
//values:60..63
    ILOAD	x	// push x to stack
    BIPUSH	62	// push byte 62 to stack
    ISUB	       	// push ( -(pop)62 + (pop)x )
    IFLT lt62		// jump if pop less then pop 62
    STORE	31	//returned value
   GOTO enddiv2
lt62:
    STORE	30	//returned value
   GOTO enddiv2
lt60:
//values:56..59
    ILOAD	x	// push x to stack
    BIPUSH	58	// push byte 58 to stack
    ISUB	       	// push ( -(pop)58 + (pop)x )
    IFLT lt58		// jump if pop less then pop 58
    STORE	29	//returned value
   GOTO enddiv2
lt58:
    STORE	28	//returned value
   GOTO enddiv2
lt56:
//values:48..55
    ILOAD	x	// push x to stack
    BIPUSH	52	// push byte 52 to stack
    ISUB	       	// push ( -(pop)52 + (pop)x )
    IFLT lt52		// jump if pop less then pop 52
//values:52..55
    ILOAD	x	// push x to stack
    BIPUSH	54	// push byte 54 to stack
    ISUB	       	// push ( -(pop)54 + (pop)x )
    IFLT lt54		// jump if pop less then pop 54
    STORE	27	//returned value
   GOTO enddiv2
lt54:
    STORE	26	//returned value
   GOTO enddiv2
lt52:
//values:48..51
    ILOAD	x	// push x to stack
    BIPUSH	50	// push byte 50 to stack
    ISUB	       	// push ( -(pop)50 + (pop)x )
    IFLT lt50		// jump if pop less then pop 50
    STORE	25	//returned value
   GOTO enddiv2
lt50:
    STORE	24	//returned value
   GOTO enddiv2
lt48:
//values:32..47
    ILOAD	x	// push x to stack
    BIPUSH	40	// push byte 40 to stack
    ISUB	       	// push ( -(pop)40 + (pop)x )
    IFLT lt40		// jump if pop less then pop 40
//values:40..47
    ILOAD	x	// push x to stack
    BIPUSH	44	// push byte 44 to stack
    ISUB	       	// push ( -(pop)44 + (pop)x )
    IFLT lt44		// jump if pop less then pop 44
//values:44..47
    ILOAD	x	// push x to stack
    BIPUSH	46	// push byte 46 to stack
    ISUB	       	// push ( -(pop)46 + (pop)x )
    IFLT lt46		// jump if pop less then pop 46
    STORE	23	//returned value
   GOTO enddiv2
lt46:
    STORE	22	//returned value
   GOTO enddiv2
lt44:
//values:40..43
    ILOAD	x	// push x to stack
    BIPUSH	42	// push byte 42 to stack
    ISUB	       	// push ( -(pop)42 + (pop)x )
    IFLT lt42		// jump if pop less then pop 42
    STORE	21	//returned value
   GOTO enddiv2
lt42:
    STORE	20	//returned value
   GOTO enddiv2
lt40:
//values:32..39
    ILOAD	x	// push x to stack
    BIPUSH	36	// push byte 36 to stack
    ISUB	       	// push ( -(pop)36 + (pop)x )
    IFLT lt36		// jump if pop less then pop 36
//values:36..39
    ILOAD	x	// push x to stack
    BIPUSH	38	// push byte 38 to stack
    ISUB	       	// push ( -(pop)38 + (pop)x )
    IFLT lt38		// jump if pop less then pop 38
    STORE	19	//returned value
   GOTO enddiv2
lt38:
    STORE	18	//returned value
   GOTO enddiv2
lt36:
//values:32..35
    ILOAD	x	// push x to stack
    BIPUSH	34	// push byte 34 to stack
    ISUB	       	// push ( -(pop)34 + (pop)x )
    IFLT lt34		// jump if pop less then pop 34
    STORE	17	//returned value
   GOTO enddiv2
lt34:
    STORE	16	//returned value
   GOTO enddiv2
lt32:
//values:0..31
    ILOAD	x	// push x to stack
    BIPUSH	16	// push byte 16 to stack
    ISUB	       	// push ( -(pop)16 + (pop)x )
    IFLT lt16		// jump if pop less then pop 16
//values:16..31
    ILOAD	x	// push x to stack
    BIPUSH	24	// push byte 24 to stack
    ISUB	       	// push ( -(pop)24 + (pop)x )
    IFLT lt24		// jump if pop less then pop 24
//values:24..31
    ILOAD	x	// push x to stack
    BIPUSH	28	// push byte 28 to stack
    ISUB	       	// push ( -(pop)28 + (pop)x )
    IFLT lt28		// jump if pop less then pop 28
//values:28..31
    ILOAD	x	// push x to stack
    BIPUSH	30	// push byte 30 to stack
    ISUB	       	// push ( -(pop)30 + (pop)x )
    IFLT lt30		// jump if pop less then pop 30
    STORE	15	//returned value
   GOTO enddiv2
lt30:
    STORE	14	//returned value
   GOTO enddiv2
lt28:
//values:24..27
    ILOAD	x	// push x to stack
    BIPUSH	26	// push byte 26 to stack
    ISUB	       	// push ( -(pop)26 + (pop)x )
    IFLT lt26		// jump if pop less then pop 26
    STORE	13	//returned value
   GOTO enddiv2
lt26:
    STORE	12	//returned value
   GOTO enddiv2
lt24:
//values:16..23
    ILOAD	x	// push x to stack
    BIPUSH	20	// push byte 20 to stack
    ISUB	       	// push ( -(pop)20 + (pop)x )
    IFLT lt20		// jump if pop less then pop 20
//values:20..23
    ILOAD	x	// push x to stack
    BIPUSH	22	// push byte 22 to stack
    ISUB	       	// push ( -(pop)22 + (pop)x )
    IFLT lt22		// jump if pop less then pop 22
    STORE	11	//returned value
   GOTO enddiv2
lt22:
    STORE	10	//returned value
   GOTO enddiv2
lt20:
//values:16..19
    ILOAD	x	// push x to stack
    BIPUSH	18	// push byte 18 to stack
    ISUB	       	// push ( -(pop)18 + (pop)x )
    IFLT lt18		// jump if pop less then pop 18
    STORE	9	//returned value
   GOTO enddiv2
lt18:
    STORE	8	//returned value
   GOTO enddiv2
lt16:
//values:0..15
    ILOAD	x	// push x to stack
    BIPUSH	8	// push byte 8 to stack
    ISUB	       	// push ( -(pop)8 + (pop)x )
    IFLT lt8		// jump if pop less then pop 8
//values:8..15
    ILOAD	x	// push x to stack
    BIPUSH	12	// push byte 12 to stack
    ISUB	       	// push ( -(pop)12 + (pop)x )
    IFLT lt12		// jump if pop less then pop 12
//values:12..15
    ILOAD	x	// push x to stack
    BIPUSH	14	// push byte 14 to stack
    ISUB	       	// push ( -(pop)14 + (pop)x )
    IFLT lt14		// jump if pop less then pop 14
    STORE	7	//returned value
   GOTO enddiv2
lt14:
    STORE	6	//returned value
   GOTO enddiv2
lt12:
//values:8..11
    ILOAD	x	// push x to stack
    BIPUSH	10	// push byte 10 to stack
    ISUB	       	// push ( -(pop)10 + (pop)x )
    IFLT lt10		// jump if pop less then pop 10
    STORE	5	//returned value
   GOTO enddiv2
lt10:
    STORE	4	//returned value
   GOTO enddiv2
lt8:
//values:0..7
    ILOAD	x	// push x to stack
    BIPUSH	4	// push byte 4 to stack
    ISUB	       	// push ( -(pop)4 + (pop)x )
    IFLT lt4		// jump if pop less then pop 4
//values:4..7
    ILOAD	x	// push x to stack
    BIPUSH	6	// push byte 6 to stack
    ISUB	       	// push ( -(pop)6 + (pop)x )
    IFLT lt6		// jump if pop less then pop 6
    STORE	3	//returned value
   GOTO enddiv2
lt6:
    STORE	2	//returned value
   GOTO enddiv2
lt4:
//values:0..3
    ILOAD	x	// push x to stack
    BIPUSH	2	// push byte 2 to stack
    ISUB	       	// push ( -(pop)2 + (pop)x )
    IFLT lt2		// jump if pop less then pop 2
    STORE	1	//returned value
   GOTO enddiv2
lt2:
    STORE	0	//returned value
enddiv2:
..end-method
// oppure se tra gli opcode indefiniti fosse consentita
// l'indicizzazione di memoria, potrebbero usarsi l'inizializzazione
// della mappatura della funzione
...constant
res00div2 0
res01div2 0
res02div2 1
res03div2 1
res04div2 2
res05div2 2
res06div2 3
res07div2 3
.....
resFDdiv2 126
resFEdiv2 126
resFFdiv2 127
//generabili dinamicamente con qualcosa tipo
// perl -e 'for($i=0;$i<2**8;$i++){printf"res%02Xdiv2 %d\n",$i,$i/2}'
...end-constant


 writes:
[megacut]
Caro ingegnoso autore ed ideatore, se evitassi di dispensarci con 1000
ed oltre linee di post e codice, i nostri modem nonche' i dischi fissi
sarebbero molto piu' felici, ed ancora prima di loro noi.
[Per moderatore]
Non si possono rigettare questi tipi di post?
-- 
Linux Registered User #181013
[Exokernels] Although one approach to eliminating bloated, buggy,
unreliable operating systems is to make them smaller, a more radical
one is to eliminate the operating system altogether.

 writes:
Sephiroth> Caro ingegnoso autore ed ideatore,
Sephiroth> se evitassi di dispensarci con 1000 ed oltre linee di post
Sephiroth> e codice, i nostri modem nonche' i dischi fissi sarebbero
Sephiroth> molto piu' felici, ed ancora prima di loro noi.
Non cogli l'approccio ottimale con condizioni esperte di codice autogenerato
tale da eseguire solo circa 25 passi di istruzione delle 764 presenti
per giungere al risultato qualunque sia l'input.
Anziche` la media di 64*20 passi d'esecuzione come e` soluzione piu`
comune e che qualcuno chiama elegante, come se eleganza fosse questa.
(a dirla tutta dovrei anche sostituire le istruzioni per disporre il risultato
tipo "ISTORE 0" con "BIPUSH 0", non era il codice il cuore del post,
ma il metodo a condizioni esperte inserite nel codice, il codice stava
infatti solo ad esempio concreto del metodo),
Tu evidentemente non hai neanche compreso quell'idea perche` non hai mai
visto un approccio del genere (essendo una nuova idea),
e ti permetti di parlare perfino di spazio sugli hard disk a nome di altri.
Sappi che ti stai rivolgendo a chi ha rispetto di ogni singolo bit
piu` di quanto tu hai di te stesso.
Aprofitto dell'intervento di questo imb.. per dare il riferimento
http://www.andruschs.de/dots/tips_tricks/rfc/RFC1036_news_wichtig_neu.txt
Usenet prevede una specifica di rimozione/sostituzione dei propri post,
io la ho applicata, e ci tengo che si sappia in particolare mi riferisco
al field "Supersedes:" avendo cura di mantenere la Cancel-lock
assegnata dal server all'atto della pubblicazione, ma purtroppo non tutti
i nodi usenet rispettano tale specifica, in particolare ho incontrato
una nuova difficolta` perche` questo newsgroup e` moderato (c'e` un
ulteriore passaggio di approvazione). L'avro` detto troppo
sinteticamente per essere capito da tutti?
Sephiroth> [Per moderatore]
Sephiroth> Non si possono rigettare questi tipi di post?
Non sei capace di risponderti da solo, certo che si possono rigettare.
Saluti e comunque scusate,


, max wrote:
       > > Per lo shift a sinistra, la moltiplicazione, non c'e'
       > > problema... lo sommo a se' stesso ed in pratica e' come se
       > > lo moltiplicassi per 2.  ma per la divisione per 2 come si
       > > fa?  Non posso sottrarlo da se stesso...
Saidone> Ci provo anch'io... :-)
Saidone> Due numeri, maschera parte da 2 (2^1), addendo parte da 1.
Saidone> Controllo a ogni ciclo lo stato dei bit dell'ingresso a
Saidone> partire dal secondo da destra e in caso questo sia 1, sommo
Saidone> addendo al risultato. Alla fine di ogni ciclo raddoppio sia
Saidone> la maschera che l'addendo.
Saidone> Premesso che il numero da processare sia gia' sullo stack.
Saidone> 	ISTORE	ingresso	//lo memorizzo in una temporanea
Saidone> 	BIPUSH	2
Saidone> 	ISTORE	maschera
Saidone> 	BIPUSH	0
Saidone> 	ISTORE	risultato
Saidone> 	BUPUSH	1
Saidone> 	ISTORE	addendo
Saidone> 
Saidone> ciclo:	ILOAD	ingresso
Saidone> 	ILOAD	maschera
Saidone> 	IAND		
Saidone> 	ILOAD	maschera
Saidone> 	IF_ICMPEQ som		//se c'era un 1 in quella posizione,
Saidone> 				//somma la sua meta' al risultato
Saidone> 	GOTO	nonsom
Saidone> som:	ILOAD	risultato
Saidone> 	ILOAD	addendo
Saidone> 	IADD
Saidone> 	ISTORE	risultato
Saidone> nosom:	ILOAD	addendo
Saidone> 	DUP
Saidone> 	IADD
Saidone> 	DUP
Saidone> 	BIPUSH 	128
Saidone> 	IF_ICMPEQ fine
Saidone> 	ISTORE	addendo
Saidone> 	ILOAD	maschera
Saidone> 	DUP
Saidone> 	IADD
Saidone> 	ISTORE	maschera
Saidone> 	GOTO	ciclo
Saidone> fine:	ILOAD	risultato
Saidone> A questo punto dovresti trovare sullo stack il risultato.
Saidone> Tieni conto che ho visto per la prima volta questo linguaggio
Saidone> 5 minuti fa, magari fai qualche verifica :-) Inoltre non ho
Saidone> voluto rompermi la testa con la pila, e forse ho usato troppo
Saidone> le variabili temporanee, il che rende il codice non troppo
Saidone> elegante...
Saidone> Ciao, Marco
Se non sbaglio questo procedimento ha una media di 7+7*20+8=155
passi di esecuzione di istruzioni, e non e` male. Dubito che con
questo algoritmo potessi fare di meglio.
il mio approccio puo` giungere al risultato in 25 passi fissi
per qualunque input. Non si era forse capito?
L'operazione shift e` basilare, mi chiedo veramente perche` questa IJVM sia
cosi` direi eccessivamente limitata pur avendo spazio di ridondanza
per semplici istruzioni dedicate e almeno non specificate.
Centra tutto questo forse qualcosa con la lentezza di Java?
Qualcuno mi disse che l'inventore di Java era passato dalla Sun
alla Microsoft, adesso comincio a capire perche`...
Saluti,


Non sei capace di risponderti da solo, certo che si possono rigettare.
Come vedi non hai inteso il senso della frase, che non e' la domanda
superficiale a cui hai risposto.
Un vivo invito a rispolverare le netiquette.
-- 
       Sephiroth


 visto un approccio del genere (essendo una nuova idea),
Saidone> Una nuova idea? La ricerca binaria???
Non ho detto questo.
Mi riferivo come nel post iniziale alla sua ottimizzazione (non sommaria),
da intendere come estremo inferiore del numero di cicli di clock necessari
a far giungere la VM al risultato di divisione per 2.
Risultato -questo e` il nuovo- ottenuto secondo un modello di
flusso logico che -come dicevo- mi ha premesso di individuare della
ridondanza dall'esito rimprecisato e di dare il codice di elaborazione
ottimale che inevitabilmente ha un legame con l'algoritmo di ricerca
binaria (dicevo anche questo).
Visto comunque questo tuo intervento riprendero` una risposta
ad altri tuoi post piu` pertinenti al riguardo.
Saidone> Ciao, Marco
Saluti,



Il tuo e` un approccio didattico/accademico classico, anche ben fatto,
ma frutto di una pensata approssimativa focalizzata su una buona soluzione.
aidone> il mio metodo pero' ha una occupazione in memoria inferiore di
aidone> almeno un fattore 10 (a spanne, non mi va di mettermi a
aidone> contare le istruzioni).
forse anche piu` di 10, le istruzioni erano circa 748 (naturalmente le avevo
fatte contare al generatore automatico).
aidone> Dipende dal contesto in cui andra' in esecuzione.
questo e` certo, ma contando che il compilato java viene compresso
con inflate (di ZIP), e che quando andra` in memoria e l'occupazione
(comunque inferiore ai 2k), mi sembra sia un qualtitativo piu`
trascurabile che l'approssimazione grossolana sulla complessita`
dell'algoritmo.
       > L'operazione shift e` basilare, mi chiedo
       > veramente perche`
       > questa IJVM sia cosi` direi eccessivamente limitata pur
       > avendo spazio di ridondanza per semplici istruzioni dedicate
       > e almeno non specificate.
aidone> Penso siano una VM e un compilatore nati per scopi didattici,
Anche io lo "penso" (nel senso di "lo ipotizz(av)o" con probabilita` non 1),
infatti ai miei tempi si usava PDP-11 o la macchina di Turing,
ma in altre parole non sono convinto che sia limitato alla didattica.
aidone> magari vengono usati in qualche corso di compilatori.
Io direi che chi ci ha proposto il problema dello shift come minimo
ci debba :-) una risposta il piu` etimologicamente valida possibile
in proposito
Se e` questo il caso, io penso che apparenti(*) semplificazioni che
contengono deviazioni di obiettivi, non siano il miglior chiarimento
esplicativo.
(*) ho scritto "apparenti" perche` la semplicita` a e` *soggettiva*
e da parte mia non c'e` realta` piu` semplice di quella ottimale.
aidone> Ciao, Marco
Saluti,
MARco
-- 
 
http://mar.i.am/~u16500.5567/it.scienza.informatica,it


 vengono usati in qualche corso di compilatori.
Per quanto ne so io la IJVM è stata progettata per sistemi embedded, ma in 
realtà viene usata principalmente per scopi didattici (infatti viene 
adottata dal Tanenbaum in "Architettura dei computer" per implementare le 
architetture sperimentali Mic).
-- 
"Advertising is welcomed on some lists and Newsgroups, and
abhorred on others!" (Netiquette Guidelines, RFC 1855)
TheLegs__tahome.cjb.net
 [] eirhnh soy neyrw