Hi all
Imagine you have a big array and that you want to process it by little
pieces.
One solution would be to make a new array which is displaced to another,
and that would be great because you don't use up memory space for
nothing, since you donc copy the elements.
However imagine, that your process can only handle simple-arrays. Then,
using cmucl as I do, this small array can't be displaced-to anymore
since it would transform it to a vector. Using subseq is then what I do,
but it takes a lot of space.
One would say "why not give as parameter to the processing funtion the
big array and an offset ?"
Well, I don't really like this, it doesn't feel the write way to do it
to me.
So am I wrong with this or is there another solution, ie having a kind
of displaced-to array that would be a simple-array ?
Thanx for any answer...
Martin
Martin Raspaud <··············@wanadoo.fr> writes:
> So am I wrong with this or is there another solution
I'd say you have unreasonable restrictions here. If you want to be
able to efficiently process portions of large arrays, use start/end
args. Otherwise, you can use displaced arrays, but then you have to
remove the simple-array restriction on your utility functions. If you
write them so they expect a simple array, *and* they don't take bounds
arguments, they're badly written for your purpose.
> , ie having a kind
> of displaced-to array that would be a simple-array ?
No, that's exactly the distinction between the types ARRAY and
SIMPLE-ARRAY: a SIMPLE-ARRAY has no fill-pointer, and is not
displaced. This lets the implementation do more efficient access.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
Martin Raspaud <··············@wanadoo.fr> writes:
> One would say "why not give as parameter to the processing funtion the
> big array and an offset ?"
> Well, I don't really like this, it doesn't feel the write way to do it
> to me.
Incidentally, if you just don't like having to pass three args to your
processing functions, you could wrap it all up in a class:
(defclass darray ()
((array :initarg displaced-to)
(start :initarg start)
(end :initarg end)))
(defun consumer (darray)
(with-slots (array start end) darray
(declare (type <x> array))
(loop for i from start below end
...)))
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
On 2004-01-17, Martin Raspaud <··············@wanadoo.fr> wrote:
|
| One would say "why not give as parameter to the processing funtion the
| big array and an offset ?"
| Well, I don't really like this, it doesn't feel the write way to do it
| to me.
Why not? This is how sequence functions like find, replace, remove,
etc. handle this situation, by using optional :start and :end
arguments.
--
Cliff Crawford *** ·····@cornell.edu
"In theory there is no difference between theory and practice.
In practice there is." -- Yogi Berra
* Martin Raspaud
| One would say "why not give as parameter to the processing funtion
| the big array and an offset ?" Well, I don't really like this, it
| doesn't feel the right way to do it to me.
|
| So am I wrong with this or is there another solution, ie having a kind
| of displaced-to array that would be a simple-array ?
One common optimization when working with non-simple arrays is to
dig out the underlying simple-array and the start and end positions
that a displaced array makes into one convenient object.
The function ARRAY-DISPLACEMENT returns the values of the arguments
:DISPLACED-TO and and :DISPLACED-INDEX-OFFSETgiven to MAKE-ARRAY or
ADJUST-ARRAY, or NIL and 0 if it was not displaced.
(defun undisplace-array (array)
"Return the fundamental array and the start and end positions into
it of a displaced array."
(let ((length (length array))
(start 0))
(loop
(multiple-value-bind (to offset) (array-displacement array)
(if to
(setq array to
start (+ start offset))
(return (values array start (+ start length))))))))
--
Erik Naggum | Oslo, Norway
Act from reason, and failure makes you rethink and study harder.
Act from faith, and failure makes you blame someone and push harder.
Erik Naggum wrote:
> * Martin Raspaud
> | One would say "why not give as parameter to the processing funtion
> | the big array and an offset ?" Well, I don't really like this, it
> | doesn't feel the right way to do it to me.
> |
> | So am I wrong with this or is there another solution, ie having a kind
> | of displaced-to array that would be a simple-array ?
>
> One common optimization when working with non-simple arrays is to
> dig out the underlying simple-array and the start and end positions
> that a displaced array makes into one convenient object.
>
> The function ARRAY-DISPLACEMENT returns the values of the arguments
> :DISPLACED-TO and and :DISPLACED-INDEX-OFFSETgiven to MAKE-ARRAY or
> ADJUST-ARRAY, or NIL and 0 if it was not displaced.
>
[snip]
This is, incidentally, how f2cl (Fortran-to-Lisp converter) handles
Fortran arrays. For speed, you want specialized arrays. However, in
Fortran, when you call a routine with a slice of an array, f2cl uses a
displaced array. The called routine then uses array-displacement as
many times as needed to find the original array, which is a specialized
array.
This isn't as good a Fortran, but it does get as close as possible.
Ray