[racket] Looping with look-behind and look-forward

If you are only using integers, efficiency matters, and your running averages are larger than two (I can't tell of you are using three for a simple example, or if that is the only requirement), then it might be better to maintain the latest sum by subtracting the oldest member and adding the newest. If the processing time for the arithmetic is much smaller than the overhead of list maintenance, then this post isn't very useful.

rac  


On May 27, 2012, at 9:54 AM, Harry Spier wrote:

> Sorry Jens, I see I've just recreated the form you originally suggested.
> Thanks, Harry
> 
> On Sun, May 27, 2012 at 11:46 AM, Harry Spier <vasishtha.spier at gmail.com> wrote:
>> I think I've come up with a simpler form to do this.
>> 
>> (define (running-average-of-3 l)
>>   (for
>>    ( [prior (in-list l)]
>>      [x (in-list (rest l))]
>>      [next (in-list (rest (rest l)))])
>>   (displayln (/ (+ x prior next) 3))))
>> 
>> (running-average-of-3 '(1 2 3 4 5 6))
>> 
>> 
>> So I can do something like:
>> 
>> (define (f1 l)
>>   (for/fold ([result-list '()])
>>    ( [prior (in-list (append '() l))]
>>      [x (in-list l)]
>>      [next (in-list  (append (rest l) '()))])
>>    ...
>>    ... make new-result-element using x prior and next...
>>   (cons new-result-element result-list))
>>  (reverse result-list))
>> 
>> The list I'm working on in my application has about 40,000 sub-lists.
>> Will the compiler build new lists from scratch as the sequence for
>> prior and next in this code or will it use pointers to and from the
>> existing list l to do this?
>> 
>> Thanks,
>> Harry
>> 
>> On Sun, May 27, 2012 at 10:38 AM, Jens Axel Søgaard
>> <jensaxel at soegaard.net> wrote:
>>> 2012/5/27 Harry Spier <vasishtha.spier at gmail.com>:
>>>> Is the "for" form a macro?  And if so how difficult would it be to
>>>> make a new form "for-with-look-around" that had built in look-back and
>>>> look-ahead operators (next x) (prior x) (  next?) (prior?).
>>>> 
>>>> So you could do something like:
>>>> 
>>>> ((define (running-average-of-3 l)
>>>>   (for-with-look-around
>>>>    ([x (in-list l)])
>>>>    (unless? (or (prior?) (next?))
>>>>                 (displayln (/ (+ x (prior x) (next x)) 3))))))
>>>> 
>>>> From a functional programming perspective is building a form like this
>>>> a bad idea?
>>> 
>>> It is a fine idea.
>>> Here is variation on the idea.
>>> 
>>> (define (in-triples l)
>>>  (define (sublists xs)
>>>    (if (empty? xs)
>>>        '()
>>>        (cons xs (sublists (rest xs)))))
>>>  (define (triple xs) (take xs 3))
>>>  (sequence-map triple (drop-right (sublists l) 2)))
>>> 
>>> (define (running-average-of-3 l)
>>>  (for ([t (in-triples l)])
>>>    (match-define (list x y z) t)
>>>    (displayln (/ (+ x y z) 3))))
>>> 
>>> (running-average-of-3 '(1 2 3 4 5 6))
> 
> ____________________
>  Racket Users list:
>  http://lists.racket-lang.org/users