It looks like you're new here. If you want to get involved, click one of these buttons!

- 141.2K All Categories
- 103.9K Programming Languages
- 6.5K Assembler Developer
- 1.9K Basic
- 40K C and C++
- 2.9K C#
- 7.9K Delphi and Kylix
- 4 Haskell
- 9.7K Java
- 4.1K Pascal
- 1.3K Perl
- 2K PHP
- 553 Python
- 37 Ruby
- 4.4K VB.NET
- 1.6K VBA
- 20.9K Visual Basic
- 2.6K Game programming
- 317 Console programming
- 93 DirectX Game dev
- 1 Minecraft
- 112 Newbie Game Programmers
- 2 Oculus Rift
- 9K Applications
- 1.8K Computer Graphics
- 748 Computer Hardware
- 3.5K Database & SQL
- 535 Electronics development
- 1.6K Matlab
- 628 Sound & Music
- 258 XML Development
- 3.3K Classifieds
- 199 Co-operative Projects
- 199 For sale
- 190 FreeLance Software City
- 1.9K Jobs Available
- 605 Jobs Wanted
- 213 Wanted
- 2.9K Microsoft .NET
- 1.8K ASP.NET
- 1.1K .NET General
- 3.4K Miscellaneous
- 7 Join the Team
- 356 Comments on this site
- 71 Computer Emulators
- 2.1K General programming
- 188 New programming languages
- 641 Off topic board
- 226 Mobile & Wireless
- 98 Android
- 126 Palm Pilot
- 340 Multimedia
- 156 Demo programming
- 184 MP3 programming
- Bash scripts
- 28 Cloud Computing
- 53 FreeBSD
- 1.7K LINUX programming
- 371 MS-DOS
- Shell scripting
- 321 Windows CE & Pocket PC
- 4.1K Windows programming
- 944 Software Development
- 417 Algorithms
- 68 Object Orientation
- 92 Project Management
- 95 Quality & Testing
- 271 Security
- 7.7K WEB-Development
- 1.8K Active Server Pages
- 62 AJAX
- 6 Bootstrap Themes
- 55 CGI Development
- 28 ColdFusion
- 224 Flash development
- 1.4K HTML & WEB-Design
- 1.4K Internet Development
- 2.2K JavaScript
- 37 JQuery
- 310 WEB Servers
- 157 WEB-Services / SOAP

Grizant
Member Posts: **4**

How would I create a multiplication subroutine that On input R2 and R3 contain two non-negative integers a (multiplicand)

;and b (multiplier) respectively, and on return R1 and R0 contain

; non-negative numbers h and l such the R1,R0 together contain the product

; of a and b :

; a * b = 2^15 * h + l . No other registers should be affected.

; On return R2 is trashed and R3 contains an error flag, which in this case

; is set iff either a or b is negative.

;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

; ld R2,M1000 ; address M1000 contains #1000

; add R3,R2,R2 ; R3 <-- #2000

; jsr mlt

; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

; 2000000 = 2^15 * 61 + 1152

There are several algorithms for multiplication. One can be developed based on

the binary place value system and noting that doubling a number

(i.e.,adding it to itself) shifts the bits one place left.

A simpler algorithm is based on adding R2 to itself R3 times. In this case

it might be better to test the operands to make sure R2 contains the larger of a and b.

(Adding 1000 to itself 3 times is much faster than adding 3 to itself 1000 times).

The product of a and b need not fit into one word: Say you are adding R2 to R0.

Remembering that the operands are all positive, a negative sum signifies overflow,

so the msb must be cleared and R1 incremented; e.g.:

ADD R0,R0,R2

BRzp mlt_goon ; go on if no overflow

AND R0,R0,R4 ; R4 previously loaded with x7FFF = b0111111111111111

ADD R1,R1,#1 ; add in "carry" from R0

mlt_goon

to test this I have

;t_mlt.asm

;RDO fall 2003 for pa2 .

.orig x3000

; One the simulator, use

;Simulate>Set Value...>Location and pull down R2, and put 1000, click Apply

; Then pull down R3, and put 2000, then Apply, then click OK.

; Highlight x3001 (the HALT statement) and then click Simulate>Toggle Breakpoint

; Then run this program with your mlt procedure added.

; When the program breaks before the HALT, click

; File>Save Memory Contents...pa2.dat, using x3000 to x30020

; for the memory range. Be sure "Save Registers" is checked.

jsr mlt

HALT

; After the LC3 has halted click

;

;;;;;;;;;;;;;;;;;;;;;;;;;;;

mlt

; On input R2 and R3 contain two non-negative integers a (multiplicand)

;and b (multiplier) respectively, and on return R1 and R0 contain

; non-negative numbers h and l such the R1,R0 together contain the product

; of a and b :

; a * b = 2^15 * h + l . No other registers should be affected.

; On return R2 is trashed and R3 contains an error flag, which in this case

; is set iff either a or b is negative.

;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

; ld R2,M1000 ; address M1000 contains #1000

; add R3,R2,R2 ; R3 <-- #2000

; jsr mlt

; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

; 2000000 = 2^15 * 61 + 1152

;********* YOUR CODE GOES HERE ***********

.end

;and b (multiplier) respectively, and on return R1 and R0 contain

; non-negative numbers h and l such the R1,R0 together contain the product

; of a and b :

; a * b = 2^15 * h + l . No other registers should be affected.

; On return R2 is trashed and R3 contains an error flag, which in this case

; is set iff either a or b is negative.

;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

; ld R2,M1000 ; address M1000 contains #1000

; add R3,R2,R2 ; R3 <-- #2000

; jsr mlt

; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

; 2000000 = 2^15 * 61 + 1152

There are several algorithms for multiplication. One can be developed based on

the binary place value system and noting that doubling a number

(i.e.,adding it to itself) shifts the bits one place left.

A simpler algorithm is based on adding R2 to itself R3 times. In this case

it might be better to test the operands to make sure R2 contains the larger of a and b.

(Adding 1000 to itself 3 times is much faster than adding 3 to itself 1000 times).

The product of a and b need not fit into one word: Say you are adding R2 to R0.

Remembering that the operands are all positive, a negative sum signifies overflow,

so the msb must be cleared and R1 incremented; e.g.:

ADD R0,R0,R2

BRzp mlt_goon ; go on if no overflow

AND R0,R0,R4 ; R4 previously loaded with x7FFF = b0111111111111111

ADD R1,R1,#1 ; add in "carry" from R0

mlt_goon

to test this I have

;t_mlt.asm

;RDO fall 2003 for pa2 .

.orig x3000

; One the simulator, use

;Simulate>Set Value...>Location and pull down R2, and put 1000, click Apply

; Then pull down R3, and put 2000, then Apply, then click OK.

; Highlight x3001 (the HALT statement) and then click Simulate>Toggle Breakpoint

; Then run this program with your mlt procedure added.

; When the program breaks before the HALT, click

; File>Save Memory Contents...pa2.dat, using x3000 to x30020

; for the memory range. Be sure "Save Registers" is checked.

jsr mlt

HALT

; After the LC3 has halted click

;

;;;;;;;;;;;;;;;;;;;;;;;;;;;

mlt

; On input R2 and R3 contain two non-negative integers a (multiplicand)

;and b (multiplier) respectively, and on return R1 and R0 contain

; non-negative numbers h and l such the R1,R0 together contain the product

; of a and b :

; a * b = 2^15 * h + l . No other registers should be affected.

; On return R2 is trashed and R3 contains an error flag, which in this case

; is set iff either a or b is negative.

;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

; ld R2,M1000 ; address M1000 contains #1000

; add R3,R2,R2 ; R3 <-- #2000

; jsr mlt

; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

; 2000000 = 2^15 * 61 + 1152

;********* YOUR CODE GOES HERE ***********

.end

Terms of use / Privacy statement / Publisher: Lars Hagelin

Programmers Heaven articles / Programmers Heaven files / Programmers Heaven uploaded content / Programmers Heaven C Sharp ebook / Operated by CommunityHeaven

© 1997-2017 Programmersheaven.com - All rights reserved.

## Comments

4: ;and b (multiplier) respectively, and on return R1 and R0 contain

: ; non-negative numbers h and l such the R1,R0 together contain the product

: ; of a and b :

: ; a * b = 2^15 * h + l . No other registers should be affected.

: ; On return R2 is trashed and R3 contains an error flag, which in this case

: ; is set iff either a or b is negative.

: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

: ; ld R2,M1000 ; address M1000 contains #1000

: ; add R3,R2,R2 ; R3 <-- #2000

: ; jsr mlt

: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

: ; 2000000 = 2^15 * 61 + 1152

:

: There are several algorithms for multiplication. One can be developed based on

: the binary place value system and noting that doubling a number

: (i.e.,adding it to itself) shifts the bits one place left.

: A simpler algorithm is based on adding R2 to itself R3 times. In this case

: it might be better to test the operands to make sure R2 contains the larger of a and b.

: (Adding 1000 to itself 3 times is much faster than adding 3 to itself 1000 times).

:

: The product of a and b need not fit into one word: Say you are adding R2 to R0.

: Remembering that the operands are all positive, a negative sum signifies overflow,

: so the msb must be cleared and R1 incremented; e.g.:

:

: ADD R0,R0,R2

: BRzp mlt_goon ; go on if no overflow

: AND R0,R0,R4 ; R4 previously loaded with x7FFF = b0111111111111111

: ADD R1,R1,#1 ; add in "carry" from R0

: mlt_goon

:

: to test this I have

:

: ;t_mlt.asm

: ;RDO fall 2003 for pa2 .

:

: .orig x3000

:

: ; One the simulator, use

: ;Simulate>Set Value...>Location and pull down R2, and put 1000, click Apply

: ; Then pull down R3, and put 2000, then Apply, then click OK.

: ; Highlight x3001 (the HALT statement) and then click Simulate>Toggle Breakpoint

: ; Then run this program with your mlt procedure added.

: ; When the program breaks before the HALT, click

: ; File>Save Memory Contents...pa2.dat, using x3000 to x30020

: ; for the memory range. Be sure "Save Registers" is checked.

:

: jsr mlt

: HALT

: ; After the LC3 has halted click

: ;

: ;;;;;;;;;;;;;;;;;;;;;;;;;;;

: mlt

: ; On input R2 and R3 contain two non-negative integers a (multiplicand)

: ;and b (multiplier) respectively, and on return R1 and R0 contain

: ; non-negative numbers h and l such the R1,R0 together contain the product

: ; of a and b :

: ; a * b = 2^15 * h + l . No other registers should be affected.

: ; On return R2 is trashed and R3 contains an error flag, which in this case

: ; is set iff either a or b is negative.

: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

: ; ld R2,M1000 ; address M1000 contains #1000

: ; add R3,R2,R2 ; R3 <-- #2000

: ; jsr mlt

: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

: ; 2000000 = 2^15 * 61 + 1152

: ;********* YOUR CODE GOES HERE ***********

:

: .end

:

:

1Well, this post is almost a year old to the day, but it still offends me, basically because this post is a OBVIOUSLY a request to do a programming assignment, mainly one which I give to my assembly language classes, for I am 'RDO' . 'Grizant' cut and pasted the assignment verbatim including some of my code, without my permission, of course.

I agree with an earlier post by Eric on this issue, in that I think it is good for students to ask questions of experienced programmers, and I would rather err on the side of liberality so as not to stifle such questions. Minimally, the asker must at least be able to paraphrase the problem in his or her own words, and show _some_ of their own clueless code.

On the whole, I trust the judgement and ethics of the real programmers on this list in responding to posts like this. Of course doing a student's assignment for them is not helping them or our profession in the long run, and charging students a _fee_ for producing code for school projects is a sign of predatory jaded cynicism or grave desparation.

We professors thank the members of this list for their cooperation in this. Students, keep the questions coming, but play fair.

unclebobobo

: How would I create a multiplication subroutine that On input R2 and R3 contain two non-negative integers a (multiplicand)

: ;and b (multiplier) respectively, and on return R1 and R0 contain

: ; non-negative numbers h and l such the R1,R0 together contain the product

: ; of a and b :

: ; a * b = 2^15 * h + l . No other registers should be affected.

: ; On return R2 is trashed and R3 contains an error flag, which in this case

: ; is set iff either a or b is negative.

: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

: ; ld R2,M1000 ; address M1000 contains #1000

: ; add R3,R2,R2 ; R3 <-- #2000

: ; jsr mlt

: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

: ; 2000000 = 2^15 * 61 + 1152

:

: There are several algorithms for multiplication. One can be developed based on

: the binary place value system and noting that doubling a number

: (i.e.,adding it to itself) shifts the bits one place left.

: A simpler algorithm is based on adding R2 to itself R3 times. In this case

: it might be better to test the operands to make sure R2 contains the larger of a and b.

: (Adding 1000 to itself 3 times is much faster than adding 3 to itself 1000 times).

:

: The product of a and b need not fit into one word: Say you are adding R2 to R0.

: Remembering that the operands are all positive, a negative sum signifies overflow,

: so the msb must be cleared and R1 incremented; e.g.:

:

: ADD R0,R0,R2

: BRzp mlt_goon ; go on if no overflow

: AND R0,R0,R4 ; R4 previously loaded with x7FFF = b0111111111111111

: ADD R1,R1,#1 ; add in "carry" from R0

: mlt_goon

:

: to test this I have

:

: ;t_mlt.asm

: ;RDO fall 2003 for pa2 .

:

: .orig x3000

:

: ; One the simulator, use

: ;Simulate>Set Value...>Location and pull down R2, and put 1000, click Apply

: ; Then pull down R3, and put 2000, then Apply, then click OK.

: ; Highlight x3001 (the HALT statement) and then click Simulate>Toggle Breakpoint

: ; Then run this program with your mlt procedure added.

: ; When the program breaks before the HALT, click

: ; File>Save Memory Contents...pa2.dat, using x3000 to x30020

: ; for the memory range. Be sure "Save Registers" is checked.

:

: jsr mlt

: HALT

: ; After the LC3 has halted click

: ;

: ;;;;;;;;;;;;;;;;;;;;;;;;;;;

: mlt

: ; On input R2 and R3 contain two non-negative integers a (multiplicand)

: ;and b (multiplier) respectively, and on return R1 and R0 contain

: ; non-negative numbers h and l such the R1,R0 together contain the product

: ; of a and b :

: ; a * b = 2^15 * h + l . No other registers should be affected.

: ; On return R2 is trashed and R3 contains an error flag, which in this case

: ; is set iff either a or b is negative.

: ;EXAMPLE: multiply #1000 by #2000 to obtain #2000000

: ; ld R2,M1000 ; address M1000 contains #1000

: ; add R3,R2,R2 ; R3 <-- #2000

: ; jsr mlt

: ; On return R3 is 0, R1 contains #61 and R0 contains #1152 since

: ; 2000000 = 2^15 * 61 + 1152

: ;********* YOUR CODE GOES HERE ***********

:

: .end

:

: