> -----Original Message-----
> From: .....piclist-bouncesKILLspam@spam@mit.edu
> [piclist-bouncesKILLspammit.edu] On Behalf Of Mark Rages
> Sent: 2005 Jul 15, Fri 10:26
> To: .....piclistKILLspam.....mit.edu
> Subject: [PIC] Design Challenge: Find center of three values
>
> Here's a design challenge for you guys:
>
> I have values in three file registers:  fileA, fileB, fileC.
>
> I want to choose the value that's in the middle (numerically)
> and put it into W.
>
> The brute-force way to do this would be to copy the list,
> sort the copy in place, and choose the middle value.
>
> I'm sure there's a more direct way.  Any ideas?
>
> (Application:  This a simple nonlinear filter to remove
> occasional outliers in a sampled data stream.)
>
> Regards,
> Mark
> markrages@gmail
> --
> You think that it is a secret, but it never has been one.
>   - fortune cookie
>

> On 7/15/05, Mark Rages <markragesspam_OUTgmail.com> wrote:
> > Here's a design challenge for you guys:
>
> I should add, I'm using the 14-bit 16F688.
>
> Regards,
> Mark
> markrages@gmail
> --
> You think that it is a secret, but it never has been one.
>   - fortune cookie
>

> Here's a design challenge for you guys:
>
> I have values in three file registers:  fileA, fileB, fileC.
>
> I want to choose the value that's in the middle (numerically) and put it
> into W.
>
> The brute-force way to do this would be to copy the list, sort the
> copy in place, and choose the middle value.
>
> I'm sure there's a more direct way.  Any ideas?
>
> (Application:  This a simple nonlinear filter to remove occasional
> outliers in a sampled data stream.)
>
> Regards,
> Mark
> markrages@gmail

> How's this? I had to use a temp register though:
>
> movf   file1,w
> subwf  file2,w
> btfsc  STATUS, C
> goto   $ + 2
> movf   file1,w
> goto   $ + 1
> movf   file2,w
> movwf  temp
> subwf  file3,w
> btfsc  STATUS, C
> goto   $ + 2
> movf   file3,w
> movwf  temp
> movf   temp,w
>
> Cheerful regards,
> Bob Blick
>
>
>> Here's a design challenge for you guys:
>>
>> I have values in three file registers:  fileA, fileB, fileC.
>>
>> I want to choose the value that's in the middle (numerically) and put it
>> into W.
>>
>> The brute-force way to do this would be to copy the list, sort the
>> copy in place, and choose the middle value.
>>
>> I'm sure there's a more direct way.  Any ideas?
>>
>> (Application:  This a simple nonlinear filter to remove occasional
>> outliers in a sampled data stream.)
>>
>> Regards,
>> Mark
>> markrages@gmail
>
>

> Oops, we don't need to copy REGA, so it can be done even faster:
>
>     ; Find median of REGA, REGB, REGC.
>
>     MOVF    REGB,W    ;TEMP2 = REGB.
>     MOVWF   TEMP2     ;
>     MOVF    REGC,W    ;MEDIAN = REGC.
>     MOVWF   MEDIAN    ;
>
>     SUBWF   TEMP2,W   ;TEMP2 >= MEDIAN?
>     BC      $+3       ;If so, skip ahead.
>     ADDWF   MEDIAN    ;Otherwise, swap MEDIAN and
>     SUBWF   TEMP2     ;TEMP2.
>
>     MOVF    REGA,W   ;MEDIAN >= REGA?
>     SUBWF   MEDIAN,W  ;
>     SKPC              ;If so, skip ahead.
>     SUBWF   MEDIAN    ;Otherwise, MEDIAN = TEMP1.
>
>     MOVF    MEDIAN,W  ;TEMP2 >= MEDIAN?
>     SUBWF   TEMP2,W   ;
>     SKPC              ;If so, skip ahead.
>     ADDWF   MEDIAN    ;Otherwise, MEDIAN = TEMP2.
>
> 17 words, 16 or 17 cycles.

>
> On 7/15/05, Mark Rages <spamBeGonemarkragesKILLspamgmail.com> wrote:
> > I'll post my solution in a minute, once I'm satisfied it works.
>
> Well, I think it's working and it's quitting time, so here goes:
>
> I started by listing all the possibilities:
>
> A > B > C choose B
> A > C > B choose C
> B > A > C choose A
> B > C > A choose C
> C > A > B choose A
> C > B > A choose B
>
> I notice that there are really only three comparisons, if we ingnore
> equality.  (After all, if A=B, it doesn't matter which I choose.)
>
> So I made a mapping from the comparison result to the choice:
>
> A>B | B>C | C>A | Choose
> ----+-----+-----+--------
>  1  |  1  |  0  | B
>  1  |  0  |  0  | C
>  0  |  1  |  0  | A
>  0  |  1  |  1  | C
>  1  |  0  |  1  | A
>  0  |  0  |  1  | B
>
> Or, in decimal and numerical order:
> comparison  | choose
> ------------+--------
>    0        | X
>    1        | B
>    2        | A
>    3        | C
>    4        | C
>    5        | A
>    6        | B
>    7        | X
>
> But there's an interesting symmetry here: 3..0 is the same as 4..7.  This will
> simplify my selection code.
>
> Here's my code.  I used one temp register for the comparison result.
>
> gteq macro fileA,fileB
>         movfw fileB             ; w=B
>         subwf fileA,w           ; w=A-B
>         ;; if B>A we borrowed, so _borrow=0
>         ;;  ... _borrow=1 means A>B or A==B
>
>         ;; Tack the result on the right of the comparison register.
>         rlf iris_adc_temp,f     ; '1'-> A>=B
>         endm
>
> abc_median macro A,B,C
>         local done
>
>         clrf comparison_temp
>
>         ; do comparisons
>         gteq A,B
>         gteq B,C
>         gteq C,A
>
>         ;; fold around 4
>         movfw comparison_temp
>         btfsc comparison_temp,2 ; is >=4?
>         sublw 0x07              ; yes. 4->3,5->2,6->1,7->0
>
>         skpnz                   ; handle special case A=B=C
>         movlw 0x01              ; in that case just choose any!
>
>         movwf comparison_temp
>
>         ; Now select from A,B,C like this:
>         ;; 1 -> B
>         ;; 2 -> A
>         ;; 3 -> C
>
>         movfw A
>         btfss comparison_temp,0 ; this bit clear: comparison_temp=2
>         goto done
>
>         movfw B
>         btfss comparison_temp,1 ; this bit clear: comparison_temp=1
>         goto done
>
>         movfw C
> done
>         endm
> --
> You think that it is a secret, but it never has been one.
>   - fortune cookie
>

>
> Hi Mark.
>
> You got the same idea as I got when looked at your first post
> ten minutes ago :) Shift all carries into temp first.
> Ok, here is straightforward coding.
>
>         movfw   fileC           ;1
>         subwf   fileB,w         ;2
>         rlf     temp,F          ;3
>
>         movfw   fileA           ;4
>         subwf   fileC,w         ;5
>         rlf     temp,F          ;6
>
>         movfw   fileB           ;7
>         subwf   fileA,w         ;8
>
> Indeed table is simmetrical, so we can reduce it by half
>
>   Cy  temp.1 temp.0
> > A>B | B>C | C>A | Choose
> > ----+-----+-----+--------

> >  1  |  1  |  0  | B
> >  1  |  0  |  0  | C
> >  0  |  1  |  0  | A
> >  0  |  1  |  1  | C
> >  1  |  0  |  1  | A
> >  0  |  0  |  1  | B
>
>         skpnc                   ;9
>         comf    temp,F          ;10
>
> > A>B | B>C | C>A | Choose
> > ----+-----+-----+--------
> >  0  |  1  |  0  | A
> >  0  |  1  |  1  | C
> >  0  |  0  |  1  | B

>
> Now let's decrement it by one
>
>         decf    temp,F          ;11
>
> > A>B | B>C | C>A | Choose
> > ----+-----+-----+--------
> >  0  |  0  |  1  | A
> >  0  |  1  |  0  | C
> >  0  |  0  |  0  | B

>         movfw   fileC           ;16
>
> Code hasn't been tested thought and looks like there should be way
> to squeeze it 4 instructions less :) Guess I'm getting old and lazy :)
>
> WBR Dmitry.
>
> PS.  Scott you always were good at finding bugs :)
>
> Mark Rages wrote:
> >
> > On 7/15/05, Mark Rages <.....markragesspam_OUTgmail.com> wrote:
> > > I'll post my solution in a minute, once I'm satisfied it works.
> >
> > Well, I think it's working and it's quitting time, so here goes:
> >
> > I started by listing all the possibilities:
> >
> > A > B > C choose B
> > A > C > B choose C
> > B > A > C choose A
> > B > C > A choose C
> > C > A > B choose A
> > C > B > A choose B
> >
> > I notice that there are really only three comparisons, if we ingnore
> > equality.  (After all, if A=B, it doesn't matter which I choose.)
> >
> > So I made a mapping from the comparison result to the choice:
> >
> > A>B | B>C | C>A | Choose
> > ----+-----+-----+--------
> >  1  |  1  |  0  | B
> >  1  |  0  |  0  | C
> >  0  |  1  |  0  | A
> >  0  |  1  |  1  | C
> >  1  |  0  |  1  | A
> >  0  |  0  |  1  | B
> >
> > Or, in decimal and numerical order:
> > comparison  | choose
> > ------------+--------
> >    0        | X
> >    1        | B
> >    2        | A
> >    3        | C
> >    4        | C
> >    5        | A
> >    6        | B
> >    7        | X
> >
> > But there's an interesting symmetry here: 3..0 is the same as 4..7.  This will
> > simplify my selection code.
> >
> > Here's my code.  I used one temp register for the comparison result.
> >
> > gteq macro fileA,fileB
> >         movfw fileB             ; w=B
> >         subwf fileA,w           ; w=A-B
> >         ;; if B>A we borrowed, so _borrow=0
> >         ;;  ... _borrow=1 means A>B or A==B
> >
> >         ;; Tack the result on the right of the comparison register.
> >         rlf iris_adc_temp,f     ; '1'-> A>=B
> >         endm
> >
> > abc_median macro A,B,C
> >         local done
> >
> >         clrf comparison_temp
> >
> >         ; do comparisons
> >         gteq A,B
> >         gteq B,C
> >         gteq C,A
> >
> >         ;; fold around 4
> >         movfw comparison_temp
> >         btfsc comparison_temp,2 ; is >=4?
> >         sublw 0x07              ; yes. 4->3,5->2,6->1,7->0
> >
> >         skpnz                   ; handle special case A=B=C
> >         movlw 0x01              ; in that case just choose any!
> >
> >         movwf comparison_temp
> >
> >         ; Now select from A,B,C like this:
> >         ;; 1 -> B
> >         ;; 2 -> A
> >         ;; 3 -> C
> >
> >         movfw A
> >         btfss comparison_temp,0 ; this bit clear: comparison_temp=2
> >         goto done
> >
> >         movfw B
> >         btfss comparison_temp,1 ; this bit clear: comparison_temp=1
> >         goto done
> >
> >         movfw C
> > done
> >         endm
> > --
> > You think that it is a secret, but it never has been one.
> >   - fortune cookie
> >
> > --

> Mark Rages wrote:
>
> >Here's a design challenge for you guys:
> >
> >I have values in three file registers:  fileA, fileB, fileC.
> >
> >I want to choose the value that's in the middle (numerically) and put it into W.
> >
> >The brute-force way to do this would be to copy the list, sort the
> >copy in place, and choose the middle value.
> >
> >I'm sure there's a more direct way.  Any ideas?
> >
> >(Application:  This a simple nonlinear filter to remove occasional
> >outliers in a sampled data stream.)
> >
> >Regards,
> >Mark
> >markrages@gmail
> >
> >
> Your clock is set to July 2005, Mark.
>

>
> John Nall wrote:
>
> >Howard Winter wrote:
> >
> >
> >>You aren't the only one - it arrived here a day or two ago, dated
> >>July. Either Mark's system re-sent it for some reason, or it's been
> >>hanging around on some street-corner of the Internet with its gang for
> >>the past 6 months..
> >>
> >>
> >
> >It arrived here only this morning (but dated July).  I always keep my
> >inbox on Thunderbird cleared after I have read the messages, either by
> >deleting the ones that have been read, or by moving them to another
> >folder.  So it definitely popped into the inbox just this morning.
> >Wonder where that puppy has been hanging out???  :-)
> >
> >
> >
> Yes, it JUST arrived.
>
> Homeland security up to their old tricks again, I guess. They delayed
> some encrypted
> firmware code for 6 weeks once.
>
> --Bob
>
> --
> Note: To protect our network,
> attachments must be sent to
> spamBeGoneattach@spam@spam_OUTengineer.cotse.net .
> 1-520-850-1673 USA/Canada
> http://beam.to/azengineer
>

> I don't think there's a cunning way to do it.  It demands a minimum of 2
> comparisons, max 3. Sorting 4 or more you'd want to use a function call or
> you'd have a lot of messy and confusing code (this is confusing enough).
> Best pseudo code I can do:
>
>                   IF B >= A GOTO BA
>                   IF C >= A GOTO A                ; A > B if C >= A then C
>  >= A > B
>                   IF C >= B GOTO C                ; A > B and A > C if C >=
> B  then A > C >= B
>                                                                   ; A > B, A
>  > C and B > C therefore A > B > C
> B               ANSWER B
>                   GOTO END
> BA             IF C >= A GOTO BACA        ; B >= A
>                                                                   ; B >= A >
> C
> A               ANSWER A
>                   GOTO END
> BACA       IF C >= B GOTO B                 ; B > A, C > A if C >= B then C
>  >= B > A
>                                                                   ; B > A, C
>  > A and B > C therefore B > C > A
> C               ANSWER C
> END
>

>
> On 1/19/06, Bob Axtell <RemoveMEengineerEraseMEspam_OUTcotse.net> wrote:
> > Mark Rages wrote:
> >
> > >Here's a design challenge for you guys:
> > >
> > >I have values in three file registers:  fileA, fileB, fileC.
> > >
> > >I want to choose the value that's in the middle (numerically) and put it into W.
> > >
> > >The brute-force way to do this would be to copy the list, sort the
> > >copy in place, and choose the middle value.
> > >
> > >I'm sure there's a more direct way.  Any ideas?
> > >
> > >(Application:  This a simple nonlinear filter to remove occasional
> > >outliers in a sampled data stream.)
> > >
> > >Regards,
> > >Mark
> > >markrages@gmail
> > >
> > >
> > Your clock is set to July 2005, Mark.
> >
>
> It's an old thread.  The application I referred to is in full
> production right now.
>
> Regards,
> Mark