Changeset 36

Show
Ignore:
Timestamp:
08/27/07 18:49:58 (1 year ago)
Author:
pernet
Message:

New version of ftrmm ftrsm:
* ftrsm based on the multicascade algorithm (minimizing the modular reduction)
* general structure, and automated generation of each specialization
* few bugs to be fix still

Location:
include/fflas-ffpack
Files:
2 added
5 modified

Legend:

Unmodified
Added
Removed

  • include/fflas-ffpack/fflas.h

    r33 r36  
    281281                return C; 
    282282        } 
    283          
     283 
    284284        //--------------------------------------------------------------------- 
    285285        // fsquare:  
    … …  
    553553                 
    554554        // Specialized routines for ftrsm 
    555         template<class Field> 
    556         static void ftrsmLeftUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    557                                         const size_t M, const size_t N, 
    558                                         const typename Field::Element alpha, 
    559                                         const typename Field::Element * A, const size_t lda, 
    560                                         typename Field::Element * B, const size_t ldb); 
    561          
    562         template<class Field> 
    563         static void ftrsmLeftUpTrans (const Field& F, const FFLAS_DIAG Diag,  
    564                                       const size_t M, const size_t N, 
    565                                       const typename Field::Element alpha, 
    566                                       const typename Field::Element * A, const size_t lda, 
    567                                       typename Field::Element * B, const size_t ldb); 
    568          
    569         template<class Field> 
    570         static void ftrsmLeftLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    571                                          const size_t M, const size_t N, 
    572                                          const typename Field::Element alpha, 
    573                                          typename Field::Element * A, const size_t lda, 
    574                                          typename Field::Element * B, const size_t ldb,  
    575                                          const size_t nmax); 
    576         template<class Element> 
    577         class callFtrsmLeftLowNoTrans; 
    578          
    579         template<class Element> 
    580         class callFtrsmRightUpNoTrans; 
    581          
    582         template<class Element> 
    583         class callFtrmmLeftUpNoTrans; 
    584          
    585         template<class Element> 
    586         class callFtrmmLeftUpTrans; 
    587  
    588         template<class Element> 
    589         class callFtrmmLeftLowNoTrans;           
    590  
    591         template<class Element> 
    592         class callFtrmmLeftLowTrans;             
    593  
    594         template<class Element> 
    595         class callFtrmmRightUpNoTrans;           
    596  
    597         template<class Element> 
    598         class callFtrmmRightUpTrans;             
    599  
    600         template<class Element> 
    601         class callFtrmmRightLowNoTrans;          
    602  
    603         template<class Element> 
    604         class callFtrmmRightLowTrans;            
    605          
    606         template<class Field> 
    607         static void ftrsmLeftLowTrans (const Field& F, const FFLAS_DIAG Diag,  
    608                                        const size_t M, const size_t N, 
    609                                        const typename Field::Element alpha, 
    610                                        const typename Field::Element * A, const size_t lda, 
    611                                        typename Field::Element * B, const size_t ldb); 
    612          
    613         template<class Field> 
    614         static void ftrsmRightUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    615                                          const size_t M, const size_t N, 
    616                                          const typename Field::Element alpha, 
    617                                          typename Field::Element * A, const size_t lda, 
    618                                          typename Field::Element * B, const size_t ldb, 
    619                                          const size_t nmax); 
    620          
    621         template<class Field> 
    622         static void ftrsmRightUpTrans (const Field& F, const FFLAS_DIAG Diag,  
    623                                        const size_t M, const size_t N, 
    624                                        const typename Field::Element alpha, 
    625                                        const typename Field::Element * A, const size_t lda, 
    626                                        typename Field::Element * B, const size_t ldb); 
    627  
    628         template<class Field> 
    629         static void ftrsmRightLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    630                                           const size_t M, const size_t N, 
    631                                           const typename Field::Element alpha, 
    632                                           const typename Field::Element * A, const size_t lda, 
    633                                           typename Field::Element * B, const size_t ldb); 
    634  
    635         template<class Field> 
    636         static void ftrsmRightLowTrans (const Field& F, const FFLAS_DIAG Diag,  
    637                                         const size_t M, const size_t N, 
    638                                         const typename Field::Element alpha, 
    639                                         const typename Field::Element * A, const size_t lda, 
    640                                         typename Field::Element * B, const size_t ldb); 
     555        template <class Element> 
     556        class ftrsmLeftUpperNoTransNonUnit; 
     557        template <class Element> 
     558        class ftrsmLeftUpperNoTransUnit; 
     559        template <class Element> 
     560        class ftrsmLeftUpperTransNonUnit; 
     561        template <class Element> 
     562        class ftrsmLeftUpperTransUnit; 
     563        template <class Element> 
     564        class ftrsmLeftLowerNoTransNonUnit; 
     565        template <class Element> 
     566        class ftrsmLeftLowerNoTransUnit; 
     567        template <class Element> 
     568        class ftrsmLeftLowerTransNonUnit; 
     569        template <class Element> 
     570        class ftrsmLeftLowerTransUnit; 
     571        template <class Element> 
     572        class ftrsmRightUpperNoTransNonUnit; 
     573        template <class Element> 
     574        class ftrsmRightUpperNoTransUnit; 
     575        template <class Element> 
     576        class ftrsmRightUpperTransNonUnit; 
     577        template <class Element> 
     578        class ftrsmRightUpperTransUnit; 
     579        template <class Element> 
     580        class ftrsmRightLowerNoTransNonUnit; 
     581        template <class Element> 
     582        class ftrsmRightLowerNoTransUnit; 
     583        template <class Element> 
     584        class ftrsmRightLowerTransNonUnit; 
     585        template <class Element> 
     586        class ftrsmRightLowerTransUnit; 
    641587 
    642588        // Specialized routines for ftrmm 
    643         template<class Field> 
    644         static void ftrmmLeftUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    645                                         const size_t M, const size_t N, 
    646                                         const typename Field::Element * A, const size_t lda, 
    647                                         typename Field::Element * B, const size_t ldb,  
    648                                         const size_t nmax); 
    649  
    650         template<class Field> 
    651         static void ftrmmLeftUpTrans (const Field& F, const FFLAS_DIAG Diag,  
    652                                       const size_t M, const size_t N, 
    653                                       const typename Field::Element * A, const size_t lda, 
    654                                       typename Field::Element * B, const size_t ldb, 
    655                                       const size_t nmax); 
    656  
    657         template<class Field> 
    658         static void ftrmmLeftLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    659                                          const size_t M, const size_t N, 
    660                                          const typename Field::Element * A, const size_t lda, 
    661                                          typename Field::Element * B, const size_t ldb,  
    662                                          const size_t nmax); 
    663  
    664         template<class Field> 
    665         static void ftrmmLeftLowTrans (const Field& F, const FFLAS_DIAG Diag,  
    666                                        const size_t M, const size_t N, 
    667                                        const typename Field::Element * A, const size_t lda, 
    668                                        typename Field::Element * B, const size_t ldb, 
    669                                        const size_t nmax); 
    670          
    671         template<class Field> 
    672         static void ftrmmRightUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    673                                          const size_t M, const size_t N, 
    674                                          const typename Field::Element * A, const size_t lda, 
    675                                          typename Field::Element * B, const size_t ldb,  
    676                                          const size_t nmax); 
    677  
    678         template<class Field> 
    679         static void ftrmmRightUpTrans (const Field& F, const FFLAS_DIAG Diag,  
    680                                        const size_t M, const size_t N, 
    681                                        const typename Field::Element * A, const size_t lda, 
    682                                        typename Field::Element * B, const size_t ldb,  
    683                                        const size_t nmax); 
    684  
    685         template<class Field> 
    686         static void ftrmmRightLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
    687                                           const size_t M, const size_t N, 
    688                                           const typename Field::Element * A, const size_t lda, 
    689                                           typename Field::Element * B, const size_t ldb, 
    690                                           const size_t nmax); 
    691         template<class Field> 
    692         static void ftrmmRightLowTrans (const Field& F, const FFLAS_DIAG Diag,  
    693                                         const size_t M, const size_t N, 
    694                                         const typename Field::Element * A, const size_t lda, 
    695                                         typename Field::Element * B, const size_t ldb,  
    696                                         const size_t nmax); 
     589        template <class Element> 
     590        class ftrmmLeftUpperNoTransNonUnit; 
     591        template <class Element> 
     592        class ftrmmLeftUpperNoTransUnit; 
     593        template <class Element> 
     594        class ftrmmLeftUpperTransNonUnit; 
     595        template <class Element> 
     596        class ftrmmLeftUpperTransUnit; 
     597        template <class Element> 
     598        class ftrmmLeftLowerNoTransNonUnit; 
     599        template <class Element> 
     600        class ftrmmLeftLowerNoTransUnit; 
     601        template <class Element> 
     602        class ftrmmLeftLowerTransNonUnit; 
     603        template <class Element> 
     604        class ftrmmLeftLowerTransUnit; 
     605        template <class Element> 
     606        class ftrmmRightUpperNoTransNonUnit; 
     607        template <class Element> 
     608        class ftrmmRightUpperNoTransUnit; 
     609        template <class Element> 
     610        class ftrmmRightUpperTransNonUnit; 
     611        template <class Element> 
     612        class ftrmmRightUpperTransUnit; 
     613        template <class Element> 
     614        class ftrmmRightLowerNoTransNonUnit; 
     615        template <class Element> 
     616        class ftrmmRightLowerNoTransUnit; 
     617        template <class Element> 
     618        class ftrmmRightLowerTransNonUnit; 
     619        template <class Element> 
     620        class ftrmmRightLowerTransUnit; 
     621 
     622//      template<class Field> 
     623//      static void ftrsmLeftUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     624//                                      const size_t M, const size_t N, 
     625//                                      const typename Field::Element alpha, 
     626//                                      const typename Field::Element * A, const size_t lda, 
     627//                                      typename Field::Element * B, const size_t ldb); 
     628         
     629//      template<class Field> 
     630//      static void ftrsmLeftUpTrans (const Field& F, const FFLAS_DIAG Diag,  
     631//                                    const size_t M, const size_t N, 
     632//                                    const typename Field::Element alpha, 
     633//                                    const typename Field::Element * A, const size_t lda, 
     634//                                    typename Field::Element * B, const size_t ldb); 
     635         
     636//      template<class Field> 
     637//      static void ftrsmLeftLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     638//                                       const size_t M, const size_t N, 
     639//                                       const typename Field::Element alpha, 
     640//                                       typename Field::Element * A, const size_t lda, 
     641//                                       typename Field::Element * B, const size_t ldb,  
     642//                                       const size_t nmax); 
     643//      template<class Element> 
     644//      class callFtrsmLeftLowNoTrans; 
     645         
     646//      template<class Element> 
     647//      class callFtrsmRightUpNoTrans; 
     648         
     649//      template<class Element> 
     650//      class callFtrmmLeftUpNoTrans; 
     651         
     652//      template<class Element> 
     653//      class callFtrmmLeftUpTrans; 
     654 
     655//      template<class Element> 
     656//      class callFtrmmLeftLowNoTrans;           
     657 
     658//      template<class Element> 
     659//      class callFtrmmLeftLowTrans;             
     660 
     661//      template<class Element> 
     662//      class callFtrmmRightUpNoTrans;           
     663 
     664//      template<class Element> 
     665//      class callFtrmmRightUpTrans;             
     666 
     667//      template<class Element> 
     668//      class callFtrmmRightLowNoTrans;          
     669 
     670//      template<class Element> 
     671//      class callFtrmmRightLowTrans;            
     672         
     673//      template<class Field> 
     674//      static void ftrsmLeftLowTrans (const Field& F, const FFLAS_DIAG Diag,  
     675//                                     const size_t M, const size_t N, 
     676//                                     const typename Field::Element alpha, 
     677//                                     const typename Field::Element * A, const size_t lda, 
     678//                                     typename Field::Element * B, const size_t ldb); 
     679         
     680//      template<class Field> 
     681//      static void ftrsmRightUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     682//                                       const size_t M, const size_t N, 
     683//                                       const typename Field::Element alpha, 
     684//                                       typename Field::Element * A, const size_t lda, 
     685//                                       typename Field::Element * B, const size_t ldb, 
     686//                                       const size_t nmax); 
     687         
     688//      template<class Field> 
     689//      static void ftrsmRightUpTrans (const Field& F, const FFLAS_DIAG Diag,  
     690//                                     const size_t M, const size_t N, 
     691//                                     const typename Field::Element alpha, 
     692//                                     const typename Field::Element * A, const size_t lda, 
     693//                                     typename Field::Element * B, const size_t ldb); 
     694 
     695//      template<class Field> 
     696//      static void ftrsmRightLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     697//                                        const size_t M, const size_t N, 
     698//                                        const typename Field::Element alpha, 
     699//                                        const typename Field::Element * A, const size_t lda, 
     700//                                        typename Field::Element * B, const size_t ldb); 
     701 
     702//      template<class Field> 
     703//      static void ftrsmRightLowTrans (const Field& F, const FFLAS_DIAG Diag,  
     704//                                      const size_t M, const size_t N, 
     705//                                      const typename Field::Element alpha, 
     706//                                      const typename Field::Element * A, const size_t lda, 
     707//                                      typename Field::Element * B, const size_t ldb); 
     708 
     709        // Specialized routines for ftrmm 
     710//      template<class Field> 
     711//      static void ftrmmLeftUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     712//                                      const size_t M, const size_t N, 
     713//                                      const typename Field::Element * A, const size_t lda, 
     714//                                      typename Field::Element * B, const size_t ldb,  
     715//                                      const size_t nmax); 
     716 
     717//      template<class Field> 
     718//      static void ftrmmLeftUpTrans (const Field& F, const FFLAS_DIAG Diag,  
     719//                                    const size_t M, const size_t N, 
     720//                                    const typename Field::Element * A, const size_t lda, 
     721//                                    typename Field::Element * B, const size_t ldb, 
     722//                                    const size_t nmax); 
     723 
     724//      template<class Field> 
     725//      static void ftrmmLeftLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     726//                                       const size_t M, const size_t N, 
     727//                                       const typename Field::Element * A, const size_t lda, 
     728//                                       typename Field::Element * B, const size_t ldb,  
     729//                                       const size_t nmax); 
     730 
     731//      template<class Field> 
     732//      static void ftrmmLeftLowTrans (const Field& F, const FFLAS_DIAG Diag,  
     733//                                     const size_t M, const size_t N, 
     734//                                     const typename Field::Element * A, const size_t lda, 
     735//                                     typename Field::Element * B, const size_t ldb, 
     736//                                     const size_t nmax); 
     737         
     738//      template<class Field> 
     739//      static void ftrmmRightUpNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     740//                                       const size_t M, const size_t N, 
     741//                                       const typename Field::Element * A, const size_t lda, 
     742//                                       typename Field::Element * B, const size_t ldb,  
     743//                                       const size_t nmax); 
     744 
     745//      template<class Field> 
     746//      static void ftrmmRightUpTrans (const Field& F, const FFLAS_DIAG Diag,  
     747//                                     const size_t M, const size_t N, 
     748//                                     const typename Field::Element * A, const size_t lda, 
     749//                                     typename Field::Element * B, const size_t ldb,  
     750//                                     const size_t nmax); 
     751 
     752//      template<class Field> 
     753//      static void ftrmmRightLowNoTrans (const Field& F, const FFLAS_DIAG Diag,  
     754//                                        const size_t M, const size_t N, 
     755//                                        const typename Field::Element * A, const size_t lda, 
     756//                                        typename Field::Element * B, const size_t ldb, 
     757//                                        const size_t nmax); 
     758//      template<class Field> 
     759//      static void ftrmmRightLowTrans (const Field& F, const FFLAS_DIAG Diag,  
     760//                                      const size_t M, const size_t N, 
     761//                                      const typename Field::Element * A, const size_t lda, 
     762//                                      typename Field::Element * B, const size_t ldb,  
     763//                                      const size_t nmax); 
    697764}; // class FFLAS 
    698765 

  • include/fflas-ffpack/fflas_bounds.inl

    r33 r36  
    187187                        return nmax= bound_compute_double (p=pi); //(F.balanced) ? bound_compute_balanced(p=pi) : bound_compute(p=pi); 
    188188#else 
    189                 return (F.balanced) ? bound_compute_double_balanced(p=pi) : bound_compute_double(p=pi); 
     189                return nmax = (F.balanced) ? bound_compute_double_balanced(p=pi) : bound_compute_double(p=pi); 
    190190#endif 
    191191        } 
    … …  
    211211                        return nmax= bound_compute_float (p=pi); //(F.balanced) ? bound_compute_balanced(p=pi) : bound_compute(p=pi); 
    212212#else 
    213                 return (F.balanced) ? bound_compute_float_balanced(p=pi) : bound_compute_float(p=pi); 
     213                return nmax = (F.balanced) ? bound_compute_float_balanced(p=pi) : bound_compute_float(p=pi); 
    214214#endif 
    215215        } 

  • include/fflas-ffpack/fflas_fgemm.inl

    r26 r36  
    521521                         
    522522                // Two temporary submatrices are required 
    523                 typename Field::Element* X1 = new typename Field::Element[mr*x1rd]; 
     523 
    524524                typename Field::Element* X2 = new typename Field::Element[kr*nr]; 
    525525                 
    … …  
    531531                } 
    532532 
    533                 // S3 = A11 - A21 in X1 
     533                typename Field::Element* X1 = new typename Field::Element[mr*x1rd];             // S3 = A11 - A21 in X1 
    534534                d11 = A11; d21 = A21; dx1 = X1; 
    535535                for (size_t i = 0; i < imaxa; ++i, d11 += lda, d21 += lda, dx1 += ldx1) 
    … …  
    621621                                F.subin (*(dx2+j),* (d21 + j)); 
    622622                } 
     623 
    623624                //write_field(F, cerr<<"T4 = "<<endl, X2, imaxb, jmaxb, ldx2); 
    624625 
    … …  
    626627                WinoMain (F, ta, tb, mr, nr, kr, alpha, A22, lda, X2, ldx2, zero, C11, ldc, kmax, w-1, base); 
    627628                //write_field(F, cerr<<"P4 = "<<endl, C11, mr, nr, ldc); 
    628                  
     629 
     630                delete[] X2;             
    629631                // U6 = U3 - P4 in C21 
    630632                d21c = C21; d11c = C11; 
    … …  
    643645 
    644646                delete[] X1; 
    645                 delete[] X2; 
    646647         
    647648        } else { 
    … …  
    13511352 
    13521353 
     1354        // Unsafe matmul over Z 
     1355        // For internal usage only (or use it with care) 
     1356        template<> 
     1357        inline double*  
     1358        FFLAS::fgemm<UnparametricField<double> > ( const UnparametricField<double>& F, 
     1359                                             const FFLAS_TRANSPOSE ta, 
     1360                                             const FFLAS_TRANSPOSE tb, 
     1361                                             const size_t m, 
     1362                                             const size_t n, 
     1363                                             const size_t k, 
     1364                                             const double alpha, 
     1365                                             const double* A, const size_t lda, 
     1366                                             const double* B, const size_t ldb,  
     1367                                             const double beta, 
     1368                                             double* C, const size_t ldc, 
     1369                                             const size_t w){ 
     1370 
     1371                if (!(m && n && k)) return C; 
     1372                 
     1373                //FFLAS_BASE base = BaseCompute<typename Field::double> ()(F, w); 
     1374 
     1375                WinoMain (F, ta, tb, m, n, k, alpha, A, lda, B, ldb, beta, 
     1376                          C, ldc, k+1, w, FflasDouble); 
     1377                return C; 
     1378        } 
     1379 
     1380        template<> 
     1381        inline float*  
     1382        FFLAS::fgemm<UnparametricField<float> > ( const UnparametricField<float>& F, 
     1383                                                  const FFLAS_TRANSPOSE ta, 
     1384                                                  const FFLAS_TRANSPOSE tb, 
     1385                                                  const size_t m, 
     1386                                                  const size_t n, 
     1387                                                  const size_t k, 
     1388                                                  const float alpha, 
     1389                                                  const float* A, const size_t lda, 
     1390                                                  const float* B, const size_t ldb,  
     1391                                                  const float beta, 
     1392                                                  float* C, const size_t ldc, 
     1393                                                  const size_t w){ 
     1394                 
     1395                if (!(m && n && k)) return C; 
     1396                 
     1397                //FFLAS_BASE base = BaseCompute<typename Field::float> ()(F, w); 
     1398 
     1399                WinoMain (F, ta, tb, m, n, k, alpha, A, lda, B, ldb, beta, 
     1400                          C, ldc, k+1, w, FflasFloat); 
     1401                return C; 
     1402                } 
     1403         
     1404        template<> 
     1405        inline double*  
     1406        FFLAS::fgemm<UnparametricField<double> > ( const UnparametricField<double>& F, 
     1407                                             const FFLAS_TRANSPOSE ta, 
     1408                                             const FFLAS_TRANSPOSE tb, 
     1409                                             const size_t m, 
     1410                                             const size_t n, 
     1411                                             const size_t k, 
     1412                                             const double alpha, 
     1413                                             const double* A, const size_t lda, 
     1414                                             const double* B, const size_t ldb,  
     1415                                             const double beta, 
     1416                                             double* C, const size_t ldc){ 
     1417                return fgemm (F, ta, tb, m, n ,k, alpha, A, lda, B, ldb, beta, C, ldc, WinoSteps (MIN(m,MIN(k,n)))); 
     1418        } 
     1419 
     1420        template<> 
     1421        inline float*  
     1422        FFLAS::fgemm<UnparametricField<float> > ( const UnparametricField<float>& F, 
     1423                                                  const FFLAS_TRANSPOSE ta, 
     1424                                                  const FFLAS_TRANSPOSE tb, 
     1425                                                  const size_t m, 
     1426                                                  const size_t n, 
     1427                                                  const size_t k, 
     1428                                                  const float alpha, 
     1429                                                  const float* A, const size_t lda, 
     1430                                                  const float* B, const size_t ldb,  
     1431                                                  const float beta, 
     1432                                                  float* C, const size_t ldc){ 
     1433                return fgemm (F, ta, tb, m, n ,k, alpha, A, lda, B, ldb, beta, C, ldc, WinoSteps (MIN(m,MIN(k,n)))); 
     1434        } 
     1435         
    13531436         
    13541437template < class Field >  

  • include/fflas-ffpack/fflas_ftrmm.inl

    r21 r36  
    22 
    33/* fflas/fflas_ftrmm.inl 
    4  * Copyright (C) 2005 Clement Pernet 
     4 * Copyright (C) 2007 Clement Pernet 
    55 * 
    66 * Written by Clement Pernet <Clement.Pernet@imag.fr> 
    … …  
    99 */ 
    1010 
     11 
    1112//--------------------------------------------------------------------- 
    1213// ftrmm: TRiangular Matrix Multiply 
    1314// Computes  B <- alpha.op(A).B,  B <- alpha.B.op(A) 
    1415// B is M*N, A is M*M if Side==FflasLeft, N*N if Side==FflasRight 
    15 // Warning :Assumes alpha==1 
    1616//--------------------------------------------------------------------- 
    1717template<class Field> 
    1818inline void 
    19 FFLAS::ftrmm(const Field& F, const FFLAS_SIDE Side, 
    20              const FFLAS_UPLO Uplo,  
    21              const FFLAS_TRANSPOSE TransA, 
    22              const FFLAS_DIAG Diag,  
    23              const size_t M, const size_t N, 
    24              const typename Field::Element alpha, 
    25              typename Field::Element * A, const size_t lda, 
    26              typename Field::Element * B, const size_t ldb){ 
    27          
     19FFLAS::ftrmm (const Field& F, const FFLAS_SIDE Side, 
     20              const FFLAS_UPLO Uplo,  
     21              const FFLAS_TRANSPOSE TransA, 
     22              const FFLAS_DIAG Diag,  
     23              const size_t M, const size_t N, 
     24&n