mulimoen
/
SummationByParts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ensure FastFloat flag works

This commit is contained in:
Magnus Ulimoen 2021-02-01 23:13:10 +01:00
parent 6f7268bf33
commit 299b4f8083
7 changed files with 24 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
sbp/src/operators/algos.rs
View File

@ -31,18 +31,14 @@ impl<const B: usize> DiagonalMatrix<B> {
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct BlockMatrix<const M: usize, const N: usize, const D: usize> {
pub start: Matrix<Float, M, N>,
pub diag: RowVector<Float, D>,
pub end: Matrix<Float, M, N>,
pub(crate) struct BlockMatrix<T, const M: usize, const N: usize, const D: usize> {
pub start: Matrix<T, M, N>,
pub diag: RowVector<T, D>,
pub end: Matrix<T, M, N>,
}
impl<const M: usize, const N: usize, const D: usize> BlockMatrix<M, N, D> {
pub const fn new(
start: Matrix<Float, M, N>,
diag: RowVector<Float, D>,
end: Matrix<Float, M, N>,
) -> Self {
impl<T, const M: usize, const N: usize, const D: usize> BlockMatrix<T, M, N, D> {
pub const fn new(start: Matrix<T, M, N>, diag: RowVector<T, D>, end: Matrix<T, M, N>) -> Self {
Self { start, diag, end }
}
}
@ -57,7 +53,7 @@ pub(crate) enum OperatorType {
#[inline(always)]
/// Works on all 1d vectors
pub(crate) fn diff_op_1d_fallback<const M: usize, const N: usize, const D: usize>(
matrix: &BlockMatrix<M, N, D>,
matrix: &BlockMatrix<Float, M, N, D>,
optype: OperatorType,
prev: ArrayView1<Float>,
mut fut: ArrayViewMut1<Float>,
@ -106,7 +102,7 @@ pub(crate) fn diff_op_1d_fallback<const M: usize, const N: usize, const D: usize
#[inline(always)]
/// diff op in 1d for slices
pub(crate) fn diff_op_1d_slice<const M: usize, const N: usize, const D: usize>(
matrix: &BlockMatrix<M, N, D>,
matrix: &BlockMatrix<Float, M, N, D>,
optype: OperatorType,
prev: &[Float],
fut: &mut [Float],
@ -181,7 +177,7 @@ pub(crate) fn diff_op_1d_slice<const M: usize, const N: usize, const D: usize>(
#[inline(always)]
/// Will always work on 1d, delegated based on slicedness
pub(crate) fn diff_op_1d<const M: usize, const N: usize, const D: usize>(
matrix: &BlockMatrix<M, N, D>,
matrix: &BlockMatrix<Float, M, N, D>,
optype: OperatorType,
prev: ArrayView1<Float>,
mut fut: ArrayViewMut1<Float>,
@ -201,7 +197,7 @@ pub(crate) fn diff_op_1d<const M: usize, const N: usize, const D: usize>(
#[allow(unused)]
/// 2D diff fallback for when matrices are not slicable
pub(crate) fn diff_op_2d_fallback<const M: usize, const N: usize, const D: usize>(
matrix: &BlockMatrix<M, N, D>,
matrix: &BlockMatrix<Float, M, N, D>,
optype: OperatorType,
prev: ArrayView2<Float>,
mut fut: ArrayViewMut2<Float>,
@ -275,7 +271,7 @@ pub(crate) fn diff_op_2d_fallback<const M: usize, const N: usize, const D: usize
}
pub(crate) fn diff_op_2d_sliceable<const M: usize, const N: usize, const D: usize>(
matrix: &BlockMatrix<M, N, D>,
matrix: &BlockMatrix<Float, M, N, D>,
optype: OperatorType,
prev: ArrayView2<Float>,
mut fut: ArrayViewMut2<Float>,
@ -292,7 +288,7 @@ pub(crate) fn diff_op_2d_sliceable<const M: usize, const N: usize, const D: usiz
#[inline(always)]
/// Dispatch based on strides
pub(crate) fn diff_op_2d<const M: usize, const N: usize, const D: usize>(
matrix: &BlockMatrix<M, N, D>,
matrix: &BlockMatrix<Float, M, N, D>,
optype: OperatorType,
prev: ArrayView2<Float>,
fut: ArrayViewMut2<Float>,
@ -494,7 +490,7 @@ fn dotproduct<'a>(
#[cfg(feature = "sparse")]
pub(crate) fn sparse_from_block<const M: usize, const N: usize, const D: usize>(
matrix: &BlockMatrix<M, N, D>,
matrix: &BlockMatrix<Float, M, N, D>,
optype: OperatorType,
n: usize,
) -> sprs::CsMat<Float> {

4
sbp/src/operators/traditional4.rs
View File

@ -27,7 +27,7 @@ impl SBP4 {
const DIFF_BLOCKEND: super::Matrix<Float, 4, 6> =
super::flip_sign(super::flip_ud(super::flip_lr(Self::DIFF_BLOCK)));
const DIFF: BlockMatrix<4, 6, 5> =
const DIFF: BlockMatrix<Float, 4, 6, 5> =
BlockMatrix::new(Self::DIFF_BLOCK, Self::DIFF_DIAG, Self::DIFF_BLOCKEND);
#[rustfmt::skip]
@ -41,7 +41,7 @@ impl SBP4 {
[-4.0/43.0, 59.0/43.0, -110.0/43.0, 59.0/43.0, -4.0/43.0, 0.0],
[-1.0/49.0, 0.0, 59.0/49.0, -118.0/49.0, 64.0/49.0, -4.0/49.0]
]);
const D2: BlockMatrix<4, 6, 5> = BlockMatrix::new(
const D2: BlockMatrix<Float, 4, 6, 5> = BlockMatrix::new(
Self::D2BLOCK,
Self::D2DIAG,
super::flip_ud(super::flip_lr(Self::D2BLOCK)),

2
sbp/src/operators/traditional8.rs
View File

@ -27,7 +27,7 @@ impl SBP8 {
[2.75587615266177e-02, -8.71295642560637e-02, 5.01135077563584e-02, 7.68229253600969e-02, 4.60181213406519e-02, -7.55873581663580e-01, 0.00000000000000e+00, 8.21713248844682e-01, -2.16615355227872e-01, 4.12600676624518e-02, -3.86813134335486e-03, 0.0],
[5.84767272160451e-03, -1.08336661209337e-02, -1.42810403117803e-02, 3.50919361287023e-02, -1.22244235731112e-02, 1.19411743193552e-01, -7.51668243727123e-01, 0.00000000000000e+00, 7.92601963555477e-01, -1.98150490888869e-01, 3.77429506454989e-02, -3.53840162301552e-03],
]);
const DIFF: BlockMatrix<8, 12, 9> = BlockMatrix::new(
const DIFF: BlockMatrix<Float, 8, 12, 9> = BlockMatrix::new(
Self::DIFF_BLOCK,
Self::DIFF_DIAG,
super::flip_sign(super::flip_ud(super::flip_lr(Self::DIFF_BLOCK))),

4
sbp/src/operators/upwind4.rs
View File

@ -27,7 +27,7 @@ impl Upwind4 {
const DIFF_BLOCKEND: Matrix<Float, 4, 7> =
super::flip_sign(super::flip_ud(super::flip_lr(Self::DIFF_BLOCK)));
const DIFF: BlockMatrix<4, 7, 7> =
const DIFF: BlockMatrix<Float, 4, 7, 7> =
BlockMatrix::new(Self::DIFF_BLOCK, Self::DIFF_DIAG, Self::DIFF_BLOCKEND);
#[rustfmt::skip]
@ -43,7 +43,7 @@ impl Upwind4 {
]]);
const DISS_BLOCKEND: Matrix<Float, 4, 7> = super::flip_ud(super::flip_lr(Self::DISS_BLOCK));
const DISS: BlockMatrix<4, 7, 7> =
const DISS: BlockMatrix<Float, 4, 7, 7> =
BlockMatrix::new(Self::DISS_BLOCK, Self::DISS_DIAG, Self::DISS_BLOCKEND);
}

4
sbp/src/operators/upwind4h2.rs
View File

@ -24,7 +24,7 @@ impl Upwind4h2 {
const DIFF_DIAG: RowVector<Float, 7> = RowVector::new([[
-1.43229166666667e-02, 1.40625000000000e-01, -7.38281250000000e-01, 0.00000000000000e+00, 7.38281250000000e-01, -1.40625000000000e-01, 1.43229166666667e-02
]]);
const DIFF: BlockMatrix<4, 7, 7> = BlockMatrix::new(
const DIFF: BlockMatrix<Float, 4, 7, 7> = BlockMatrix::new(
Self::DIFF_BLOCK,
Self::DIFF_DIAG,
super::flip_sign(super::flip_ud(super::flip_lr(Self::DIFF_BLOCK))),
@ -42,7 +42,7 @@ impl Upwind4h2 {
const DISS_DIAG: RowVector<Float, 7> = RowVector::new([[
1.43229166666667e-02, -8.59375000000000e-02, 2.14843750000000e-01, -2.86458333333333e-01, 2.14843750000000e-01, -8.59375000000000e-02, 1.43229166666667e-02,
]]);
const DISS: BlockMatrix<4, 7, 7> = BlockMatrix::new(
const DISS: BlockMatrix<Float, 4, 7, 7> = BlockMatrix::new(
Self::DISS_BLOCK,
Self::DISS_DIAG,
super::flip_ud(super::flip_lr(Self::DISS_BLOCK)),

4
sbp/src/operators/upwind9.rs
View File

@ -28,7 +28,7 @@ impl Upwind9 {
[-6.19425252179959e-03, 3.69595678895333e-02, -7.01892820620398e-02, -3.35233082197107e-03, 2.69304373763091e-01, -8.89857974743355e-01, 0.00000000000000e+00, 8.66656645522330e-01, -2.57919763669076e-01, 6.44799409172690e-02, -1.07466568195448e-02, 8.59732545563586e-04, 0.0],
[1.44853491014330e-02, -4.59275574977554e-02, 3.08833474560615e-02, 3.57240610228828e-02, -7.07760049349999e-02, 1.88587240076292e-01, -7.92626447113877e-01, 0.00000000000000e+00, 8.25608497215073e-01, -2.35888142061449e-01, 5.89720355153623e-02, -9.82867258589373e-03, 7.86293806871498e-04],
]);
const DIFF: BlockMatrix<8, 13, 11> = BlockMatrix::new(
const DIFF: BlockMatrix<Float, 8, 13, 11> = BlockMatrix::new(
Self::DIFF_BLOCK,
Self::DIFF_DIAG,
super::flip_sign(super::flip_ud(super::flip_lr(Self::DIFF_BLOCK))),
@ -50,7 +50,7 @@ impl Upwind9 {
const DISS_DIAG: RowVector<Float, 11> = RowVector::new([[
1.0/1260.0, -1.0/126.0, 1.0/28.0, -2.0/21.0, 1.0/6.0, -1.0/5.0, 1.0/6.0, -2.0/21.0, 1.0/28.0, -1.0/126.0, 1.0/1260.0,
]]);
const DISS: BlockMatrix<8, 13, 11> = BlockMatrix::new(
const DISS: BlockMatrix<Float, 8, 13, 11> = BlockMatrix::new(
Self::DISS_BLOCK,
Self::DISS_DIAG,
super::flip_ud(super::flip_lr(Self::DISS_BLOCK)),

4
sbp/src/operators/upwind9h2.rs
View File

@ -28,7 +28,7 @@ impl Upwind9h2 {
[-1.35203347497451e-03, 5.77422023528126e-03, -1.06262408660325e-02, -2.37853245409338e-02, 2.05772021953463e-01, -8.20033622612654e-01, 0.00000000000000e+00, 8.31345778788959e-01, -2.37329555369694e-01, 5.93323888424235e-02, -9.88873147373725e-03, 7.91098517898980e-04, 0.0],
[-1.85246767034256e-03, 2.89905176240824e-03, 6.61951741227212e-04, 2.52792141498726e-03, -5.27086038822990e-02, 2.36934258275492e-01, -8.34333946306806e-01, 0.00000000000000e+00, 8.33639122800983e-01, -2.38182606514566e-01, 5.95456516286416e-02, -9.92427527144027e-03, 7.93942021715222e-04]
]);
const DIFF: BlockMatrix<8, 13, 11> = BlockMatrix::new(
const DIFF: BlockMatrix<Float, 8, 13, 11> = BlockMatrix::new(
Self::DIFF_BLOCK,
Self::DIFF_DIAG,
super::flip_sign(super::flip_ud(super::flip_lr(Self::DIFF_BLOCK))),
@ -50,7 +50,7 @@ impl Upwind9h2 {
const DISS_DIAG: RowVector<Float, 11> = RowVector::new([[
7.93650793650794e-04, -7.93650793650794e-03, 3.57142857142857e-02, -9.52380952380952e-02, 1.66666666666667e-01, -2.00000000000000e-01, 1.66666666666667e-01, -9.52380952380952e-02, 3.57142857142857e-02, -7.93650793650794e-03, 7.93650793650794e-04
]]);
const DISS: BlockMatrix<8, 13, 11> = BlockMatrix::new(
const DISS: BlockMatrix<Float, 8, 13, 11> = BlockMatrix::new(
Self::DISS_BLOCK,
Self::DISS_DIAG,
super::flip_ud(super::flip_lr(Self::DISS_BLOCK)),