Dimension shiftable buffer
The DimensionShiftableBuffer
by this crate presents a dimension shiftable buffer feature.
What's the "dimension shiftable buffer"?
- First, a dimension "un-shiftable" buffer is a common buffer types such as:
[T;3]
= One datum, 3-fixed-dimension, buffer is allocated a single heap, elements placed on a sequential memory addresses.[[T;3]]
= 0..* data, 3-fixed-dimension, buffer is allocated a single heap, elements placed on a sequential memory addresses.Vec<T>
= 0..* data, 1-fiexed-dimension, buffer is allocated a single heap, elements placed on a sequential memory addresses.Vec<[T;3]>
= 0..* data, 3-fixed-dimension, buffer is allocated a single heap, elements placed on a sequential memory addresses.Vec<Vec<T>>
= 0..* data, 1..*-any-dimension, buffer is allocated a multiple heap, elements placed on a dispersed memory addresses.
- Then, a dimension "shiftable" buffer is:
DimensionShiftableBuffer<T>
= 0..* data, N-shiftable-dimension, buffer is allocated a single heap, elements places on a sequential memory addresses.- Has one buffer heap.
- Can access as N=1..* dimension view such as like a
[&[T;3]]
,[&mut [T;3]]
,[&[T;127]]
. - With only safe implementation.
Example
[]
= "*"
Example-1
A simple usages.
// make a 2d-empty DimensionShiftableBuffer
let mut dsb = new.unwrap;
// push a 2d-datum
dsb.push.unwrap;
// push a 2d-datum
dsb.push.unwrap;
// append a 2d-datum sequence
dsb.append.unwrap;
for index in 0..dsb.len.unwrap
// shift dimension to 3 from 2
dsb.shift_dimension.unwrap;
// push a 3d-datum
dsb.push.unwrap;
// get a 3d-datum
assert_eq!;
assert_eq!;
assert_eq!;
assert_eq!;
assert_eq!;
// get a linear slice
let linear_slice = dsb.as_slice;
assert_eq!;
Example-2
With an error handling.
use DimensionShiftableBuffer
// Index of 1D => 0 |1 |2 |3 |4 |5 |6 |7 |8 |
// Index of 2D => 0,0 0,1 |1,0 1,1 |2,0 2,1 |3,0 3,1 |4,0 4,1 |
// Index of 3D => 0,0 0,1 0,2 |1,0 1,1 1,2 |2,0 2,1 2,2 |
// Index of 7D => 0,0 0,1 0,2 0,3 0,4 0,5 0,6 |1,0 1,1 1,2 1,3 1,4 1,5 1,6 |
let entity = vec!;
let dimension = 1;
let mut dsb = new.unwrap;
let d1_i3 = dsb.get.unwrap;
assert_eq!;
dsb.shift_dimension.unwrap;
let d3_i2 = dsb.get.unwrap;
assert_eq!;
match dsb.shift_dimension
dsb.shift_dimension_truncate.unwrap;
let d2_i1 = dsb.get.unwrap;
assert_eq!;
dsb.shift_dimension_padding.unwrap;
let d7_i1 = dsb.get.unwrap;
assert_eq!
Example-3
Additional feature="csv" (default).; CSV=Character-Separated-Values, also known as DSV or TSV.
let delimiter = " ";
let source = "0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0";
let dimension = 3;
// construct
let mut dsb = DimensionShiftableBuffer::<f32>::from_csv(source, dimension, delimiter).unwrap();
// modify-1
dsb.for_each(|v| *v += 0.1);
// modify-2
for n in 0..dsb.len().unwrap()
{
for v in dsb.get_mut(n).unwrap()
{
*v *= *v;
}
}
// show
eprintln!("{:?}", dsb);
// enumerate
for i in 0..18
// maybe, 0..5 will ok, 6..18 will err
{
match dsb.get(i)
{
Ok(dimensional_elements) =>
{
for (i_sub, actual) in dimensional_elements.iter().enumerate()
{
let i_flatten = i * dimension as usize + i_sub;
let expected = (i_flatten as f32 + 0.1) * (i_flatten as f32 + 0.1);
assert_eq!(actual, &expected);
}
},
Err(e) =>
{
match e
{
DimensionShiftableBufferError::OutOfRange {
limit: _,
requested: _
} => (),
_ => panic!("unexpected err: {:?}", e)
}
},
}
}
println!("<<print CSV, as a sequential slice>>\n{}", dsb.to_csv(", "));
println!(
"<<print CSV, as a dimmensional slices>>\n{}",
dsb.to_csv_dimensional(", ", "\n").unwrap()
);
<<print 0.010000001, 1.21, 4.4099994, 9.61, 16.81, 26.009998, 37.21, 50.41, 65.61001, 82.810005, 102.01001, 123.21001, 146.41, 171.61002, 198.81001, 228.01001, 259.21002, 292.41
<<print CSV, as a dimmensional slices>>
0.010000001, 1.21, 4.4099994
9.61, 16.81, 26.009998
37.21, 50.41, 65.61001
82.810005, 102.01001, 123.21001
146.41, 171.61002, 198.81001
228.01001, 259.21002, 292.41