*ar { arg numChans = 4, inArray, spread = 1, level = 1, width = 2, center = 0.0, orientation = 0.5, levelComp = true;
    var n = max(1, inArray.size);
    var pos = if(n == 1) { 0 } { [ center - spread, center + spread ].resamp1(n) };
    if (levelComp) { level = level * n.reciprocal.sqrt };
    ^PanAz.ar(numChans, inArray, pos, level, width, orientation).flop.collect(Mix(_))
}

and:

resamp1 { arg newSize;
    var factor = this.size - 1 / (newSize - 1).max(1);
        ^this.species.fill(newSize, { |i| this.blendAt(i * factor) })
    }

I think that "center" instead of "0" would be a good solution, to allow the user to move the source:

var pos = if(n == 1) { center } { [ center - spread, center + spread ].resamp1(n) };

I think also that would be good to inform the user that, when spread=1, array[0] is moved to channel= (numChans/2) counterclockwise.

Good idea, yes.

the fix does not look good to me: especially, it introduces a possible division by zero in the resamp functions when passing a newSize of 1. it is probably better to define the semantics of resampling to one element as single-element collection with the mean of the collection. something like:

   resamp1 { arg newSize;
    if (newSize == 1) {
      ^this.species.fill(1, this.mean)
    } {       
      var factor = this.size - 1 / (newSize - 1);
      ^this.species.fill(newSize, { |i| this.blendAt(i * factor) })
  }

This could solve also the thread "SequenceableCollection resamp0/1
broken (e.g. SplayAz) #727"

It is true that:

[1,6,7].resamp1(4).mean
[1,6,7].mean

return the same values, and if we set newSize= "high number", the result
is subject to little approximation. So probably the Tim's solution is
very good to solve two issues.

Luca

On 15/03/14 16:51, Tim Blechmann wrote:

the fix does not look good to me: especially, it introduces a possible
division by zero in the resamp functions when passing a |newSize| of
|1|. it is probably better to define the semantics of resampling to
one element as single-element collection with the mean of the
collection. something like:

| resamp1 { arg newSize;
if (newSize == 1) {
^this.species.fill(1, this.mean)
} {
var factor = this.size - 1 / (newSize - 1);
^this.species.fill(newSize, { |i| this.blendAt(i * factor) })
}
|

—
Reply to this email directly or view it on GitHub
#1045 (comment).

I was thinking along the same lines. It isn't entirely clear though if you think about it, because resamp1 leaves the first element in a collection unchanged, irrespective of the new size.

[1, 2, 3, 100].resamp1(2)
[1, 2, 3, 100].resamp1(5)

Now whether that is right or not is another question, but it is a conscious decision of how to think about boundaries when you interpolate. The fix I committed sticks to the conventions so far, perhaps an argument could be added that specifies of how to deal with the boundaries in general (not only for n=1).

the fix does not look good to me: especially, it introduces a possible division by zero in the resamp functions when passing a newSize of 1.

resamp1 { arg newSize;
        var factor = this.size - 1 / (newSize - 1).max(1);
        ^this.species.fill(newSize, { |i| this.blendAt(i * factor) })
    }

Will never have a division by zero.

sry ... diffed in reverse ...

3 resampling to one element will have 3 different possibilities:

• the first element
• the mean of first and second element
• the mean of all elements.

for resamp0, one should probably use the first, for resamp1, i tend to prefer the third option, though no strong preference ...

So how would that be for n -> 1 elements?
The mean of all? Only the first? Only the first and second?
Those options seem not really convincing, I agree.
And what when we resample n -> melements?
Even more complicated.