RENOIR - Technical Specifications

10 So Guy Like Me 10 Triumph-boy misses girl1

RENOIR - Technical Specifications2

This programs acts like Hello There at the beginning or opening. It prints out a text page dealing with a screenplay script, having six pairs of 'but' 'so' for each line of action, at the minimum. The 'but' is an 'AND' ; and the 'so' is an 'OR'. Each pair defines a computer word string bracketed or blocked between. The minimum coding for OPEN SOURCE means display text only.3

Addendum4

For NOT logic for all bits zero, use NAND logic, such that 0 becomes 0 with carry AND, then set 1 on carry NAND, with right most bit set 1 with NOR.5

For NOT logic for all bits one, use NAND logic, such that 1 becomes 1 with carry AND, then set 0 on carry NAND, with right most bit set 0 with NOR.6

Subtraction uses one's complement arithmetic, such that the register is set negative.7

That is, using NOT logic for all bits, use NAND logic: 8

such that any 0 becomes 0 with carry AND, then set any 1 for carry NAND, with 9

right most bit set 1 with NOR if 0; 10

such that any 1 becomes 1 with carry NAND, then set any 0 for carry NAND, with right most bit set 0 with NOR, if 1.11

We have seen how simple logic gates can perform the process of binary addition. It is only logical to assume that a similar circuit could perform binary subtraction.12

If we look at the possibilities involved in subtracting one 1-bit number from another, we can quickly see that three of the four possible combinations are easy and straight-forward. The fourth one involves a bit more:13

0 - 0 = 014

1 - 0 = 115

1 - 1 = 016

0 - 1 = 1, with a borrow bit.17

That borrow bit is just like a borrow in decimal subtraction: it subtracts from the next higher order of magnitude in the overall number. Let's see what the truth table looks like.18

INPUTS OUTPUTS 19

A B BORROW A - B20

0 0 0 021

0 1 1 122

1 0 0 123

1 1 0 024

This is an interesting result. The difference, A-B, is still an Exclusive-OR function, just as the sum was for addition. The borrow is still an AND function, but is A'B instead of AB.25

What we'd like to do, now, is find an easy way to use the binary adder to perform subtraction as well. We already have half of it working: the difference output. Can we simply invert the A input so the AND gate will have the right signals? No, we can't, because that would invert the sense of the Exclusive-OR function.26

What would be really nice is to convert B to the negative equivalent of its value, and then use the basic adder just as it stands. To see if we can do that, let's consider negative binary numbers below.27

Temperature Example28

An example of subtraction is to take the mean local temperature, 15 and subtract it from the six local readings:29

1 -15 -1111+0001 000130

2 -5 -0101+0001 101131

3 -5 -0101+0001 101132

4 5 010133

5 5 010134

6 15 111135

mean 0 000036

Division by two or right shifting is the reverse of left shifting for multiplying by two.37

Division is a kind of subtraction, while multiplication is a kind of addition. It is possible with LSE to create an addition as multiplication by left shifting and a subtraction as division by right shifting. The scientific calculator performs both additions and subtractions and both multiplications and division when inputs are not alike. When inputs are alike, it uses left shifting, and right shifting for subtraction or negation.38

The LSE uses octal to create negative numbers in one's complement. But uses binary to create negative numbers in two's complement for adding the right most one bit. Also the negative numbers are left shifted with the same process as below.39

NOT for all zeroes and NOT for all ones are both also left shifted. Errors may occur in the scientific calculator when overflow occurs. [Windows standard calculator VIEW]40

[http://www.play-hookey.com/digital/binary_subtraction.html]41

A Sixteen bit Computer42

0000 0000 0000 0000 43

CARRY SUM44

Shift A B A AND B A XOR B45

0000 0 0 0 046

0001 0 1 0 147

0010 1 0 0 148

0100 1 1 1 049

1000 0 0 0 050

Instructions 4 bit shift LSB right end51

[LSB least significant bit]52

0000 0000 0000 1111 (data)53

0100 0100 0100 0100 100054

0000 0000 0001 1110 (data)55

Note that you have to know what the data is56

in order to take the right instruction for it.57

Had the data been 1011 (data)58

0100 0000 0100 0100 [1000]59

0000 0000 0001 1110 (data)60

1000 acts as a place filler for LSB 061

[RSB really significant bit]62

Reading the instruction from RSB to set 63

the data bits loops until 1000.64

An instruction to set all four 4 bits is 65

Four sixteen bit words from RSB.66

In the examples above, the first three words67

are all three: 0000 0000 0000 0000 [1000]68

Then lastly: 0100 0000 0100 0100 [1000]69

By shifting one bit to the left, the four 70

instructions fit into four sixteen bit words:71

0000 0000 0000 0001 [three times]72

1000 0000 1000 1001 [Loop until LSB 1]73

Shifting back one bit to the right:74

1000 0000 0000 0000 [three times]75

1100 0000 0100 0100 [Loop until RSB 1]76

Remember that the leading RSB 1 77

means 1000 for the last 0 and a place setter.78

In short, there is no instruction register 79

because the RSB moves left, and then the next80

et cetera until the next RSB 1, in a left shift.81

The Carry function shifts each bit left until82

the RSB 1, then the Sum function sets LSB 0.83

Hence, the ADDER is a serial AND and XOR register.84

As the bits move into the LSB, the first bit is set left 85

by the Carry function, which shift each bit, 0 or 1, to 86

the left bit. This stops when the next most RSB 1.87

It is equivalent to a multiply by two on binary.88

The LSE works in decimal in the scientific calculator,89

converting to octal, then multiply by two, 90

which is a left bit shift. Divide is a right bit shift.91

Taking an average of two unlike numbers in decimal 92

and then converting to octal for multiply is not needed,93

because it is the sum of the two unlike numbers.94

Keeping in decimal the sum of the unlike numbers in the 95

scientific store register, all that is needed is to add any unlike 96

number to the store. In fact, any like number may be added.97

Since the doubled number is added once to the store instead of98

adding two unlike numbers in the store, it cuts down on adds.99

Converting a like number to octal from decimal, multiplying by two, 100

and converting from octal to decimal may decrease round off error.101

My idea of a shift register of 16 bits; which is a summing or adding register by itself.102

I had in mind to have four shifting registers, A, B, C, D; [conceptual in my mind]103

where A was serial input and B was parallel input from A, such that A stored to B, and A and B added to B; B parallel output to A; and C parallel output to D;104

where C was serial input and D was parallel input from C, such that C stored to D, and C and D multiplied to D, so that both B and D were continuous sum, product.105

When adding with A and B, C would act as a serial instruction register for A or B.106

When multiplying with C and D, A would act as serial instruction register for C or D.107

When adding with A and B, D would act as a parallel I/O register; and108

when multiplying with C and D, B would act as a parallel I/O register.109

Adding adds two [un] like numbers and divides by two to get arithmetic average.110

It converts this decimal number to octal and multiplies by two. Multiply is like add.111

Multiplying multiples two [un] like numbers and takes root to get multiplier average.112

It converts this decimal number to octal and multiplies by itself. Approximating113

Multiply may also add two [un] like numbers (1.0x) and subtract 1.0, divide by two.114

It converts this decimal number to octal and multiplies by two and adds 1.0. All of115

these operations avoid using registers, B, C, and D, since use of scientific calculator.116

My idea of the bit string resembles a cache with a start bit and an end bit. In this case, the start bit is the RSB 1 and the end bit is the LSB 0. This is a kind of editor, looking at the bit string and tagging it appropriately.117

What follows is a queue or cache that is X86 dependent upon variable lengths.118

1 273.15 [1.0] 119

2 283.15 [1.154679470] [1.0366] [1.1464]120

3 283.15 [1.154679470] [1.0366] [1.1464]121

4 293.15 [1.326645153] [1.0732] [1.2928]122

5 293.15 [1.326645153] [1.0732] [1.2928]123

6 303.15 [1.517139393] [1.1098] [1.4392]124

288.15 [1.246613712]125

[1.056] [1.2196]126

Entering a file of numbers127

[1.0]128

[1.0366]129

[1.0366]130

[1.0732]131

[1.0732]132

[1.1098]133

Adding the 2nd and 3rd, like and134

adding the 4th and 5th, like and135

adding the 1st and 6th, unlike136

by taking the sum in decimal and137

dividing by two for an average.138

Taking the average multiplied by two139

and adding to storage and dividing by 3140

for mean, 1.056. [1.0549]141

Adding the 2nd and 3rd, like (each -1) and142

adding the 4th and 5th, like (each -1) and143

adding the 1st and 6th, unlike (each -1)144

By taking the sum in decimal and145

again for each of the above (each +1) and 146

adding to storage and dividing by 3 for mean,147

1.2196. [1.224] using mean, and using sum [1.2928],148

gives an approximation for multiplying and again.149

Note this does not convert decimal to octal and back.150

[Were this decimal process in the octal process, each 151

time there was an adding to storage would involve a152

conversion to decimal using the addition function above153

then conversion to octal for storage. Also there would be154

processing of the instruction register by shifting four bits,155

creating four times four bits in sixteen bits, using the carry156

function and the sum function for logically shifting bits, as 157

well as shifting instructions, bits, negating and subtracting158

As we discovered when looking at binary counters, once a full count is obtained, the next clock pulse will cause the counter to read zero again. Likewise if we set up a counter to count backwards, the first clock pulse will cause the count to go from all zeroes to all ones. Thinking along these lines, we can see that the binary number 1111 might represent the decimal number 15, or it could represent the number -1.159

On the right is the counting sequence for a 4-bit binary number, with decimal equivalents expressed in two ways. First we have the unsigned counting sequence, where all numbers are assumed to be positive. Then we see the signed sequence, which includes both positive and negative numbers.160

Looking at the two decimal counting sequences, we note two factors right away:161

1. The positive signed numbers are the same as their unsigned counterparts. 162

2. Negative signed numbers all correspond to the most significant bit of the binary number being a logic 1. 163

Because positive numbers are the same in both sequences, they can be used together without difficulty. We only need to keep track of how we want to define the system. And the fact that negative numbers all have the binary MSB = 1 is helpful because the MSB can immediately be used to identify the sign of the number. Indeed, the binary MSB is commonly known as the sign bit. The use of this bit to distinguish between positive and negative numbers also allows us to divide the counting sequence evenly between positive and negative numbers.164

Now we need to look at the relationship between the binary numbers for positive and negative versions of the same magnitude. Suppose we invert each bit of 0001 (+1) to get 1110 (-2). If we then increment the result, we get 1111 (-1), which is what we wanted. Will this relationship hold for all negative numbers?165

In fact, it does work, as you can determine for yourself. To form the negative of any number, first complement all bits of the number. The result is the one's complement of the original number. Then, add 1 to the result, thus forming the two's complement of the original number. Arithmetic involving such signed numbers is known generally as two's complement arithmetic.166

To check the validity of this process, let's take the two's complement of 0. We should logically get a result of 0. So, we start with 0000, and form the one's complement (1111). Now add 1 to the result (10000). But this won't fit in a 4-bit number, so the extra 1-bit is lost, leaving a result of (0000). Sure enough, -0 = 0, as it should. Remember to discard the carry from the highest-order bit. Two's complement arithmetic always works this way.167

Note: It is not possible to represent +8 as a 4-bit signed number. Therefore it is not possible to correctly take the two's complement of -8. It will come back again as -8. Binary Unsigned168

Decimal Signed169

Decimal 170

0000 0 0 171

0001 1 1 172

0010 2 2 173

0011 3 3 174

0100 4 4 175

0101 5 5 176

0110 6 6 177

0111 7 7 178

1000 8 -8 179

1001 9 -7 180

1010 10 -6 181

1011 11 -5 182

1100 12 -4 183

1101 13 -3 184

1110 14 -2 185

1111 15 -1 186