10#ifndef EIGEN_SPARSE_SELFADJOINTVIEW_H
11#define EIGEN_SPARSE_SELFADJOINTVIEW_H
31template<
typename MatrixType,
unsigned int Mode>
32struct traits<SparseSelfAdjointView<MatrixType,Mode> > : traits<MatrixType> {
35template<
int SrcMode,
int DstMode,
typename MatrixType,
int DestOrder>
36void permute_symm_to_symm(
const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest,
const typename MatrixType::StorageIndex* perm = 0);
38template<
int Mode,
typename MatrixType,
int DestOrder>
39void permute_symm_to_fullsymm(
const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest,
const typename MatrixType::StorageIndex* perm = 0);
44 :
public EigenBase<SparseSelfAdjointView<MatrixType,_Mode> >
51 RowsAtCompileTime = internal::traits<SparseSelfAdjointView>::RowsAtCompileTime,
52 ColsAtCompileTime = internal::traits<SparseSelfAdjointView>::ColsAtCompileTime
56 typedef typename MatrixType::Scalar Scalar;
57 typedef typename MatrixType::StorageIndex StorageIndex;
59 typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
60 typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;
64 eigen_assert(rows()==cols() &&
"SelfAdjointView is only for squared matrices");
67 inline Index rows()
const {
return m_matrix.rows(); }
68 inline Index cols()
const {
return m_matrix.cols(); }
71 const _MatrixTypeNested& matrix()
const {
return m_matrix; }
72 typename internal::remove_reference<MatrixTypeNested>::type& matrix() {
return m_matrix; }
79 template<
typename OtherDerived>
91 template<
typename OtherDerived>
friend
99 template<
typename OtherDerived>
107 template<
typename OtherDerived>
friend
122 template<
typename DerivedU>
129 return SparseSymmetricPermutationProduct<_MatrixTypeNested,Mode>(m_matrix, perm);
132 template<
typename SrcMatrixType,
int SrcMode>
133 SparseSelfAdjointView& operator=(
const SparseSymmetricPermutationProduct<SrcMatrixType,SrcMode>& permutedMatrix)
135 internal::call_assignment_no_alias_no_transpose(*
this, permutedMatrix);
139 SparseSelfAdjointView& operator=(
const SparseSelfAdjointView& src)
141 PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
142 return *
this = src.twistedBy(pnull);
146 EIGEN_DEFAULT_COPY_CONSTRUCTOR(SparseSelfAdjointView)
148 template<
typename SrcMatrixType,
unsigned int SrcMode>
149 SparseSelfAdjointView& operator=(
const SparseSelfAdjointView<SrcMatrixType,SrcMode>& src)
151 PermutationMatrix<Dynamic,Dynamic,StorageIndex> pnull;
152 return *
this = src.twistedBy(pnull);
157 EIGEN_ONLY_USED_FOR_DEBUG(rows);
158 EIGEN_ONLY_USED_FOR_DEBUG(cols);
159 eigen_assert(rows == this->rows() && cols == this->cols()
160 &&
"SparseSelfadjointView::resize() does not actually allow to resize.");
165 MatrixTypeNested m_matrix;
169 template<
typename Dest>
void evalTo(Dest &)
const;
176template<
typename Derived>
177template<
unsigned int UpLo>
178typename SparseMatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView()
const
180 return SparseSelfAdjointView<const Derived, UpLo>(derived());
183template<
typename Derived>
184template<
unsigned int UpLo>
185typename SparseMatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type SparseMatrixBase<Derived>::selfadjointView()
187 return SparseSelfAdjointView<Derived, UpLo>(derived());
194template<
typename MatrixType,
unsigned int Mode>
195template<
typename DerivedU>
196SparseSelfAdjointView<MatrixType,Mode>&
197SparseSelfAdjointView<MatrixType,Mode>::rankUpdate(
const SparseMatrixBase<DerivedU>& u,
const Scalar& alpha)
199 SparseMatrix<Scalar,(MatrixType::Flags&
RowMajorBit)?RowMajor:ColMajor> tmp = u * u.adjoint();
201 m_matrix = tmp.template triangularView<Mode>();
203 m_matrix += alpha * tmp.template triangularView<Mode>();
213template<
typename MatrixType,
unsigned int Mode>
214struct evaluator_traits<SparseSelfAdjointView<MatrixType,Mode> >
216 typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
217 typedef SparseSelfAdjointShape Shape;
220struct SparseSelfAdjoint2Sparse {};
222template<>
struct AssignmentKind<SparseShape,SparseSelfAdjointShape> {
typedef SparseSelfAdjoint2Sparse Kind; };
223template<>
struct AssignmentKind<SparseSelfAdjointShape,SparseShape> {
typedef Sparse2Sparse Kind; };
225template<
typename DstXprType,
typename SrcXprType,
typename Functor>
226struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse>
228 typedef typename DstXprType::StorageIndex StorageIndex;
229 typedef internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> AssignOpType;
231 template<
typename DestScalar,
int StorageOrder>
232 static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst,
const SrcXprType &src,
const AssignOpType&)
234 internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
238 template<
typename DestScalar,
int StorageOrder,
typename AssignFunc>
239 static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst,
const SrcXprType &src,
const AssignFunc& func)
241 SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
242 run(tmp, src, AssignOpType());
243 call_assignment_no_alias_no_transpose(dst, tmp, func);
246 template<
typename DestScalar,
int StorageOrder>
247 static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst,
const SrcXprType &src,
248 const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& )
250 SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
251 run(tmp, src, AssignOpType());
255 template<
typename DestScalar,
int StorageOrder>
256 static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst,
const SrcXprType &src,
257 const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>& )
259 SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
260 run(tmp, src, AssignOpType());
264 template<
typename DestScalar>
265 static void run(DynamicSparseMatrix<DestScalar,ColMajor,StorageIndex>& dst,
const SrcXprType &src,
const AssignOpType&)
268 SparseMatrix<DestScalar,ColMajor,StorageIndex> tmp(dst.rows(),dst.cols());
269 internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), tmp);
282template<
int Mode,
typename SparseLhsType,
typename DenseRhsType,
typename DenseResType,
typename AlphaType>
283inline void sparse_selfadjoint_time_dense_product(
const SparseLhsType& lhs,
const DenseRhsType& rhs, DenseResType& res,
const AlphaType& alpha)
285 EIGEN_ONLY_USED_FOR_DEBUG(alpha);
287 typedef typename internal::nested_eval<SparseLhsType,DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
288 typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
289 typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
290 typedef typename LhsEval::InnerIterator LhsIterator;
291 typedef typename SparseLhsType::Scalar LhsScalar;
297 || ( (Mode&
Upper) && !LhsIsRowMajor)
298 || ( (Mode&
Lower) && LhsIsRowMajor),
299 ProcessSecondHalf = !ProcessFirstHalf
302 SparseLhsTypeNested lhs_nested(lhs);
303 LhsEval lhsEval(lhs_nested);
306 for (
Index k=0; k<rhs.cols(); ++k)
308 for (
Index j=0; j<lhs.outerSize(); ++j)
310 LhsIterator i(lhsEval,j);
312 if (ProcessSecondHalf)
314 while (i && i.index()<j) ++i;
315 if(i && i.index()==j)
317 res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
323 typename ScalarBinaryOpTraits<AlphaType, typename DenseRhsType::Scalar>::ReturnType rhs_j(alpha*rhs(j,k));
325 typename DenseResType::Scalar res_j(0);
326 for(; (ProcessFirstHalf ? i && i.index() < j : i) ; ++i)
328 LhsScalar lhs_ij = i.value();
329 if(!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
330 res_j += lhs_ij * rhs.coeff(i.index(),k);
331 res(i.index(),k) += numext::conj(lhs_ij) * rhs_j;
333 res.coeffRef(j,k) += alpha * res_j;
336 if (ProcessFirstHalf && i && (i.index()==j))
337 res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
343template<
typename LhsView,
typename Rhs,
int ProductType>
344struct generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType>
345: generic_product_impl_base<LhsView, Rhs, generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType> >
347 template<
typename Dest>
348 static void scaleAndAddTo(Dest& dst,
const LhsView& lhsView,
const Rhs& rhs,
const typename Dest::Scalar& alpha)
350 typedef typename LhsView::_MatrixTypeNested Lhs;
351 typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
352 typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
353 LhsNested lhsNested(lhsView.matrix());
354 RhsNested rhsNested(rhs);
356 internal::sparse_selfadjoint_time_dense_product<LhsView::Mode>(lhsNested, rhsNested, dst, alpha);
360template<
typename Lhs,
typename RhsView,
int ProductType>
361struct generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType>
362: generic_product_impl_base<Lhs, RhsView, generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType> >
364 template<
typename Dest>
365 static void scaleAndAddTo(Dest& dst,
const Lhs& lhs,
const RhsView& rhsView,
const typename Dest::Scalar& alpha)
367 typedef typename RhsView::_MatrixTypeNested Rhs;
368 typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
369 typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
370 LhsNested lhsNested(lhs);
371 RhsNested rhsNested(rhsView.matrix());
374 Transpose<Dest> dstT(dst);
375 internal::sparse_selfadjoint_time_dense_product<RhsView::TransposeMode>(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
382template<
typename LhsView,
typename Rhs,
int ProductTag>
383struct product_evaluator<Product<LhsView, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, SparseShape>
384 :
public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject>
386 typedef Product<LhsView, Rhs, DefaultProduct> XprType;
387 typedef typename XprType::PlainObject PlainObject;
388 typedef evaluator<PlainObject> Base;
390 product_evaluator(
const XprType& xpr)
391 : m_lhs(xpr.lhs()), m_result(xpr.rows(), xpr.cols())
393 ::new (
static_cast<Base*
>(
this)) Base(m_result);
394 generic_product_impl<typename Rhs::PlainObject, Rhs, SparseShape, SparseShape, ProductTag>::evalTo(m_result, m_lhs, xpr.rhs());
398 typename Rhs::PlainObject m_lhs;
399 PlainObject m_result;
402template<typename Lhs, typename RhsView,
int ProductTag>
403struct product_evaluator<Product<Lhs, RhsView, DefaultProduct>, ProductTag, SparseShape, SparseSelfAdjointShape>
404 : public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject>
406 typedef Product<Lhs, RhsView, DefaultProduct> XprType;
407 typedef typename XprType::PlainObject PlainObject;
408 typedef evaluator<PlainObject> Base;
410 product_evaluator(
const XprType& xpr)
411 : m_rhs(xpr.rhs()), m_result(xpr.rows(), xpr.cols())
413 ::new (
static_cast<Base*
>(
this)) Base(m_result);
414 generic_product_impl<Lhs, typename Lhs::PlainObject, SparseShape, SparseShape, ProductTag>::evalTo(m_result, xpr.lhs(), m_rhs);
418 typename Lhs::PlainObject m_rhs;
419 PlainObject m_result;
429template<
int Mode,
typename MatrixType,
int DestOrder>
430void permute_symm_to_fullsymm(
const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DestOrder,typename MatrixType::StorageIndex>& _dest,
const typename MatrixType::StorageIndex* perm)
432 typedef typename MatrixType::StorageIndex StorageIndex;
433 typedef typename MatrixType::Scalar Scalar;
434 typedef SparseMatrix<Scalar,DestOrder,StorageIndex> Dest;
435 typedef Matrix<StorageIndex,Dynamic,1> VectorI;
436 typedef evaluator<MatrixType> MatEval;
437 typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
439 MatEval matEval(mat);
440 Dest& dest(_dest.derived());
442 StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
445 Index size = mat.rows();
449 dest.resize(size,size);
450 for(Index j = 0; j<size; ++j)
452 Index jp = perm ? perm[j] : j;
453 for(MatIterator it(matEval,j); it; ++it)
455 Index i = it.index();
458 Index ip = perm ? perm[i] : i;
459 if(Mode==
int(Upper|Lower))
460 count[StorageOrderMatch ? jp : ip]++;
463 else if(( Mode==Lower && r>c) || ( Mode==Upper && r<c))
470 Index nnz = count.sum();
473 dest.resizeNonZeros(nnz);
474 dest.outerIndexPtr()[0] = 0;
475 for(Index j=0; j<size; ++j)
476 dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
477 for(Index j=0; j<size; ++j)
478 count[j] = dest.outerIndexPtr()[j];
481 for(StorageIndex j = 0; j<size; ++j)
483 for(MatIterator it(matEval,j); it; ++it)
485 StorageIndex i = internal::convert_index<StorageIndex>(it.index());
489 StorageIndex jp = perm ? perm[j] : j;
490 StorageIndex ip = perm ? perm[i] : i;
492 if(Mode==
int(Upper|Lower))
494 Index k = count[StorageOrderMatch ? jp : ip]++;
495 dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
496 dest.valuePtr()[k] = it.value();
500 Index k = count[ip]++;
501 dest.innerIndexPtr()[k] = ip;
502 dest.valuePtr()[k] = it.value();
504 else if(( (Mode&Lower)==Lower && r>c) || ( (Mode&Upper)==Upper && r<c))
506 if(!StorageOrderMatch)
508 Index k = count[jp]++;
509 dest.innerIndexPtr()[k] = ip;
510 dest.valuePtr()[k] = it.value();
512 dest.innerIndexPtr()[k] = jp;
513 dest.valuePtr()[k] = numext::conj(it.value());
519template<
int _SrcMode,
int _DstMode,
typename MatrixType,
int DstOrder>
520void permute_symm_to_symm(
const MatrixType& mat, SparseMatrix<typename MatrixType::Scalar,DstOrder,typename MatrixType::StorageIndex>& _dest,
const typename MatrixType::StorageIndex* perm)
522 typedef typename MatrixType::StorageIndex StorageIndex;
523 typedef typename MatrixType::Scalar Scalar;
524 SparseMatrix<Scalar,DstOrder,StorageIndex>& dest(_dest.derived());
525 typedef Matrix<StorageIndex,Dynamic,1> VectorI;
526 typedef evaluator<MatrixType> MatEval;
527 typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
531 StorageOrderMatch = int(SrcOrder) == int(DstOrder),
533 SrcMode = SrcOrder==RowMajor ? (_SrcMode==Upper ? Lower : Upper) : _SrcMode
536 MatEval matEval(mat);
538 Index size = mat.rows();
541 dest.resize(size,size);
542 for(StorageIndex j = 0; j<size; ++j)
544 StorageIndex jp = perm ? perm[j] : j;
545 for(MatIterator it(matEval,j); it; ++it)
547 StorageIndex i = it.index();
548 if((
int(SrcMode)==
int(Lower) && i<j) || (
int(SrcMode)==
int(Upper) && i>j))
551 StorageIndex ip = perm ? perm[i] : i;
552 count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
555 dest.outerIndexPtr()[0] = 0;
556 for(Index j=0; j<size; ++j)
557 dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
558 dest.resizeNonZeros(dest.outerIndexPtr()[size]);
559 for(Index j=0; j<size; ++j)
560 count[j] = dest.outerIndexPtr()[j];
562 for(StorageIndex j = 0; j<size; ++j)
565 for(MatIterator it(matEval,j); it; ++it)
567 StorageIndex i = it.index();
568 if((
int(SrcMode)==int(Lower) && i<j) || (
int(SrcMode)==int(Upper) && i>j))
571 StorageIndex jp = perm ? perm[j] : j;
572 StorageIndex ip = perm? perm[i] : i;
574 Index k = count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
575 dest.innerIndexPtr()[k] = int(DstMode)==int(Lower) ? (std::max)(ip,jp) : (std::min)(ip,jp);
577 if(!StorageOrderMatch) std::swap(ip,jp);
578 if( ((
int(DstMode)==
int(Lower) && ip<jp) || (
int(DstMode)==
int(Upper) && ip>jp)))
579 dest.valuePtr()[k] = numext::conj(it.value());
581 dest.valuePtr()[k] = it.value();
592template<
typename MatrixType,
int Mode>
593struct traits<SparseSymmetricPermutationProduct<MatrixType,Mode> > : traits<MatrixType> {
598template<
typename MatrixType,
int Mode>
599class SparseSymmetricPermutationProduct
600 :
public EigenBase<SparseSymmetricPermutationProduct<MatrixType,Mode> >
603 typedef typename MatrixType::Scalar Scalar;
604 typedef typename MatrixType::StorageIndex StorageIndex;
606 RowsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::RowsAtCompileTime,
607 ColsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::ColsAtCompileTime
610 typedef PermutationMatrix<Dynamic,Dynamic,StorageIndex> Perm;
612 typedef Matrix<StorageIndex,Dynamic,1> VectorI;
613 typedef typename MatrixType::Nested MatrixTypeNested;
614 typedef typename internal::remove_all<MatrixTypeNested>::type NestedExpression;
616 SparseSymmetricPermutationProduct(
const MatrixType& mat,
const Perm& perm)
617 : m_matrix(mat), m_perm(perm)
620 inline Index rows()
const {
return m_matrix.rows(); }
621 inline Index cols()
const {
return m_matrix.cols(); }
623 const NestedExpression& matrix()
const {
return m_matrix; }
624 const Perm& perm()
const {
return m_perm; }
627 MatrixTypeNested m_matrix;
634template<
typename DstXprType,
typename MatrixType,
int Mode,
typename Scalar>
635struct Assignment<DstXprType, SparseSymmetricPermutationProduct<MatrixType,Mode>, internal::assign_op<Scalar,typename MatrixType::Scalar>, Sparse2Sparse>
637 typedef SparseSymmetricPermutationProduct<MatrixType,Mode> SrcXprType;
638 typedef typename DstXprType::StorageIndex DstIndex;
639 template<
int Options>
640 static void run(SparseMatrix<Scalar,Options,DstIndex> &dst,
const SrcXprType &src,
const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
643 SparseMatrix<Scalar,(Options&
RowMajor)==RowMajor ? ColMajor : RowMajor, DstIndex> tmp;
644 internal::permute_symm_to_fullsymm<Mode>(src.matrix(),tmp,src.perm().indices().data());
648 template<
typename DestType,
unsigned int DestMode>
649 static void run(SparseSelfAdjointView<DestType,DestMode>& dst,
const SrcXprType &src,
const internal::assign_op<Scalar,typename MatrixType::Scalar> &)
651 internal::permute_symm_to_symm<Mode,DestMode>(src.matrix(),dst.matrix(),src.perm().indices().data());
Derived & derived()
Definition: EigenBase.h:46
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:50
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:180
Permutation matrix.
Definition: PermutationMatrix.h:298
Expression of the product of two arbitrary matrices or vectors.
Definition: Product.h:75
Base class of any sparse matrices or sparse expressions.
Definition: SparseMatrixBase.h:28
Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
Definition: SparseSelfAdjointView.h:45
friend Product< OtherDerived, SparseSelfAdjointView > operator*(const MatrixBase< OtherDerived > &lhs, const SparseSelfAdjointView &rhs)
Definition: SparseSelfAdjointView.h:109
SparseSelfAdjointView & rankUpdate(const SparseMatrixBase< DerivedU > &u, const Scalar &alpha=Scalar(1))
Product< SparseSelfAdjointView, OtherDerived > operator*(const MatrixBase< OtherDerived > &rhs) const
Definition: SparseSelfAdjointView.h:101
Product< SparseSelfAdjointView, OtherDerived > operator*(const SparseMatrixBase< OtherDerived > &rhs) const
Definition: SparseSelfAdjointView.h:81
friend Product< OtherDerived, SparseSelfAdjointView > operator*(const SparseMatrixBase< OtherDerived > &lhs, const SparseSelfAdjointView &rhs)
Definition: SparseSelfAdjointView.h:93
SparseSymmetricPermutationProduct< _MatrixTypeNested, Mode > twistedBy(const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm) const
Definition: SparseSelfAdjointView.h:127
@ Lower
Definition: Constants.h:209
@ Upper
Definition: Constants.h:211
@ ColMajor
Definition: Constants.h:319
@ RowMajor
Definition: Constants.h:321
const unsigned int RowMajorBit
Definition: Constants.h:66
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
Definition: EigenBase.h:30
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:39
Derived & derived()
Definition: EigenBase.h:46