mirror of
https://github.com/revarbat/BOSL2.git
synced 2025-01-16 13:50:23 +01:00
Added list_rotate() and a bunch of assert()s
This commit is contained in:
Revar Desmera
parent
e064db6b14
commit
b0cdbcca0a
69
arrays.scad
69
arrays.scad
@ -153,7 +153,35 @@ function list_range(n=undef, s=0, e=undef, step=undef) =
|
||||
// list = The list to reverse.
|
||||
// Example:
|
||||
// reverse([3,4,5,6]); // Returns [6,5,4,3]
|
||||
function reverse(list) = [ for (i = [len(list)-1 : -1 : 0]) list[i] ];
|
||||
function reverse(list) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
[ for (i = [len(list)-1 : -1 : 0]) list[i] ];
|
||||
|
||||
|
||||
// Function: list_rotate()
|
||||
// Usage:
|
||||
// rlist = list_rotate(list,n);
|
||||
// Description:
|
||||
// Rotates the contents of a list by `n` positions left.
|
||||
// If `n` is negative, then the rotation is `abs(n)` positions to the right.
|
||||
// Arguments:
|
||||
// list = The list to rotate.
|
||||
// n = The number of positions to rotate by. If negative, rotated to the right. Positive rotates to the left. Default: 1
|
||||
// Example:
|
||||
// l1 = list_rotate([1,2,3,4,5],-2); // Returns: [4,5,1,2,3]
|
||||
// l2 = list_rotate([1,2,3,4,5],-1); // Returns: [5,1,2,3,4]
|
||||
// l3 = list_rotate([1,2,3,4,5],0); // Returns: [1,2,3,4,5]
|
||||
// l4 = list_rotate([1,2,3,4,5],1); // Returns: [2,3,4,5,1]
|
||||
// l5 = list_rotate([1,2,3,4,5],2); // Returns: [3,4,5,1,2]
|
||||
// l6 = list_rotate([1,2,3,4,5],3); // Returns: [4,5,1,2,3]
|
||||
// l7 = list_rotate([1,2,3,4,5],4); // Returns: [5,1,2,3,4]
|
||||
// l8 = list_rotate([1,2,3,4,5],5); // Returns: [1,2,3,4,5]
|
||||
// l9 = list_rotate([1,2,3,4,5],6); // Returns: [2,3,4,5,1]
|
||||
function list_rotate(list,n=1) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
assert(is_num(n))
|
||||
let(n = posmod(n,len(list)))
|
||||
n==0? list : concat(select(list,n,-1), select(list,0,n-1));
|
||||
|
||||
|
||||
// Function: deduplicate()
|
||||
@ -172,6 +200,7 @@ function reverse(list) = [ for (i = [len(list)-1 : -1 : 0]) list[i] ];
|
||||
// deduplicate("Hello"); // Returns: ["H","e","l","o"]
|
||||
// deduplicate([[3,4],[7,2],[7,1.99],[1,4]],eps=0.1); // Returns: [[3,4],[7,2],[1,4]]
|
||||
function deduplicate(list, closed=false, eps=EPSILON) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
let(
|
||||
l = len(list),
|
||||
end = l-(closed?0:1)
|
||||
@ -201,6 +230,7 @@ function deduplicate(list, closed=false, eps=EPSILON) =
|
||||
// list_set([2,3,4,5], 2, 21); // Returns: [2,3,21,5]
|
||||
// list_set([2,3,4,5], [1,3], [81,47]); // Returns: [2,81,4,47]
|
||||
function list_set(list=[],indices,values,dflt=0,minlen=0) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
!is_list(indices)? (
|
||||
(is_num(indices) && indices<len(list))? [for (i=idx(list)) i==indices? values : list[i]] :
|
||||
list_set(list,[indices],[values],dflt)
|
||||
@ -237,6 +267,7 @@ function list_set(list=[],indices,values,dflt=0,minlen=0) =
|
||||
// list_insert([3,6,9,12],1); // Returns: [3,9,12]
|
||||
// list_insert([3,6,9,12],[1,3]); // Returns: [3,9]
|
||||
function list_remove(list, elements) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
!is_list(elements) ? list_remove(list,[elements]) :
|
||||
len(elements)==0 ? list :
|
||||
let(
|
||||
@ -268,7 +299,7 @@ function list_remove(list, elements) =
|
||||
// domestic = list_remove_values(animals, ["bat","rat"], all=true); // Returns: ["cat","dog"]
|
||||
// animals4 = list_remove_values(animals, ["tucan","rat"], all=true); // Returns: ["bat","cat","dog","bat"]
|
||||
function list_remove_values(list,values=[],all=false) =
|
||||
assert(is_list(list))
|
||||
assert(is_list(list)||is_string(list))
|
||||
!is_list(values)? list_remove_values(list, values=[values], all=all) :
|
||||
let(
|
||||
idxs = all? flatten(search(values,list,0)) : search(values,list,1),
|
||||
@ -285,6 +316,7 @@ function list_remove_values(list,values=[],all=false) =
|
||||
// list_insert([3,6,9,12],1,5); // Returns [3,5,6,9,12]
|
||||
// list_insert([3,6,9,12],[1,3],[5,11]); // Returns [3,5,6,9,11,12]
|
||||
function list_insert(list, pos, elements, _i=0) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
is_list(pos)? (
|
||||
assert(len(pos)==len(elements))
|
||||
let(
|
||||
@ -322,6 +354,8 @@ function list_insert(list, pos, elements, _i=0) =
|
||||
// Example:
|
||||
// bselect([3,4,5,6,7], [false,true,true,false,true]); // Returns: [4,5,7]
|
||||
function bselect(array,index) =
|
||||
assert(is_list(array)||is_string(list))
|
||||
assert(is_list(index))
|
||||
[for(i=[0:len(array)-1]) if (index[i]) array[i]];
|
||||
|
||||
|
||||
@ -341,6 +375,8 @@ function bselect(array,index) =
|
||||
// list_bset([false,true,false,true,false], [3,4]); // Returns: [0,3,0,4,0]
|
||||
// list_bset([false,true,false,true,false], [3,4],dflt=1); // Returns: [1,3,1,4,1]
|
||||
function list_bset(indexset, valuelist, dflt=0) =
|
||||
assert(is_list(indexset))
|
||||
assert(is_list(valuelist))
|
||||
let(
|
||||
trueind = search([true], indexset,0)[0]
|
||||
) concat(
|
||||
@ -358,7 +394,8 @@ function list_bset(indexset, valuelist, dflt=0) =
|
||||
// list_increasing([1,2,3,4]); // Returns: true
|
||||
// list_increasing([1,3,2,4]); // Returns: false
|
||||
// list_increasing([4,3,2,1]); // Returns: false
|
||||
function list_increasing(list,ind=0) =
|
||||
function list_increasing(list) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
len([for (p=pair(list)) if(p.x>p.y) true])==0;
|
||||
|
||||
|
||||
@ -372,6 +409,7 @@ function list_increasing(list,ind=0) =
|
||||
// list_decreasing([4,2,3,1]); // Returns: false
|
||||
// list_decreasing([4,3,2,1]); // Returns: true
|
||||
function list_decreasing(list) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
len([for (p=pair(list)) if(p.x<p.y) true])==0;
|
||||
|
||||
|
||||
@ -381,6 +419,7 @@ function list_decreasing(list) =
|
||||
// Arguments:
|
||||
// vecs = A list of lists.
|
||||
function list_shortest(vecs) =
|
||||
assert(is_list(vecs)||is_string(list))
|
||||
min([for (v = vecs) len(v)]);
|
||||
|
||||
|
||||
@ -390,6 +429,7 @@ function list_shortest(vecs) =
|
||||
// Arguments:
|
||||
// vecs = A list of lists.
|
||||
function list_longest(vecs) =
|
||||
assert(is_list(vecs)||is_string(list))
|
||||
max([for (v = vecs) len(v)]);
|
||||
|
||||
|
||||
@ -401,6 +441,7 @@ function list_longest(vecs) =
|
||||
// minlen = The minimum length to pad the list to.
|
||||
// fill = The value to pad the list with.
|
||||
function list_pad(v, minlen, fill=undef) =
|
||||
assert(is_list(v)||is_string(list))
|
||||
concat(v,replist(fill,minlen-len(v)));
|
||||
|
||||
|
||||
@ -411,6 +452,7 @@ function list_pad(v, minlen, fill=undef) =
|
||||
// v = A list.
|
||||
// minlen = The minimum length to pad the list to.
|
||||
function list_trim(v, maxlen) =
|
||||
assert(is_list(v)||is_string(list))
|
||||
[for (i=[0:1:min(len(v),maxlen)-1]) v[i]];
|
||||
|
||||
|
||||
@ -423,6 +465,7 @@ function list_trim(v, maxlen) =
|
||||
// minlen = The minimum length to pad the list to.
|
||||
// fill = The value to pad the list with.
|
||||
function list_fit(v, length, fill) =
|
||||
assert(is_list(v)||is_string(list))
|
||||
let(l=len(v)) (l==length)? v : (l>length)? list_trim(v,length) : list_pad(v,length,fill);
|
||||
|
||||
|
||||
@ -441,6 +484,7 @@ function list_fit(v, length, fill) =
|
||||
// colors = ["red", "green", "blue"];
|
||||
// for (i=idx(colors)) right(20*i) color(colors[i]) circle(d=10);
|
||||
function idx(list, step=1, end=-1,start=0) =
|
||||
assert(is_list(list)||is_string(list))
|
||||
[start : step : len(list)+end];
|
||||
|
||||
|
||||
@ -459,6 +503,7 @@ function idx(list, step=1, end=-1,start=0) =
|
||||
// colors = ["red", "green", "blue"];
|
||||
// for (p=enumerate(colors)) right(20*p[0]) color(p[1]) circle(d=10);
|
||||
function enumerate(l,idx=undef) =
|
||||
assert(is_list(l)||is_string(list))
|
||||
(idx==undef)?
|
||||
[for (i=[0:1:len(l)-1]) [i,l[i]]] :
|
||||
[for (i=[0:1:len(l)-1]) concat([i], [for (j=idx) l[i][j]])];
|
||||
@ -468,6 +513,7 @@ function enumerate(l,idx=undef) =
|
||||
// Description:
|
||||
// Shuffles the input list into random order.
|
||||
function shuffle(list) =
|
||||
assert(is_list(l)||is_string(list))
|
||||
len(list)<=1 ? list :
|
||||
let (
|
||||
rval = rands(0,1,len(list)),
|
||||
@ -688,6 +734,7 @@ function sortidx(list, idx=undef) =
|
||||
// Arguments:
|
||||
// arr = The list to uniquify.
|
||||
function unique(arr) =
|
||||
assert(is_list(arr)||is_string(list))
|
||||
len(arr)<=1? arr : let(
|
||||
sorted = sort(arr)
|
||||
) [
|
||||
@ -728,7 +775,9 @@ function subindex(v, idx) = [
|
||||
// Example:
|
||||
// l = ["A","B","C",D"];
|
||||
// echo([for (p=pair(l)) str(p.y,p.x)]); // Outputs: ["BA", "CB", "DC"]
|
||||
function pair(v) = [for (i=[0:1:len(v)-2]) [v[i],v[i+1]]];
|
||||
function pair(v) =
|
||||
assert(is_list(v)||is_string(v))
|
||||
[for (i=[0:1:len(v)-2]) [v[i],v[i+1]]];
|
||||
|
||||
|
||||
// Function: pair_wrap()
|
||||
@ -739,7 +788,9 @@ function pair(v) = [for (i=[0:1:len(v)-2]) [v[i],v[i+1]]];
|
||||
// Example:
|
||||
// l = ["A","B","C","D"];
|
||||
// echo([for (p=pair_wrap(l)) str(p.y,p.x)]); // Outputs: ["BA", "CB", "DC", "AD"]
|
||||
function pair_wrap(v) = [for (i=[0:1:len(v)-1]) [v[i],v[(i+1)%len(v)]]];
|
||||
function pair_wrap(v) =
|
||||
assert(is_list(v)||is_string(v))
|
||||
[for (i=[0:1:len(v)-1]) [v[i],v[(i+1)%len(v)]]];
|
||||
|
||||
|
||||
// Function: triplet()
|
||||
@ -750,7 +801,9 @@ function pair_wrap(v) = [for (i=[0:1:len(v)-1]) [v[i],v[(i+1)%len(v)]]];
|
||||
// Example:
|
||||
// l = ["A","B","C","D","E"];
|
||||
// echo([for (p=triplet(l)) str(p.z,p.y,p.x)]); // Outputs: ["CBA", "DCB", "EDC"]
|
||||
function triplet(v) = [for (i=[0:1:len(v)-3]) [v[i],v[i+1],v[i+2]]];
|
||||
function triplet(v) =
|
||||
assert(is_list(v)||is_string(v))
|
||||
[for (i=[0:1:len(v)-3]) [v[i],v[i+1],v[i+2]]];
|
||||
|
||||
|
||||
// Function: triplet_wrap()
|
||||
@ -761,7 +814,9 @@ function triplet(v) = [for (i=[0:1:len(v)-3]) [v[i],v[i+1],v[i+2]]];
|
||||
// Example:
|
||||
// l = ["A","B","C","D"];
|
||||
// echo([for (p=triplet_wrap(l)) str(p.z,p.y,p.x)]); // Outputs: ["CBA", "DCB", "ADC", "BAD"]
|
||||
function triplet_wrap(v) = [for (i=[0:1:len(v)-1]) [v[i],v[(i+1)%len(v)],v[(i+2)%len(v)]]];
|
||||
function triplet_wrap(v) =
|
||||
assert(is_list(v)||is_string(v))
|
||||
[for (i=[0:1:len(v)-1]) [v[i],v[(i+1)%len(v)],v[(i+2)%len(v)]]];
|
||||
|
||||
|
||||
// Function: zip()
|
||||
|
||||
@ -65,6 +65,21 @@ module test_reverse() {
|
||||
test_reverse();
|
||||
|
||||
|
||||
module test_list_rotate() {
|
||||
assert(list_rotate([1,2,3,4,5],-2) == [4,5,1,2,3]);
|
||||
assert(list_rotate([1,2,3,4,5],-1) == [5,1,2,3,4]);
|
||||
assert(list_rotate([1,2,3,4,5],0) == [1,2,3,4,5]);
|
||||
assert(list_rotate([1,2,3,4,5],1) == [2,3,4,5,1]);
|
||||
assert(list_rotate([1,2,3,4,5],2) == [3,4,5,1,2]);
|
||||
assert(list_rotate([1,2,3,4,5],3) == [4,5,1,2,3]);
|
||||
assert(list_rotate([1,2,3,4,5],4) == [5,1,2,3,4]);
|
||||
assert(list_rotate([1,2,3,4,5],5) == [1,2,3,4,5]);
|
||||
assert(list_rotate([1,2,3,4,5],6) == [2,3,4,5,1]);
|
||||
assert(list_rotate([],3) == []);
|
||||
}
|
||||
test_list_rotate();
|
||||
|
||||
|
||||
module test_deduplicate() {
|
||||
assert(deduplicate([8,3,4,4,4,8,2,3,3,8,8]) == [8,3,4,8,2,3,8]);
|
||||
assert(deduplicate(closed=true, [8,3,4,4,4,8,2,3,3,8,8]) == [8,3,4,8,2,3]);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user