Searching \ for '[PIC]: Rounding to closest 1's multiple, code encl' in subject line. ()
Make payments with PayPal - it's fast, free and secure! Help us get a faster server
FAQ page: www.piclist.com/techref/microchip/devices.htm?key=pic
Search entire site for: 'Rounding to closest 1's multiple, code encl'.

Exact match. Not showing close matches.
PICList Thread
'[PIC]: Rounding to closest 1's multiple, code encl'
2001\04\06@103828 by o-8859-1?Q?K=FCbek_Tony?=

flavicon
face
Hi,
as I promised I've hammered out some rounding code and
will attach the rounding to closest 1s multiple below.
The rounding to closest 10's multiple is posted separately.

Some minor comments:
It's coded for 24 bit input/output trough fsr0,
uses some 18Cxx specific instructions ( wouldn't be
to hard to convert to other pic's ).
It's not fully omptimized, I'll leave that as an exerzice
to the user ( there are some places that can be improved )
The rounding takes about 88 instructions worst case.
As far as I can tell there really are no faster options
to round an 24 bit value. But please prove me wrong :)

And without the input from Bob,Roman and Scott it sure would
have been a rougher ride. Thanks.

Use at will.


; ***********************************************************************
; ROUND_ONES_FSR0_24bit - Rounds 24 bit unsigned value value pointed to by
fsr0
; according to (ones)granularity in w
; FSR0 must point to MSB of input, output will overwrite input at exit
; Granularity can be 0x05, 0x02 ( others not tested )
; 0x05 round to nearest decimal '5', 0x02 round to nearest decimal '2' etc.
; In other words low nibble of w decides the granularity for the ones digit
; Other granularities are untested and may/may not nork.
;
; Executes in about 88 cycles worst case
; About 65 instructions are used. I.e mostly unrolled code
;
; Algorithm:
; * Adds half granularity to input. ( i.e. for granularity 0x05 ( 5 ) 2 is
added )
; * 'Exctract' each bit's addition to the ones digit
;    After the actual 'extraction' it is normalized ( to 0-9 range ).
; * If ones digit is larger then granularity, granulairty is subtracted from
it
;   until next subtraction generates negative result.
; * Subtract the result from the input and overwrite with output.
;
;                      
; Ram usage ( all in access bank ):
; ARG2_24+1     1 byte 'ones'
; Temp          1 byte 'granularity' ( i.e. input in w )
;

ROUND_ONES_FSR0_24bit
       GLOBAL  ROUND_ONES_FSR0_24bit
       ; save granularity
       MOVWF   Temp,A
       ; set pointer to lsb of input
       MOVF    POSTINC0,W,A
       MOVF    PREINC0,W,A     ; pointer now to lsb and lsb in w
       ; add half of granularity(real) to input
       BCF     STATUS,C
       RRCF    Temp,W,A
       ADDWF   POSTDEC0,F,A    ; add to lsb and set pointer to middle byte
       MOVF    INDF0,W,A       ; get middle byte
       BTFSC   STATUS,C
       ADDLW   D'1'            ; propagate the carry
       MOVWF   POSTDEC0,A      ; save it and set pointer to msb
       BTFSC   STATUS,C
       INCF    INDF0,F,A       ; propagate the carry and leave pointer to
msb

       ; * calcualte top byte byte low nibble
       MOVF    INDF0,W,A       ;
       ANDLW   b'00001111'     ; mask out lowest nibble
       BTFSC   INDF0,0,A       ; lowest bit set in low nibble ?
       ADDLW   D'5'            ; yes add  5, it's worth '6' not 1
       MOVWF   ARG2_24+1,A     ; start value for the ones
       ; calcualte top byte high nibble
       SWAPF   INDF0,W,A       ;
       ANDLW   b'00001111'     ; mask out lowest nibble
       BTFSC   POSTINC0,4,A    ; lowest bit set in high nibble ? *set
pointer to middle byte *
       ADDLW   D'5'            ; yes add  5, it's worth '6' not 1
       ADDWF   ARG2_24+1,F,A   ; add it to ones
       ; * calcualte middle byte low nibble
       MOVF    INDF0,W,A       ;
       ANDLW   b'00001111'     ; mask out lowest nibble
       BTFSC   INDF0,0,A       ; lowest bit set in low nibble ?
       ADDLW   D'5'            ; yes add  5, it's worth '6' not 1
       ADDWF   ARG2_24+1,F,A   ; add it to ones
       ; calcualte middle byte high nibble
       SWAPF   INDF0,W,A       ;
       ANDLW   b'00001111'     ; mask out lowest nibble
       BTFSC   POSTINC0,4,A    ; lowest bit set in high nibble ?*set
pointer to lowest byte *
       ADDLW   D'5'            ; yes add  5, it's worth '6' not 1
       ADDWF   ARG2_24+1,F,A   ; add it to ones
       ; * calculate lowest nibble of lowest byte
       MOVF    INDF0,W,A       ;
       ANDLW   b'00001111'     ; mask out lowest nibble
       ADDWF   ARG2_24+1,F,A   ; add it to ones
       ; calculate top nibble 'ones' byte
       SWAPF   INDF0,W,A       ;
       ANDLW   b'00001111'     ; mask out lowest (prev. highest) nibble
       BTFSC   INDF0,4,A       ; lowest bit set in top nibble ?
       ADDLW   D'5'            ; yes add  5, it's worth '6' not 1
       ADDWF   ARG2_24+1,F,A   ; add it to ones

       ; pointer fsr0 points to lsb of input here
ROUND_ONES_FSR0_NORM
       ; *** ones updated now we need to normalize it ( i.e. remove
everything above 10 )
       ; Maximum value for the ones: 109
       ; we start by subtracting 30 from the ones until negative, then add
ten until positive again
       ; after which we know it's in 0-9 range
       ; subtract 30 from ones        
       MOVLW   D'30'
ROUND_ONES_FSR0_SUB30
       ; subtract 30 from ones
       SUBWF   ARG2_24+1,F,A
       SKPNC   ; overflow, i.e. negative then add 10 until positive again
       GOTO    ROUND_ONES_FSR0_SUB30
       ; add 10 until positive again
       MOVLW   D'10'
ROUND_ONES_FSR0_ADD10
       ; add 10 to ones
       ADDWF   ARG2_24+1,F,A  
       SKPC    ; positive ?
       GOTO    ROUND_ONES_FSR0_ADD10   ; nope still negative
       ; now ones are positive and below 10, i.e. we have successfully
subtracted
       ; the ones digit for the 24 bit input
       
       ; ** calculate granularity diff in the ones digit
       ; subtract granularity from the ones byte
       MOVF    ARG2_24+1,W,A   ; start value
ROUND_ONES_FSR0_GRAN_CHK
       MOVWF   ARG2_24+1,A     ; save start value ( or concecutive values )
       MOVF    Temp,W,A        ; get granularity
       ; subtract it from the tens
       SUBWF   ARG2_24+1,W,A
       ; check if negative or positive
       ; if positive/zero save result and try again
       BTFSS   STATUS,N
       GOTO    ROUND_ONES_FSR0_GRAN_CHK
       ; get the diff into w
       MOVF    ARG2_24+1,W,A   ; granularity diff
       ; now we subtract this from the input
       SUBWF   POSTDEC0,F,A    ; subtract and set pointer to middle byte
       SKPC    
       DECF    INDF0,F,A       ; propagate the borrow
       MOVF    POSTDEC0,W      ; set pointer to msb
       SKPC    
       DECF    INDF0,F,A       ; propagate the borrow and leave pointer to
msb of input
                               
       RETURN





Tony Kübek, Flintab AB            
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²
E-mail: spam_OUTtony.kubekTakeThisOuTspamflintab.com
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²

--
http://www.piclist.com hint: To leave the PICList
.....piclist-unsubscribe-requestKILLspamspam@spam@mitvma.mit.edu


2001\04\06@104754 by Bob Ammerman

picon face
Rounding to nearest 2 is really trivial:

If LSBit is set then add 1.

Bob Ammerman
RAm Systems
(contract development of high performance, high function, low-level
software)

{Original Message removed}

2001\04\06@105826 by Bob Ammerman

picon face
Tony,

I hate to do this to you, but here is simpler(?) way to round to nearest 5:

Given 25 bit number HI:MID:LO

Its value is

LO + 256*MID + 65536*HI

Which is equal to

LO+255*MID+MID+65535*HI+HI

But 255*MID and 65535*HI are both multiples of 5, so:

LO+MID+HI == HI:MID:LO (mod 5)

This can be at most a 10 bit number, let us call it H2:L2

now we can:

   movf    L2,W,A
   andlw  0x0F
   movwf ONES,A

   swapf L2,W,A
   andlw 0x0F
   btfsc   L2,4
   addlw 5        ; worth 6, not 1

   btfsc    H2,0
   addlw    6
   btfsc    H2,1
   addlw    2

and Bob's your uncle!

Bob Ammerman
RAm Systems
(contract development of high performance, high function, low-level
software)

--
http://www.piclist.com hint: To leave the PICList
piclist-unsubscribe-requestspamKILLspammitvma.mit.edu


2001\04\06@111905 by o-8859-1?Q?K=FCbek_Tony?=

flavicon
face
Hi,

Scott Dattalo wrote:
>Tony,
>I hate to do this to you, but here is simpler(?) way to round to nearest 5:

Thankfully accepted :)

{Quote hidden}

I'll be darned, I certanily hope there are no such shortcuts for
the 10's multiple, that would make my latest 3 hours a total waste :).

Brilliant !

Actually I never really thought about the 1's routine it was just
an cutNpaste job from the 10's. followed by some minor tests
to spot any obvious misstakes.

>and Bob's your uncle!

I guess :)

/Tony


Tony Kübek, Flintab AB            
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²
E-mail: .....tony.kubekKILLspamspam.....flintab.com
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²

--
http://www.piclist.com hint: To leave the PICList
EraseMEpiclist-unsubscribe-requestspam_OUTspamTakeThisOuTmitvma.mit.edu


2001\04\06@111915 by o-8859-1?Q?K=FCbek_Tony?=

flavicon
face
Hi,

I appologise to Bob,as Iinadvetely wrote paraphrased 'Scott Dattalo'
as the poster in my last two postings.

Ofcource it should have read:

"Bob Ammerman wrote:"


Sorry,

/Tony



Tony Kübek, Flintab AB            
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²
E-mail: tony.kubekspamspam_OUTflintab.com
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²

--
http://www.piclist.com hint: To leave the PICList
@spam@piclist-unsubscribe-requestKILLspamspammitvma.mit.edu


2001\04\06@111926 by o-8859-1?Q?K=FCbek_Tony?=

flavicon
face
Hi,

Scott Dattalo wrote:
>Rounding to nearest 2 is really trivial:
>
>If LSBit is set then add 1.

Yes I know, the same goes for 1 it's *very* trivial :).

It's main use is for 5, however input granularity 1 and 2
doesn't 'brake' the routine. Still outputs what's expected.

But ofcource who want's to waste cycles ?.


/Tony




Tony Kübek, Flintab AB            
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²
E-mail: KILLspamtony.kubekKILLspamspamflintab.com
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²

--
http://www.piclist.com hint: To leave the PICList
RemoveMEpiclist-unsubscribe-requestTakeThisOuTspammitvma.mit.edu


2001\04\06@123957 by Scott Dattalo

face
flavicon
face
On Fri, 6 Apr 2001, [Iso-8859-1] Kübek Tony wrote:

> Hi,
>
> Scott Dattalo wrote:

Actually Bob. And it's a damned clever idea.

{Quote hidden}

actually the 10's aren't much harder:

lo + 256*mid + 65536*hi = lo +250*mid + 65530*hi + 6*(mid + hi)

  clrf   h2
  movf   mid, w
  addwf  hi,w
  rlfc   h2,f
  movwf  l2       ;mid+hi
  addwf  l2,f     ;2*mid+2*hi
  skpnc
   incf  h2,f
  addwf  l2,f     ;3*mid+3*hi
  skpnc
   incf  h2,f

  clrc      rlf    temp,w   ;6*mid+6*hi
  skpnc
   incf  h2,f

  addwf  lo,w
  skpnc
   incf  h2,f

at this point, h2:l2 is congruent to the original 24-bit number modulo 10 and is
no more than 14-bits. But this is off the top of my head and not necessarily
optimized...


>
> Brilliant !

Yeah! Let's by Bob a beer.

Scott

--
http://www.piclist.com hint: To leave the PICList
spamBeGonepiclist-unsubscribe-requestspamBeGonespammitvma.mit.edu


2001\04\06@232039 by Djula Djarmati

flavicon
face
Here is another version for 24bit mod 10 for 14bit core:

Mod10   movfw LO                +ADs-Calculates HI:MED:LO mod 10
       andlw 0x0f              +ADs-Output (0-9) is in W
       movwf Tmp               +ADs-Bits 3:0 normal weight 8421
       swapf LO,w              +ADs-
       call CalcNbl            +ADs-Bits 7:4 -+AD4- weight 8426
       movfw MED               +ADs-
       call CalcNbl            +ADs-Bits 11:8 -+AD4- weight 8426
       swapf MED,w             +ADs-
       call CalcNbl            +ADs-Bits 15:12 -+AD4- weight 8426
       movfw HI                +ADs-
       call CalcNbl            +ADs-Bits 18:15 -+AD4- weight 8426
       swapf HI,w              +ADs-
       call CalcNbl            +ADs-Bits 23:19 -+AD4- weight 8426
       swapf Tmp,w             +ADs-24 bits shrinked to 7 in Tmp
       call CalcNbl            +ADs-Shrink more to 5 bits
       movfw Tmp               +ADs-
       skpndc                  +ADs-Bit4+AD0-1? (digit carry)
       addlw 6                 +ADs-yes, 8421 to 8426 for bit4
       addlw -10               +ADs-Bits 3:0 are ok now
       skpdc                   +ADsAPA-10?
       addlw 10                +ADs-yes, restore old value
       andlw 0x0f              +ADs-clear upper bits
       return

CalcNbl andlw 0x0f              +ADs-Take care of 8426 weight scheme
       addwf Tmp,f             +ADs-for a nibble, first add 8421
       andlw 1                 +ADs-Mask bit 0
       movlw 5                 +ADs-Prepare addition
       skpz                    +ADs-Nibble bit0+AD0-1?
       addwf Tmp,f             +ADs-yes, add 5 to get 8426
       return


Djula

--
http://www.piclist.com hint: To leave the PICList
TakeThisOuTpiclist-unsubscribe-requestEraseMEspamspam_OUTmitvma.mit.edu


2001\04\07@135904 by Scott Dattalo

face
flavicon
face
I'd like to expand on Bob's idea a little.

To recap, we have a 24bit number and we'd like to find a smaller number that is
congruent to it modulo 5. In other words, if we divide the 24 bit number by 5
and the smaller number by 5 we get the same remainder. Perhaps a little table
can illustrate the pattern:


N   N % 5 (modulo operator)
-----------------------------
0   0
1   1
2   2
3   3
4   4
5   0
6   1
7   2
8   3
9   4
10   0
11   1
  .
  .
  .

The right column is the remainder after the left column has been divided by
5. In modulo parlance, we'd say 11 is congruent to 1 modulo 5.


Bob's observation is that a 24 bit number may represented (in base 256) like:

N =  H*256^2 + M*256^1 + L*256^0
 =  H*65536 + M*256 + L
 =  H*65535 + M*255 + L  + H + M

And as he pointed out, if we want to determine a smaller number congruent to
this modulo 5, then we only need to sum L,M, and H.

Why?

Well take the middle byte:


(M*255 )%5 = (M%5) * (255%5)
          = (M%5) * 0
          = 0

255 is congruent to 0 mod 5. The same is true for 65535 and the high byte
product.

So the first simplification (again as Bob notes):

N%5 == (H+L+M)%5

But we can continue! The H+L+M sum is less than or equal to 255*3, which is only
a 10 bit number. Split this into a 2-byte number like so:

N%5 == (H+L+M)%5
   == (H2:M2)%5
   == (256*H2 + M2) %5
   == (H2 + M2) %5

This might produce a 9-bit number, but there's an assembly trick to get it back
to 8. So, assume for now that H2+M2 < 256. Now, let's look at nibbles:

N2 = H2+M2
  = a*16 + b
  = a*15 + a + b

N2%5 == (a+b)%5

This is at most a 5bit number. But again, there's an assembly trick to make it a
nibble. Here's the whole thing in assembly.


; Compute N % 5, where N is a 24-bit number H:M:L

   clrf  temp       ; Add the three bytes together
   movf  L,w
   addwf M,w
   rlf   temp,f
   addwf H,w
   skpnc
    incf temp,f

;; temp = H2, W = L2

   addwf temp,f   ;temp = L2+H2, carry has 9'th bit
   skpnc
    incf temp,f   ;temp is less than 5, so we could return...

; Now for the nibbles

   swapf temp,w
   addwf temp,f
   skpndc
    incf temp,f

At this point, the lower nibble contains a number that is congruent modulo 5 to
the 24 bit number. If we want to convert this to a number between 0 and 5:

   movf    temp,w  ;(or we could cause the previous instructions
                   ; to leave the result in W)
   addlw   -10     ;If the nibble >=10, then subtract 10
   skpdc
    addlw  10

; now the nibble is between 0 and 9
   addlw   -5      ;if we're between 5 and 9, subtract 5
   skpdc
    addlw  5

That's 21 instructions to get the modulo 5 of a 24 bit number (in the lower 3
bits of W).

Now it's not too hard to get the 10's digit if we have the 5's. Repeating the
modulo table with the 10's column:


N   N % 5   N % 10
-----------------------------
0     0       0
1     1       1
2     2       2
3     3       3
4     4       4
5     0       5
6     1       6
7     2       7
8     3       8
9     4       9
10     0       0
11     1       1
  .
  .
  .

The trick to note now is that is that if the least significant bits of N and N%5
are different then we can add 5 to N%5 and get N%10 !

So continuing from above:


    andlw  b00000111  ;Get rid of the junk
    movwf  temp       ;Compare N%5
    xorwf  L,w        ; to the low byte
    andlw  1          ; - we're only interested in the LSB
    skpz              ;If it's set
     movlw 5          ; we add 5 otherwise we add 0
    addwf  temp,w     ; or f

28 instructions total to get N%10. I reckon there's a trick or two lurking in
there.

Scott

--
http://www.piclist.com hint: PICList Posts must start with ONE topic:
[PIC]:,[SX]:,[AVR]: ->uP ONLY! [EE]:,[OT]: ->Other [BUY]:,[AD]: ->Ads


2001\04\07@153816 by Bob Ammerman

picon face
Bravo, bravo!

Bob Ammerman
RAm Systems
(contract development of high performance, high function, low-level
software)

{Original Message removed}

2001\04\08@051310 by Nikolai Golovchenko

flavicon
face
Thanks Bob an Scott! Great ideas.

Scott, your version can be improved a little, by 2 words:

{Quote hidden}

The above does the same as:

   movf L, w
   addwf M, w
   skpnc
    addlw 1
   addwf H, w
   skpnc
    addlw 1
   movwf temp, w


Here is a further extension. It is possible to get directly the modulo
10 value, without going through the modulo 5 phase. Unfortunately, not
much difference in code size - 27 words.

For what it's worth:

;Nibble weights and modulo 10 values:
;1 % 10 = 1     | L (low byte)
;16 % 10 = 6    |
;256 % 10 = 6       | M (middle byte)
;4096 % 10 = 6      |
;65536 % 10 = 6         | H (high byte)
;1048756 % 10 = 6       |

   movf H, w           ;add middle and high bytes (256%10=6, and 65536%10=6)
   addwf M, w
   skpnc               ;if carry ((256*6)%10=6),
    addlw 1            ;increment w - this is equivalent to adding 6,
                       ;because w is to be multiplied by 6
   movwf temp          ;add nibbles ((1*6)%10=6, (16*6)%10=6)
   swapf temp, w
   addwf temp, f
   skpndc              ;if digit carry, increment
    incf temp, f
   swapf L, w          ;add higher nibble from low byte (16%10=6)
   addwf temp, w
   skpndc
    addlw 1
   movwf temp          ;store in temp.
                       ;Now temp should be multiplied by 6. The lower 4 bits
                       ;will have the following weights after multiplication:
                       ;1*6 = 6
                       ;2*6 = 12
                       ;4*6 = 24
                       ;8*6 = 48
                       ;That can be simplified if we apply the modulo 10 operation:
                       ;6%10 = 6 = 1 + 5
                       ;12%10 = 2
                       ;24%10 = 4
                       ;48%10 = 8
                       ;If we add 5 when lower bit is set, we get a corrected value,
                       ;which can be used then directly, without multiplication!

   btfsc temp, 0       ;correct sum
    addlw 5
   skpndc              ;if we get here skipping addition, the DC flag is cleared previously
    addlw 6            ;if nibble overflows, add 6 (16%10 = 6)

   addwf L, w          ;add lower nibble of low byte (weight = 1)
   skpndc              ;fix overflows
    addlw 6
   skpndc              ;one more time (e.g. if sum was 31, it overflows again
    addlw 6            ;after 15+6=21=16+5, and should be corrected again 5+6=11)

   addlw -10           ;find modulo 10 of a 4 bit number
   skpdc
    addlw 10

   andlw 0x0F          ;clear higher bits (if necessary)


Best regards,
Nikolai

--
http://www.piclist.com hint: The list server can filter out subtopics
(like ads or off topics) for you. See http://www.piclist.com/#topics


2001\04\08@072613 by o-8859-1?Q?K=FCbek_Tony?=

flavicon
face
Hi,

Bob Ammeroman wrote: ( correct this time :) )

>Bravo, bravo!

as an reply to Scott Dattalo's posting:

> I'd like to expand on Bob's idea a little.
>
> To recap, we have a 24bit number and we'd like to find a smaller number
that is
> congruent to it modulo 5. In other words, if we divide the 24 bit number
by 5
> and the smaller number by 5 we get the same remainder. Perhaps a little
table
> can illustrate the pattern:

<big snip>

I'm in awe,
I was looking for a 'clever' way to round variables
particulary 24 bit ones and You outshined everything I
could envision.
Thanks,

/Tony





Tony Kübek, Flintab AB            
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²
E-mail: RemoveMEtony.kubekspamTakeThisOuTflintab.com
²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²

--
http://www.piclist.com hint: The list server can filter out subtopics
(like ads or off topics) for you. See http://www.piclist.com/#topics


2001\04\08@083017 by Drew Vassallo

picon face
Needless to say, but I hope you guys post all this stuff to the PICLIST
software archives... it's absolutely amazing.

While I don't have a project that needs this rounding code at the moment,
I'm sure I will in the future.  Please try to post it to the archives.

--Andrew
_________________________________________________________________
Get your FREE download of MSN Explorer at http://explorer.msn.com

--
http://www.piclist.com hint: The list server can filter out subtopics
(like ads or off topics) for you. See http://www.piclist.com/#topics


2001\04\08@112811 by James Newton

face picon face
Darn it! YOU post it to the archives. There is a form on the bottom of every
page that allows one to post code, make a new page, etc... and the archive
allows one to very easily add a link to any post or thread by simply pasting
in the URL of the page at the site where the link should be added.

I worked hard to make it possible for others to post to the site directly so
that I would not have to work hard keeping it up to date. It is supposed to
be a group effort. You own the site as much as I do... Its your own
contributions that make it great.

I'm trying to concentrate on other projects like a parametric search engine
to help find the best PIC for the job and shopping cart services and
auctions (free) for people to use to buy and sell chips, programmers, etc...

Having said all that, I've already linked this topic from the basic math
page at
http://www.piclist.com/techref/microchip/math/basic.htm

James Newton, PICList Admin #3
jamesnewtonEraseMEspam.....piclist.com
1-619-652-0593 phone
http://www.piclist.com

{Original Message removed}

2001\04\08@151544 by Drew Vassallo

picon face
>Darn it! YOU post it to the archives. There is a form on the bottom of
>every

Hehe James.  I didn't mean that you should do it, specifically.  I realize
you've done quite a ton of work to make it easy for people to add stuff to
pages.  However, what I meant, simply, was that there seemed to be a good
deal of theory involved with Bob's and Scott's simplification of the problem
and that they should set up a nice paragraph or two on the list to describe
how this stuff works, along with the code.

Far be it from me to impose upon someone else's code and list it on the
PICLIST site.

--Andrew
_________________________________________________________________
Get your FREE download of MSN Explorer at http://explorer.msn.com

--
http://www.piclist.com hint: The list server can filter out subtopics
(like ads or off topics) for you. See http://www.piclist.com/#topics


2001\04\08@163935 by Bob Ammerman

picon face
>
> Far be it from me to impose upon someone else's code and list it on the
> PICLIST site.
>
> --Andrew
>

I hereby and for all time give permission to anyone subscribed to the
PICLIST to post any code which I provide in a posting on PICLIST to
piclist.com or any other location on the www. I only ask that the code be
attributed to me.

Bob Ammerman
RAm Systems
(contract development of high performance, high function, low-level
software)

--
http://www.piclist.com hint: The list server can filter out subtopics
(like ads or off topics) for you. See http://www.piclist.com/#topics


2001\04\08@165017 by James Newton

face picon face
Sorry, I was reading that just as my 3 year old was making me crazy...
<GRIN>

But I really do need help managing the site...
...it has grown to a point where it is too much for one person.

The WYSIWYG edit and page update forms make it very easy. Please do be
involved.

James Newton, PICList Admin #3
EraseMEjamesnewtonspampiclist.com
1-619-652-0593 phone
http://www.piclist.com

{Original Message removed}

2001\04\09@170513 by uter van ooijen & floortje hanneman

picon face
> I hereby and for all time give permission to anyone subscribed to the
> PICLIST to post any code which I provide in a posting on PICLIST to
> piclist.com or any other location on the www. I only ask that the code be
> attributed to me.

He, me too!
Can we make that the small print you have to agree to before joining the
list?

Wouter

--
http://www.piclist.com hint: The PICList is archived three different
ways.  See http://www.piclist.com/#archives for details.


2001\04\10@025142 by Vasile Surducan

flavicon
face
On Mon, 9 Apr 2001, wouter van ooijen & floortje hanneman wrote:

> > I hereby and for all time give permission to anyone subscribed to the
> > PICLIST to post any code which I provide in a posting on PICLIST to
> > piclist.com or any other location on the www. I only ask that the code be
> > attributed to me.
>
> He, me too!
> Can we make that the small print you have to agree to before joining the
> list?
>
> Wouter
>
 Would be applicable for jal 6k too ?
 Vasile

--
http://www.piclist.com#nomail Going offline? Don't AutoReply us!
email RemoveMElistservEraseMEspamEraseMEmitvma.mit.edu with SET PICList DIGEST in the body


2001\04\10@114307 by uter van ooijen & floortje hanneman

picon face
> > > I hereby and for all time give permission to anyone subscribed to the
> > > PICLIST to post any code which I provide in a posting on PICLIST to
> > > piclist.com or any other location on the www. I only ask that the code
be
> > > attributed to me.
> >
> > He, me too!
> > Can we make that the small print you have to agree to before joining the
> > list?
> >
>   Would be applicable for jal 6k too ?
>
Sorry Vasile, only for what I already make public somwehere else. And of
course it is difficult to make public what does not exists yet (BTW it will
be 8k, when you keep yourself in check and stay below 6k it will be WLoader
compatible).

Wouter

--
http://www.piclist.com#nomail Going offline? Don't AutoReply us!
email RemoveMElistservspam_OUTspamKILLspammitvma.mit.edu with SET PICList DIGEST in the body


More... (looser matching)
- Last day of these posts
- In 2001 , 2002 only
- Today
- New search...