mirror of
https://github.com/BelfrySCAD/BOSL2.git
synced 2025-01-01 09:49:45 +00:00
c10a8b919d
Here is an extensive review of common.scad, vectors.scad, arrays.scad and their regression test codes. The changes were mostly in input data check and format. Some few functions got more changes either to adapt them to the new asserts or because a better (faster, simpler) code was found. Another change was moving add_scalar from vectors.scad to arrays.scad. It is in fact an array operation. Some few documentation examples and test codes were added. Some function argument names were changed to keep them consistent with the names they have in other similar functions. That name changes were not as extensive as I would like but it is advisable to favor users. Most, but not all, changed function codes are followed by a comment with a short summary of the changes done. Those comments always start with: //*** I can eliminate those comments before a merge is done or in a second round.
461 lines
13 KiB
OpenSCAD
461 lines
13 KiB
OpenSCAD
include <../std.scad>
|
|
|
|
|
|
// Section: List Query Operations
|
|
|
|
module test_select() {
|
|
l = [3,4,5,6,7,8,9];
|
|
assert(select(l, 5, 6) == [8,9]);
|
|
assert(select(l, 5, 8) == [8,9,3,4]);
|
|
assert(select(l, 5, 2) == [8,9,3,4,5]);
|
|
assert(select(l, -3, -1) == [7,8,9]);
|
|
assert(select(l, 3, 3) == [6]);
|
|
assert(select(l, 4) == 7);
|
|
assert(select(l, -2) == 8);
|
|
assert(select(l, [1:3]) == [4,5,6]);
|
|
assert(select(l, [1,3]) == [4,6]);
|
|
}
|
|
test_select();
|
|
|
|
|
|
module test_slice() {
|
|
assert(slice([3,4,5,6,7,8,9], 3, 5) == [6,7]);
|
|
assert(slice([3,4,5,6,7,8,9], 2, -1) == [5,6,7,8,9]);
|
|
assert(slice([3,4,5,6,7,8,9], 1, 1) == []);
|
|
assert(slice([3,4,5,6,7,8,9], 6, -1) == [9]);
|
|
assert(slice([3,4,5,6,7,8,9], 2, -2) == [5,6,7,8]);
|
|
assert(slice([], 2, -2) == []);
|
|
}
|
|
test_slice();
|
|
|
|
|
|
module test_in_list() {
|
|
assert(in_list("bar", ["foo", "bar", "baz"]));
|
|
assert(!in_list("bee", ["foo", "bar", "baz"]));
|
|
assert(in_list("bar", [[2,"foo"], [4,"bar"], [3,"baz"]], idx=1));
|
|
assert(!in_list("bee", ["foo", "bar", ["bee"]]));
|
|
assert(in_list(NAN, [NAN])==false);
|
|
assert(!in_list(undef, [3,4,5]));
|
|
assert(in_list(undef,[3,4,undef,5]));
|
|
assert(!in_list(3,[]));
|
|
assert(!in_list(3,[4,5,[3]]));
|
|
}
|
|
test_in_list();
|
|
|
|
|
|
module test_min_index() {
|
|
assert(min_index([5,3,9,6,2,7,8,2,1])==8);
|
|
assert(min_index([5,3,9,6,2,7,8,2,7],all=true)==[4,7]);
|
|
// assert(min_index([],all=true)==[]);
|
|
}
|
|
test_min_index();
|
|
|
|
|
|
module test_max_index() {
|
|
assert(max_index([5,3,9,6,2,7,8,9,1])==2);
|
|
assert(max_index([5,3,9,6,2,7,8,9,7],all=true)==[2,7]);
|
|
// assert(max_index([],all=true)==[]);
|
|
}
|
|
test_max_index();
|
|
|
|
|
|
module test_list_increasing() {
|
|
assert(list_increasing([1,2,3,4]) == true);
|
|
assert(list_increasing([1,3,2,4]) == false);
|
|
assert(list_increasing([4,3,2,1]) == false);
|
|
}
|
|
test_list_increasing();
|
|
|
|
|
|
module test_list_decreasing() {
|
|
assert(list_decreasing([1,2,3,4]) == false);
|
|
assert(list_decreasing([4,2,3,1]) == false);
|
|
assert(list_decreasing([4,3,2,1]) == true);
|
|
}
|
|
test_list_decreasing();
|
|
|
|
// Section: Basic List Generation
|
|
|
|
module test_repeat() {
|
|
assert(repeat(1, 4) == [1,1,1,1]);
|
|
assert(repeat(8, [2,3]) == [[8,8,8], [8,8,8]]);
|
|
assert(repeat(0, [2,2,3]) == [[[0,0,0],[0,0,0]], [[0,0,0],[0,0,0]]]);
|
|
assert(repeat([1,2,3],3) == [[1,2,3], [1,2,3], [1,2,3]]);
|
|
assert(repeat(4, [2,-1]) == [[], []]);
|
|
}
|
|
test_repeat();
|
|
|
|
|
|
module test_list_range() {
|
|
assert(list_range(4) == [0,1,2,3]);
|
|
assert(list_range(n=4, step=2) == [0,2,4,6]);
|
|
assert(list_range(n=4, s=3, step=3) == [3,6,9,12]);
|
|
assert(list_range(e=3) == [0,1,2,3]);
|
|
assert(list_range(e=6, step=2) == [0,2,4,6]);
|
|
assert(list_range(s=3, e=5) == [3,4,5]);
|
|
assert(list_range(s=3, e=8, step=2) == [3,5,7]);
|
|
assert(list_range(s=4, e=8, step=2) == [4,6,8]);
|
|
assert(list_range(e=4, n=3) == [0,2,4]);
|
|
assert(list_range(n=4, s=[3,4], step=[2,3]) == [[3,4], [5,7], [7,10], [9,13]]);
|
|
}
|
|
test_list_range();
|
|
|
|
|
|
module test_reverse() {
|
|
assert(reverse([3,4,5,6]) == [6,5,4,3]);
|
|
assert(reverse("abcd") == ["d","c","b","a"]);
|
|
assert(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]);
|
|
assert(deduplicate("Hello") == ["H","e","l","o"]);
|
|
assert(deduplicate([[3,4],[7,1.99],[7,2],[1,4]],eps=0.1) == [[3,4],[7,2],[1,4]]);
|
|
assert(deduplicate([], closed=true) == []);
|
|
assert(deduplicate([[1,[1,[undef]]],[1,[1,[undef]]],[1,[2]],[1,[2,[0]]]])==[[1, [1,[undef]]],[1,[2]],[1,[2,[0]]]]);
|
|
}
|
|
test_deduplicate();
|
|
|
|
|
|
module test_deduplicate_indexed() {
|
|
assert(deduplicate_indexed([8,6,4,6,3], [1,4,3,1,2,2,0,1]) == [1,4,1,2,0,1]);
|
|
assert(deduplicate_indexed([8,6,4,6,3], [1,4,3,1,2,2,0,1], closed=true) == [1,4,1,2,0]);
|
|
}
|
|
test_deduplicate_indexed();
|
|
|
|
|
|
module test_list_set() {
|
|
assert(list_set([2,3,4,5], 2, 21) == [2,3,21,5]);
|
|
assert(list_set([2,3,4,5], [1,3], [81,47]) == [2,81,4,47]);
|
|
}
|
|
test_list_set();
|
|
|
|
|
|
module test_list_remove() {
|
|
assert(list_remove([3,6,9,12],1) == [3,9,12]);
|
|
assert(list_remove([3,6,9,12],[1,3]) == [3,9]);
|
|
}
|
|
test_list_remove();
|
|
|
|
|
|
module test_list_remove_values() {
|
|
animals = ["bat", "cat", "rat", "dog", "bat", "rat"];
|
|
assert(list_remove_values(animals, "rat") == ["bat","cat","dog","bat","rat"]);
|
|
assert(list_remove_values(animals, "bat", all=true) == ["cat","rat","dog","rat"]);
|
|
assert(list_remove_values(animals, ["bat","rat"]) == ["cat","dog","bat","rat"]);
|
|
assert(list_remove_values(animals, ["bat","rat"], all=true) == ["cat","dog"]);
|
|
assert(list_remove_values(animals, ["tucan","rat"], all=true) == ["bat","cat","dog","bat"]);
|
|
}
|
|
test_list_remove_values();
|
|
|
|
|
|
module test_list_insert() {
|
|
assert(list_insert([3,6,9,12],1,5) == [3,5,6,9,12]);
|
|
assert(list_insert([3,6,9,12],[1,3],[5,11]) == [3,5,6,9,11,12]);
|
|
}
|
|
test_list_insert();
|
|
|
|
|
|
module test_bselect() {
|
|
assert(bselect([3,4,5,6,7], [false,false,false,false,false]) == []);
|
|
assert(bselect([3,4,5,6,7], [false,true,true,false,true]) == [4,5,7]);
|
|
assert(bselect([3,4,5,6,7], [true,true,true,true,true]) == [3,4,5,6,7]);
|
|
}
|
|
test_bselect();
|
|
|
|
|
|
module test_list_bset() {
|
|
assert(list_bset([false,true,false,true,false], [3,4]) == [0,3,0,4,0]);
|
|
assert(list_bset([false,true,false,true,false], [3,4], dflt=1) == [1,3,1,4,1]);
|
|
}
|
|
test_list_bset();
|
|
|
|
|
|
module test_list_shortest() {
|
|
assert(list_shortest(["foobar", "bazquxx", "abcd"]) == 4);
|
|
}
|
|
test_list_shortest();
|
|
|
|
|
|
module test_list_longest() {
|
|
assert(list_longest(["foobar", "bazquxx", "abcd"]) == 7);
|
|
}
|
|
test_list_longest();
|
|
|
|
|
|
module test_list_pad() {
|
|
assert(list_pad([4,5,6], 5, 8) == [4,5,6,8,8]);
|
|
assert(list_pad([4,5,6,7,8], 5, 8) == [4,5,6,7,8]);
|
|
assert(list_pad([4,5,6,7,8,9], 5, 8) == [4,5,6,7,8,9]);
|
|
}
|
|
test_list_pad();
|
|
|
|
|
|
module test_list_trim() {
|
|
assert(list_trim([4,5,6], 5) == [4,5,6]);
|
|
assert(list_trim([4,5,6,7,8], 5) == [4,5,6,7,8]);
|
|
assert(list_trim([3,4,5,6,7,8,9], 5) == [3,4,5,6,7]);
|
|
}
|
|
test_list_trim();
|
|
|
|
|
|
module test_list_fit() {
|
|
assert(list_fit([4,5,6], 5, 8) == [4,5,6,8,8]);
|
|
assert(list_fit([4,5,6,7,8], 5, 8) == [4,5,6,7,8]);
|
|
assert(list_fit([3,4,5,6,7,8,9], 5, 8) == [3,4,5,6,7]);
|
|
}
|
|
test_list_fit();
|
|
|
|
|
|
module test_idx() {
|
|
colors = ["red", "green", "blue", "cyan"];
|
|
assert([for (i=idx(colors)) i] == [0,1,2,3]);
|
|
assert([for (i=idx(colors,end=-2)) i] == [0,1,2]);
|
|
assert([for (i=idx(colors,start=1)) i] == [1,2,3]);
|
|
assert([for (i=idx(colors,start=1,end=-2)) i] == [1,2]);
|
|
}
|
|
test_idx();
|
|
|
|
|
|
module test_enumerate() {
|
|
assert(enumerate(["a","b","c"]) == [[0,"a"], [1,"b"], [2,"c"]]);
|
|
assert(enumerate([[88,"a"],[76,"b"],[21,"c"]], idx=1) == [[0,"a"], [1,"b"], [2,"c"]]);
|
|
assert(enumerate([["cat","a",12],["dog","b",10],["log","c",14]], idx=[1:2]) == [[0,"a",12], [1,"b",10], [2,"c",14]]);
|
|
}
|
|
test_enumerate();
|
|
|
|
|
|
module test_shuffle() {
|
|
nums1 = [for (i=list_range(100)) i];
|
|
nums2 = shuffle(nums1);
|
|
nums3 = shuffle(nums2);
|
|
assert(len(nums2)==len(nums1));
|
|
assert(len(nums3)==len(nums2));
|
|
assert(nums1!=nums2);
|
|
assert(nums2!=nums3);
|
|
assert(nums1!=nums3);
|
|
}
|
|
test_shuffle();
|
|
|
|
|
|
module test_sort() {
|
|
assert(sort([7,3,9,4,3,1,8]) == [1,3,3,4,7,8,9]);
|
|
assert(sort(["cat", "oat", "sat", "bat", "vat", "rat", "pat", "mat", "fat", "hat", "eat"]) == ["bat", "cat", "eat", "fat", "hat", "mat", "oat", "pat", "rat", "sat", "vat"]);
|
|
assert(sort(enumerate([[2,3,4],[1,2,3],[2,4,3]]),idx=1)==[[1,[1,2,3]], [0,[2,3,4]], [2,[2,4,3]]]);
|
|
}
|
|
test_sort();
|
|
|
|
|
|
module test_sortidx() {
|
|
lst1 = ["d","b","e","c"];
|
|
assert(sortidx(lst1) == [1,3,0,2]);
|
|
lst2 = [
|
|
["foo", 88, [0,0,1], false],
|
|
["bar", 90, [0,1,0], true],
|
|
["baz", 89, [1,0,0], false],
|
|
["qux", 23, [1,1,1], true]
|
|
];
|
|
assert(sortidx(lst2, idx=1) == [3,0,2,1]);
|
|
assert(sortidx(lst2, idx=0) == [1,2,0,3]);
|
|
assert(sortidx(lst2, idx=[1,3]) == [3,0,2,1]);
|
|
lst3 = [[-4, 0, 0], [0, 0, -4], [0, -4, 0], [-4, 0, 0], [0, -4, 0], [0, 0, 4], [0, 0, -4], [0, 4, 0], [4, 0, 0], [0, 0, 4], [0, 4, 0], [4, 0, 0]];
|
|
assert(sortidx(lst3)==[0,3,2,4,1,6,5,9,7,10,8,11]);
|
|
}
|
|
test_sortidx();
|
|
|
|
module test_unique() {
|
|
assert(unique([]) == []);
|
|
assert(unique([8]) == [8]);
|
|
assert(unique([7,3,9,4,3,1,8]) == [1,3,4,7,8,9]);
|
|
}
|
|
test_unique();
|
|
|
|
|
|
module test_unique_count() {
|
|
assert_equal(
|
|
unique_count([3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,6]),
|
|
[[1,2,3,4,5,6,7,8,9],[2,2,4,1,3,2,1,1,3]]
|
|
);
|
|
assert_equal(
|
|
unique_count(["A","B","R","A","C","A","D","A","B","R","A"]),
|
|
[["A","B","C","D","R"],[5,2,1,1,2]]
|
|
);
|
|
}
|
|
test_unique_count();
|
|
|
|
|
|
|
|
// Sets
|
|
|
|
module test_set_union() {
|
|
assert_equal(
|
|
set_union([2,3,5,7,11], [1,2,3,5,8]),
|
|
[2,3,5,7,11,1,8]
|
|
);
|
|
assert_equal(
|
|
set_union([2,3,5,7,11], [1,2,3,5,8], get_indices=true),
|
|
[[5,0,1,2,6],[2,3,5,7,11,1,8]]
|
|
);
|
|
}
|
|
test_set_union();
|
|
|
|
|
|
module test_set_difference() {
|
|
assert_equal(
|
|
set_difference([2,3,5,7,11], [1,2,3,5,8]),
|
|
[7,11]
|
|
);
|
|
}
|
|
test_set_difference();
|
|
|
|
|
|
module test_set_intersection() {
|
|
assert_equal(
|
|
set_intersection([2,3,5,7,11], [1,2,3,5,8]),
|
|
[2,3,5]
|
|
);
|
|
}
|
|
test_set_intersection();
|
|
|
|
|
|
|
|
// Arrays
|
|
|
|
|
|
module test_add_scalar() {
|
|
assert(add_scalar([1,2,3],3) == [4,5,6]);
|
|
assert(add_scalar([[1,2,3],[3,4,5]],3) == [[4,5,6],[6,7,8]]);
|
|
}
|
|
test_add_scalar();
|
|
|
|
|
|
module test_subindex() {
|
|
v = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]];
|
|
assert(subindex(v,2) == [3, 7, 11, 15]);
|
|
assert(subindex(v,[2,1]) == [[3, 2], [7, 6], [11, 10], [15, 14]]);
|
|
assert(subindex(v,[1:3]) == [[2, 3, 4], [6, 7, 8], [10, 11, 12], [14, 15, 16]]);
|
|
}
|
|
test_subindex();
|
|
|
|
|
|
module test_force_list() {
|
|
assert_equal(force_list([3,4,5]), [3,4,5]);
|
|
assert_equal(force_list(5), [5]);
|
|
assert_equal(force_list(7, n=3), [7,7,7]);
|
|
assert_equal(force_list(4, n=3, fill=1), [4,1,1]);
|
|
}
|
|
test_force_list();
|
|
|
|
|
|
module test_pair() {
|
|
assert(pair([3,4,5,6]) == [[3,4], [4,5], [5,6]]);
|
|
assert(pair("ABCD") == [["A","B"], ["B","C"], ["C","D"]]);
|
|
}
|
|
test_pair();
|
|
|
|
|
|
module test_pair_wrap() {
|
|
assert(pair_wrap([3,4,5,6]) == [[3,4], [4,5], [5,6], [6,3]]);
|
|
assert(pair_wrap("ABCD") == [["A","B"], ["B","C"], ["C","D"], ["D","A"]]);
|
|
}
|
|
test_pair_wrap();
|
|
|
|
|
|
module test_triplet() {
|
|
assert(triplet([3,4,5,6,7]) == [[3,4,5], [4,5,6], [5,6,7]]);
|
|
assert(triplet("ABCDE") == [["A","B","C"], ["B","C","D"], ["C","D","E"]]);
|
|
}
|
|
test_triplet();
|
|
|
|
|
|
module test_triplet_wrap() {
|
|
assert(triplet_wrap([3,4,5,6]) == [[3,4,5], [4,5,6], [5,6,3], [6,3,4]]);
|
|
assert(triplet_wrap("ABCD") == [["A","B","C"], ["B","C","D"], ["C","D","A"], ["D","A","B"]]);
|
|
}
|
|
test_triplet_wrap();
|
|
|
|
|
|
module test_permute() {
|
|
assert(permute([3,4,5,6]) == [[3,4],[3,5],[3,6],[4,5],[4,6],[5,6]]);
|
|
assert(permute([3,4,5,6],n=3) == [[3,4,5],[3,4,6],[3,5,6],[4,5,6]]);
|
|
}
|
|
test_permute();
|
|
|
|
|
|
module test_repeat_entries() {
|
|
list = [0,1,2,3];
|
|
assert(repeat_entries(list, 6) == [0,0,1,2,2,3]);
|
|
assert(repeat_entries(list, 6, exact=false) == [0,0,1,1,2,2,3,3]);
|
|
assert(repeat_entries(list, [1,1,2,1], exact=false) == [0,1,2,2,3]);
|
|
}
|
|
test_repeat_entries();
|
|
|
|
|
|
module test_zip() {
|
|
v1 = [1,2,3,4];
|
|
v2 = [5,6,7];
|
|
v3 = [8,9,10,11];
|
|
assert(zip(v1,v3) == [[1,8],[2,9],[3,10],[4,11]]);
|
|
assert(zip([v1,v3]) == [[1,8],[2,9],[3,10],[4,11]]);
|
|
assert(zip([v1,v2],fit="short") == [[1,5],[2,6],[3,7]]);
|
|
assert(zip([v1,v2],fit="long") == [[1,5],[2,6],[3,7],[4,undef]]);
|
|
assert(zip([v1,v2],fit="long", fill=0) == [[1,5],[2,6],[3,7],[4,0]]);
|
|
assert(zip([v1,v2,v3],fit="long") == [[1,5,8],[2,6,9],[3,7,10],[4,undef,11]]);
|
|
}
|
|
test_zip();
|
|
|
|
|
|
module test_array_group() {
|
|
v = [1,2,3,4,5,6];
|
|
assert(array_group(v,2) == [[1,2], [3,4], [5,6]]);
|
|
assert(array_group(v,3) == [[1,2,3], [4,5,6]]);
|
|
assert(array_group(v,4,0) == [[1,2,3,4], [5,6,0,0]]);
|
|
}
|
|
test_array_group();
|
|
|
|
|
|
module test_flatten() {
|
|
assert(flatten([[1,2,3], [4,5,[6,7,8]]]) == [1,2,3,4,5,[6,7,8]]);
|
|
}
|
|
test_flatten();
|
|
|
|
|
|
module test_array_dim() {
|
|
assert(array_dim([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]) == [2,2,3]);
|
|
assert(array_dim([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]], 0) == 2);
|
|
assert(array_dim([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]], 2) == 3);
|
|
assert(array_dim([[[1,2,3],[4,5,6]],[[7,8,9]]]) == [2,undef,3]);
|
|
}
|
|
test_array_dim();
|
|
|
|
|
|
module test_transpose() {
|
|
assert(transpose([[1,2,3],[4,5,6],[7,8,9]]) == [[1,4,7],[2,5,8],[3,6,9]]);
|
|
assert(transpose([[1,2,3],[4,5,6]]) == [[1,4],[2,5],[3,6]]);
|
|
assert(transpose([3,4,5]) == [3,4,5]);
|
|
}
|
|
test_transpose();
|
|
|
|
|
|
cube();
|
|
|
|
|
|
// vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap
|