Is there a more efficient and/or idiomatic way in cl to do this:

(defun cumul (vctr)
(loop for j from 1 to (1- (length vctr))
do (setf (aref vctr j) (+ (aref vctr j) (aref vctr (1- j)))))
vctr
)

-JimC
--
James Cloos <cloos@jhcloos.com> OpenPGP: 0x997A9F17ED7DAEA6

On 2/16/2022, James Cloos wrote:

> Is there a more efficient and/or idiomatic way in cl to do this:
>
> (defun cumul (vctr)
> (loop for j from 1 to (1- (length vctr))
> do (setf (aref vctr j) (+ (aref vctr j) (aref vctr (1- j)))))
> vctr
> )

Gauche Scheme:

(define (cumul vec)
(vector-map-with-index!
(lambda (i el)
(if (zero? i)
el
(+ el (vector-ref vec (- i 1)))))
vec))

(define v (vector 2 3 4 5))
(cumul v)
v ===>
#(2 5 9 14)

On Wed, 16 Feb 2022 12:13:13 -0500
James Cloos <cloos@jhcloos.com> wrote:
> Is there a more efficient and/or idiomatic way in cl to do this:
>
> (defun cumul (vctr)
> (loop for j from 1 to (1- (length vctr))
> do (setf (aref vctr j) (+ (aref vctr j) (aref vctr (1- j)))))
> vctr
> )

I wouldn't say more idomatic but it is a bit shorter to write

(defun cumul2 (vctr)
(loop for j from 1 to (1- (length vctr))
do (incf (aref vctr j) (aref vctr (1- j))))
vctr)

; it saves you writing (aref vctr j) twice.

Any of the following 2 versions *may* be faster :

(defun cumul3 (vctr &aux (sum 0) (pos 0))
(map nil (lambda (el) (setf sum (+ sum el)
(aref vctr pos) sum pos (1+ pos)))
vctr)
vctr)

(defun cumul4 (vctr)
(do ((sum 0) (len (length vctr)) (pos 0 (1+ pos)))
((eql pos len) vctr)
(setf sum (+ sum (aref vctr pos)) (aref vctr pos) sum)))

--
To solve this problem, we define a security flag, known as the "evil"
bit, in the IPv4 [RFC791] header. Benign packets have this bit set to
0; those that are used for an attack will have the bit set to 1.
RFC 3514

On Wednesday, February 16, 2022 at 9:13:21 AM UTC-8, James Cloos wrote:
> Is there a more efficient and/or idiomatic way in cl to do this:
>
> (defun cumul (vctr)
> (loop for j from 1 to (1- (length vctr))
> do (setf (aref vctr j) (+ (aref vctr j) (aref vctr (1- j)))))
> vctr
> )

Not necessarily quite as clear, but this does get to use MAP-INTO:

(let ((last 0))
(map-into *v* #'(lambda (x) (setq last (+ x last))) *v*))

* Tom Russ <8f99f230-f0de-4373-a1ba-ec1074cda596n @googlegroups.com> :
Wrote on Thu, 17 Feb 2022 11:16:58 -0800 (PST):

> On Wednesday, February 16, 2022 at 9:13:21 AM UTC-8, James Cloos wrote:
>> Is there a more efficient and/or idiomatic way in cl to do this:
>>
>> (defun cumul (vctr)
>> (loop for j from 1 to (1- (length vctr))
>> do (setf (aref vctr j) (+ (aref vctr j) (aref vctr (1- j)))))
>> vctr
>> )
>
> Not necessarily quite as clear, but this does get to use MAP-INTO:
>
> (let ((last 0))
> (map-into *v* #'(lambda (x) (setq last (+ x last))) *v*))

the way to do cumul while keeping a running sum is just (reduce '+ list)

or (reduce (lambda (a b) (+ a b)) list)

but it loses the elegance when you have to mutate an array as a side effect

(let ((i -1))
(reduce (lambda (a b) (setf (aref v (incf i)) (+ a b)))
v
:initial-value 0))