24. April 2024, 00:38
Beiträge anzeigen
Diese Sektion erlaubt es dir alle Beiträge dieses Mitglieds zu sehen. Beachte, dass du nur solche Beiträge sehen kannst, zu denen du auch Zugriffsrechte hast.
Stimmt, ich dachte an den Mittelwert. War halt spät.ganz falsch ist dein Ansatz ja nicht mit wiederholter Ermittelung des Mittelwerts lässt sich auch Interpolieren man fängt dann beim höchsten Bit an und arbeitet sich nach unten durch ist ein Bit gesetzt nimmt man:
Die relevante Frage ist, ob das die Anforderungen an Genauigkeit und Geschwindigkeit erfüllt, und das müsste man austesten.
Übersicht
Wiki
Hilfe
Suche
Einloggen
Registrieren
a'=Mittewert(a+b)
b'=bwenn es nicht gesetzt ist nimmt mana'=a
b'=Mittewert(a+b)Am ende enthält a das Ergebnis, das das selbe wäre wie bei:((a<<8)+t*(b-a))>>8Wenn t 8 Bit groß ist und obige Methode somit 8 mal durchgeführt würde.
(1-t)*a+t*bbzw.a+t*(b-a)Wo siehst du da eine division ich sehe nur eine Multiplikationen?((a<<8)+t*(b-a))>>8
;Zu berechnendes X
MOV R0,#4096
;bit= #0x40000000
MOV R1,#0 ;res
ADD R2,R1,#0x40000000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x40000000
ADD R2,R1,#0x10000000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x10000000
ADD R2,R1,#0x4000000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x4000000
ADD R2,R1,#0x1000000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x1000000
ADD R2,R1,#0x400000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x400000
ADD R2,R1,#0x100000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x100000
ADD R2,R1,#0x40000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x40000
ADD R2,R1,#0x10000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x10000
ADD R2,R1,#0x4000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x4000
ADD R2,R1,#0x1000
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x1000
ADD R2,R1,#0x400
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x400
ADD R2,R1,#0x100
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x100
ADD R2,R1,#0x40
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x40
ADD R2,R1,#0x10
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x10
ADD R2,R1,#0x4
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x4
ADD R2,R1,#0x1
SUBS R2,R0,R2
MOV R1,R1,LSR #1
MOVpl R0,R2
ADDpl R1,R1,#0x1
Danke für deine tolle Ergänzung wegen der WebsiteDas war eigentlich der Parser mit einen Stück Beispiel Kode. Der Kode ist folgender:, ich hätte es mal trotzdem hinschreiben sollen
Deine Sprache sieht echt hammer aus! Ich würde sowas nicht hinbekommen, der Parser würde mich umhauenOb es die irgendwo zum Download gibt?
public super "Test" "java/lang/Object" []
public "<init>" [] void [
aload_0
invokespecial "java/lang/Object" "<init>" [] void
return
]
public static "main" ["java/lang/String" 1] void [
getstatic "java/lang/System" "out" "java/io/PrintStream"
ldc_w string "Hallo, Welt!"
invokevirtual "java/io/PrintStream" "println" ["java/lang/String"] void
return
]
Und das ist eigentlich quasi normaler JAVA-VM KodeDas ist aber lieb. Magst du uns auch verraten, wohin und wo?Guckst du Profil!
Rebol []
toByte: func [value] [back tail to-binary value]
toInt: func [value] [skip tail to-binary value -4]
toShort: func [value] [skip tail to-binary value -2]
toUTF8: func [value /local x] [x: to-binary value join toShort length? x x]
constant_pool: []
access_flags: #{0000}
interfaces: []
fields: []
methods: []
toConstantPool: func [value] [i: index? find constant_pool value either equal? i none [length? append constant_pool value] [i]]
constantUTF8: func [value] [toConstantPool join #{01} toUTF8 value]
constantString: func [value] [toConstantPool join #{08} toShort constantUTF8 value]
constantClass: func [name] [toConstantPool join #{07} toShort constantUTF8 name]
constantNameAndType: func [name type] [toConstantPool rejoin [#{0C} toShort constantUTF8 name toShort constantUTF8 type]]
constantFieldRef: func [class name type] [toConstantPool rejoin [#{09} toShort constantClass class toShort constantNameAndType name type]]
constantMethodRef: func [class name type] [toConstantPool rejoin [#{0A} toShort constantClass class toShort constantNameAndType name type]]
FieldDescriptor: [
[
'byte (fd: "B" fd_c: 1) |
'char (fd: "C" fd_c: 1) |
'double (fd: "D" fd_c: 2) |
'float (fd: "F" fd_c: 1) |
'int (fd: "I" fd_c: 1) |
'long (fd: "J" fd_c: 2) |
set x string! (fd: rejoin ["L" x ";"] fd_c: 1) |
'short (fd: "S" fd_c: 1) |
'boolean (fd: "Z" fd_c: 1)
]
opt [
set x integer! (fd: copy fd insert/dup fd "[" x fd_c: 1)
]
]
MethodDescriptor: [
(md: copy "(" md_pc: 0)
into [
any [
FieldDescriptor
(append md fd md_pc: add md_pc fd_c)
]
] ( append md ")") [
FieldDescriptor (md_rc: fd_c) |
'void (fd: "V" md_rc: 0)
]
(append md fd)
]
datei: open/new %Test.class
write datei #{CAFEBABE} ; magic
write datei toShort 3 ; minor_version
write datei toShort 45 ; major_version
if not parse [
public super "Test" "java/lang/Object" []
public "<init>" [] void [
aload_0
invokespecial "java/lang/Object" "<init>" [] void
return
]
public static "main" ["java/lang/String" 1] void [
getstatic "java/lang/System" "out" "java/io/PrintStream"
ldc_w string "Hallo, Welt!"
invokevirtual "java/io/PrintStream" "println" ["java/lang/String"] void
return
]
] [
any [
'public (access_flags: or~ access_flags #{0001}) |
'final (access_flags: or~ access_flags #{0010}) |
'super (access_flags: or~ access_flags #{0020}) |
'interface (access_flags: or~ access_flags #{0200}) |
'abstract (access_flags: or~ access_flags #{0400}) |
'synthetic (access_flags: or~ access_flags #{1000}) |
'annotation (access_flags: or~ access_flags #{2000}) |
'enum (access_flags: or~ access_flags #{4000})
]
set x string! (this_index: constantClass x)
set x string! (super_index: constantClass x)
into [any [set x string! (append interfaces constantClass x)]]
any [
(field: copy #{0000})
any [
'public (field: or~ field #{0001}) |
'private (field: or~ field #{0002}) |
'protected (field: or~ field #{0004}) |
'static (field: or~ field #{0008}) |
'final (field: or~ field #{0010}) |
'volatile (field: or~ field #{0040}) |
'transient (field: or~ field #{0080}) |
'synthetic (field: or~ field #{1000}) |
'enum (field: or~ field #{4000})
]
set x string! (append field toShort constantUTF8 x)
FieldDescriptor
(append field toShort constantUTF8 fd)
(append field toShort 0 append fields field)
]
any [
(method: copy #{0000} max_locals: 1)
any [
'public (method: or~ method #{0001}) |
'private (method: or~ method #{0002}) |
'protected (method: or~ method #{0004}) |
'static (method: or~ method #{0008} max_locals: 0) |
'final (method: or~ method #{0010}) |
'synchronized (method: or~ method #{0020}) |
'bridge (method: or~ method #{0040}) |
'varargs (method: or~ method #{0080}) |
'native (method: or~ method #{0100}) |
'abstract (method: or~ method #{0400}) |
'strict (method: or~ method #{0800}) |
'synthetic (method: or~ method #{1000}) |
]
set x string! (append method toShort constantUTF8 x)
MethodDescriptor
(append method toShort constantUTF8 md max_locals: add max_locals md_pc)
(code: copy #{})
opt [
into [
any [
'aload_0 (append code #{2A} max_locals: max max_locals 1) |
'getstatic copy x_cmd [2 string!] FieldDescriptor (append code rejoin [#{B2} toShort constantFieldRef x_cmd/1 x_cmd/2 fd]) |
'iconst_0 (append code #{03}) |
'invokespecial copy x_cmd [2 string!] MethodDescriptor (append code rejoin [#{B7} toShort constantMethodRef x_cmd/1 x_cmd/2 md]) |
'invokevirtual copy x_cmd [2 string!] MethodDescriptor (append code rejoin [#{B6} toShort constantMethodRef x_cmd/1 x_cmd/2 md])|
'ldc_w (append code #{13}) [
'string set x string! (append code toShort constantString x)
] |
'return (append code #{B1}) |
set x word! (print rejoin ["Unk.Inst.: " x] break)
]
]
]
(either empty? code [append method toShort 0 ] [
append method rejoin [toShort 1 toShort constantUTF8 "Code"
toInt add 12 length? code
toShort 5
toShort max_locals
toInt length? code
code
toShort 0
toShort 0
]
] append methods method)
]
end
] [print "Invalid Syntax"]
write datei toShort add 1 length? constant_pool ; constant_pool_count
write datei rejoin constant_pool ; constant_pool[constant_pool_count-1]
write datei access_flags ; access_flags
write datei toShort this_index ; this_class
write datei toShort super_index ; super_class
write datei toShort length? interfaces ; interfaces_count
foreach interface interfaces [write datei toShort interface] ; interfaces[interfaces_count]
write datei toShort length? fields ; fields_count
write datei rejoin fields ; field_info fields[fields_count]
write datei toShort length? methods ; methods_count
write datei rejoin methods ; methods[methods_count]
write datei toShort 0 ; attributes_count
; attributes[attributes_count]
close datei
Kurz hinter if not parse [ beginnt das Programm das kompiliert wird
Kein Floppy-Controller, kein Floppy. Ganz einfach.Mir fällt da spontan auch nur der Catweasel ein
Für ISA sind mir genug Controller bekannt, für PCI nicht. USB-Diskettenlaufwerke kann man vermutlich nicht schlachten.
Bei allen Heimcomputern der 80er befand sich das vollständige Betriebssystem in einem ROM und war mit dem BIOS identisch.Beim Amiga 1000 Befand sich der Kickstart auf Diskette und wurde beim anschalten in einen speziellen Speicher(WOM) geschrieben.
Mit unten meine keinen Bootloader oder ähnliches - sondern direkt ein eigenes BIOS zu schreiben oder wenn möglich eine eigene Firmware zu nutzen. Ob das klappt, weiß ich nicht, aber könnte man dieses "OS" noch OS nennen? Schließlich bauen Betriebssysteme auf dem BIOS auf.Es gibt mindestens ein Betriebssystem(OS 3.9) bei dem sich Teile(Genau die exec, dos, graphics und intuition.library) in einem BIOS besser gesagt ROM(Kickstart) befinden.
Vielleicht ist dies zu persönlich, aber wie verdient ihr euer Geld? Ich z.B. würde gerne einmal Spieleentwickler, Websiteentwickler und/oder Ingeneur werden.Zur Zeit bin ich auch Student aber das meiste Geld verdiene ich mit SAS Programmierung.
Ich hab jetzt mal einfach Borland C++ 4.5 für Win 3.1(weil ich es mal für 800DM gekauft hatte) genommen da steht in der Hilfe als Speichermodell Tiny wählen und beim linker /t angeben.Alternativ könnte man auch Turbo C 2.01 nehmenKann man damit auch problemlos flache Binaries bauen oder muss man sich da irgendwelche EXEn auseinandernehmen?
http://cc.embarcadero.com/item/25636