#![allow(dead_code)]

//! Test some nalgebra generic shape constraints do as expected.
use nalgebra::base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
use nalgebra::{allocator::Allocator, DefaultAllocator, U1, U2};
use nalgebra::{Const, Dim, DimName, Dyn};
use nalgebra::{OMatrix, RealField, Vector2};

trait GenericDim<D: Dim> {
    fn dim(&self) -> D;
}

struct UseU1 {}
struct UseU2 {}

impl GenericDim<U1> for UseU1 {
    fn dim(&self) -> U1 {
        Const::<1>
    }
}

impl GenericDim<U2> for UseU2 {
    fn dim(&self) -> U2 {
        Const::<2>
    }
}

fn test_dimeq<D1: Dim, D2: Dim>()
where
    ShapeConstraint: DimEq<D1, D2>,
{
}

#[test]
pub fn try_test_dimeq() {
    test_dimeq::<U1, U1>();
    test_dimeq::<Dyn, U1>();
}

fn new_copy<N: RealField, R: Dim, C: Dim, R1: Dim, C1: Dim>(
    r: R,
    c: C,
    m: &OMatrix<N, R1, C1>,
) -> OMatrix<N, R, C>
where
    DefaultAllocator: Allocator<R1, C1> + Allocator<R, C> + Allocator<Dyn, Dyn>,
    ShapeConstraint: SameNumberOfRows<R, R1> + SameNumberOfColumns<C, C1>,
{
    let mut zeroed = OMatrix::<N, R, C>::zeros_generic(r, c);
    zeroed.copy_from(m);
    zeroed
}

fn xx<D: DimName>()
where
    DefaultAllocator: Allocator<D> + Allocator<Dyn> + Allocator<U2>,
{
    let z2 = Vector2::<f64>::zeros();

    let mut vd = new_copy(Dyn(2), U1, &z2);
    vd.copy_from(&z2);

    let mut vn = new_copy(Const::<2>, Const::<1>, &z2);
    vn.copy_from(&z2);
}