Diff of /Real/real.pd [e99cbd] .. [591b21] Maximize Restore

  Switch to unified view

a/Real/real.pd b/Real/real.pd
...
...
2
# If array not referenced, min 1.
2
# If array not referenced, min 1.
3
3
4
4
5
do('../Config');
5
do('../Config');
6
6
7
our $VERSION = '0.08_01';
7
our $VERSION = 0.04;
8
pp_setversion(qq{'$VERSION'});
9
$VERSION = eval $VERSION;
10
11
use PDL::Exporter;
8
use PDL::Exporter;
12
9
13
10
14
#TODO 
11
#TODO 
15
# dot
12
# dot
16
13
14
pp_setversion(0.04);
17
15
18
sub generate_code($){
16
sub generate_code($){
19
    if ($config{WITHOUT_THREAD}){
17
    if ($config{WITHOUT_THREAD}){
20
    return '
18
    return '
21
        #if 0
19
        #if 0
...
...
42
40
43
41
44
pp_addhdr('
42
pp_addhdr('
45
#include <math.h>
43
#include <math.h>
46
44
47
#if defined(PDL_CORE_VERSION) && PDL_CORE_VERSION < 10
48
typedef PDL_Long PDL_Indx;
49
#endif
50
51
/* avoid annoying warnings */
45
/* avoid annoying warnings */
52
typedef PDL_Long logical;
46
typedef PDL_Long logical;
53
typedef PDL_Long integer;
47
typedef PDL_Long integer;
54
typedef PDL_Long ftnlen;
48
typedef PDL_Long ftnlen;
55
49
...
...
89
 BEGIN{ $^W = $warningFlag;}
83
 BEGIN{ $^W = $warningFlag;}
90
84
91
}
85
}
92
86
93
87
94
95
=encoding Latin-1
96
88
97
=head1 NAME
89
=head1 NAME
98
90
99
PDL::LinearAlgebra::Real - PDL interface to the real lapack linear algebra programming library
91
PDL::LinearAlgebra::Real - PDL interface to the real lapack linear algebra programming library
100
92
...
...
180
172
181
173
182
        $TFD(sgesvd_,dgesvd_)(
174
        $TFD(sgesvd_,dgesvd_)(
183
        &trau,
175
        &trau,
184
        &travt,
176
        &travt,
185
        &(integer){$PRIV(__m_size)},
177
        &$PRIV(__m_size),
186
        &(integer){$PRIV(__n_size)},
178
        &$PRIV(__n_size),
187
        $P(A),
179
        $P(A),
188
        &(integer){$PRIV(__m_size)},
180
        &$PRIV(__m_size),
189
        $P(s),
181
        $P(s),
190
        $P(U),
182
        $P(U),
191
        &(integer){$PRIV(__p_size)},
183
        &$PRIV(__p_size),
192
        $P(VT),
184
        $P(VT),
193
        &(integer){$PRIV(__s_size)},
185
        &$PRIV(__s_size),
194
        &tmp_work,
186
        &tmp_work,
195
        &lwork,
187
        &lwork,
196
        $P(info));
188
        $P(info));
197
189
198
        lwork = (integer )tmp_work;
190
        lwork = (integer )tmp_work;
...
...
206
        double *work = (double *)malloc(lwork *  sizeof(double));
198
        double *work = (double *)malloc(lwork *  sizeof(double));
207
             %}
199
             %}
208
        $TFD(sgesvd_,dgesvd_)(
200
        $TFD(sgesvd_,dgesvd_)(
209
        &trau,
201
        &trau,
210
        &travt,
202
        &travt,
211
        &(integer){$PRIV(__m_size)},
203
        &$PRIV(__m_size),
212
        &(integer){$PRIV(__n_size)},
204
        &$PRIV(__n_size),
213
        $P(A),
205
        $P(A),
214
        &(integer){$PRIV(__m_size)},
206
        &$PRIV(__m_size),
215
        $P(s),
207
        $P(s),
216
        $P(U),
208
        $P(U),
217
        &(integer){$PRIV(__p_size)},
209
        &$PRIV(__p_size),
218
        $P(VT),
210
        $P(VT),
219
        &(integer){$PRIV(__s_size)},
211
        &$PRIV(__s_size),
220
        work,
212
        work,
221
        &lwork,
213
        &lwork,
222
        $P(info));
214
        $P(info));
223
        free(work);
215
        free(work);
224
        }
216
        }
...
...
354
346
355
        }
347
        }
356
348
357
        $TFD(sgesdd_,dgesdd_)(
349
        $TFD(sgesdd_,dgesdd_)(
358
        &tra,
350
        &tra,
359
        &(integer){$PRIV(__m_size)},
351
        &$PRIV(__m_size),
360
        &(integer){$PRIV(__n_size)},
352
        &$PRIV(__n_size),
361
        $P(A),
353
        $P(A),
362
        &(integer){$PRIV(__m_size)},
354
        &$PRIV(__m_size),
363
        $P(s),
355
        $P(s),
364
        $P(U),
356
        $P(U),
365
        &(integer){$PRIV(__p_size)},
357
        &$PRIV(__p_size),
366
        $P(VT),
358
        $P(VT),
367
        &(integer){$PRIV(__s_size)},
359
        &$PRIV(__s_size),
368
        &tmp_work,
360
        &tmp_work,
369
        &lwork,
361
        &lwork,
370
        iwork,
362
        iwork,
371
        $P(info));
363
        $P(info));
372
364
...
...
390
            }
382
            }
391
            work = (double *) malloc(lwork *  sizeof(double));
383
            work = (double *) malloc(lwork *  sizeof(double));
392
             %}
384
             %}
393
        $TFD(sgesdd_,dgesdd_)(
385
        $TFD(sgesdd_,dgesdd_)(
394
        &tra,
386
        &tra,
395
        &(integer){$PRIV(__m_size)},
387
        &$PRIV(__m_size),
396
        &(integer){$PRIV(__n_size)},
388
        &$PRIV(__n_size),
397
        $P(A),
389
        $P(A),
398
        &(integer){$PRIV(__m_size)},
390
        &$PRIV(__m_size),
399
        $P(s),
391
        $P(s),
400
        $P(U),
392
        $P(U),
401
        &(integer){$PRIV(__p_size)},
393
        &$PRIV(__p_size),
402
        $P(VT),
394
        $P(VT),
403
        &(integer){$PRIV(__s_size)},
395
        &$PRIV(__s_size),
404
        work,
396
        work,
405
        &lwork,
397
        &lwork,
406
        iwork,
398
        iwork,
407
        $P(info));
399
        $P(info));
408
        free(work);
400
        free(work);
...
...
531
        
523
        
532
        $TFD(sggsvd_,dggsvd_)(
524
        $TFD(sggsvd_,dggsvd_)(
533
        &pjobu,
525
        &pjobu,
534
        &pjobv,
526
        &pjobv,
535
        &pjobq,
527
        &pjobq,
536
        &(integer){$PRIV(__m_size)},
528
        &$PRIV(__m_size),
537
        &(integer){$PRIV(__n_size)},
529
        &$PRIV(__n_size),
538
        &(integer){$PRIV(__p_size)},
530
        &$PRIV(__p_size),
539
        $P(k),
531
        $P(k),
540
        $P(l),
532
        $P(l),
541
        $P(A),
533
        $P(A),
542
        &(integer){$PRIV(__m_size)},
534
        &$PRIV(__m_size),
543
        $P(B),
535
        $P(B),
544
        &(integer){$PRIV(__p_size)},
536
        &$PRIV(__p_size),
545
        $P(alpha),
537
        $P(alpha),
546
        $P(beta),
538
        $P(beta),
547
        $P(U),
539
        $P(U),
548
        &(integer){$PRIV(__q_size)},
540
        &$PRIV(__q_size),
549
        $P(V),
541
        $P(V),
550
        &(integer){$PRIV(__s_size)},
542
        &$PRIV(__s_size),
551
        $P(Q),
543
        $P(Q),
552
        &(integer){$PRIV(__u_size)},
544
        &$PRIV(__u_size),
553
        work,
545
        work,
554
        $P(iwork),
546
        $P(iwork),
555
        $P(info));
547
        $P(info));
556
        free(work);
548
        free(work);
557
',
549
',
...
...
756
            jvr = \'V\';
748
            jvr = \'V\';
757
749
758
        $TFD(sgeev_,dgeev_)(
750
        $TFD(sgeev_,dgeev_)(
759
        &jvl,
751
        &jvl,
760
        &jvr,
752
        &jvr,
761
        &(integer){$PRIV(__n_size)},
753
        &$PRIV(__n_size),
762
        $P(A),
754
        $P(A),
763
        &(integer){$PRIV(__n_size)},
755
        &$PRIV(__n_size),
764
        $P(wr),
756
        $P(wr),
765
        $P(wi),
757
        $P(wi),
766
        $P(vl),
758
        $P(vl),
767
        &(integer){$PRIV(__m_size)},
759
        &$PRIV(__m_size),
768
        $P(vr),
760
        $P(vr),
769
        &(integer){$PRIV(__p_size)},
761
        &$PRIV(__p_size),
770
        &tmp_work,
762
        &tmp_work,
771
        &lwork,
763
        &lwork,
772
        $P(info));
764
        $P(info));
773
765
774
        lwork = (integer )tmp_work;
766
        lwork = (integer )tmp_work;
...
...
782
        double *work = (double *)malloc(lwork *  sizeof(double));
774
        double *work = (double *)malloc(lwork *  sizeof(double));
783
             %}
775
             %}
784
        $TFD(sgeev_,dgeev_)(
776
        $TFD(sgeev_,dgeev_)(
785
        &jvl,
777
        &jvl,
786
        &jvr,
778
        &jvr,
787
        &(integer){$PRIV(__n_size)},
779
        &$PRIV(__n_size),
788
        $P(A),
780
        $P(A),
789
        &(integer){$PRIV(__n_size)},
781
        &$PRIV(__n_size),
790
        $P(wr),
782
        $P(wr),
791
        $P(wi),
783
        $P(wi),
792
        $P(vl),
784
        $P(vl),
793
        &(integer){$PRIV(__m_size)},
785
        &$PRIV(__m_size),
794
        $P(vr),
786
        $P(vr),
795
        &(integer){$PRIV(__p_size)},
787
        &$PRIV(__p_size),
796
        work,
788
        work,
797
        &lwork,
789
        &lwork,
798
        $P(info));
790
        $P(info));
799
        free(work);
791
        free(work);
800
        }
792
        }
...
...
944
        $TFD(sgeevx_,dgeevx_)(
936
        $TFD(sgeevx_,dgeevx_)(
945
        &balanc,
937
        &balanc,
946
        &jvl,
938
        &jvl,
947
        &jvr,
939
        &jvr,
948
        &sens,
940
        &sens,
949
        &(integer){$PRIV(__n_size)},
941
        &$PRIV(__n_size),
950
        $P(A),
942
        $P(A),
951
        &(integer){$PRIV(__n_size)},
943
        &$PRIV(__n_size),
952
        $P(wr),
944
        $P(wr),
953
        $P(wi),
945
        $P(wi),
954
        $P(vl),
946
        $P(vl),
955
        &(integer){$PRIV(__m_size)},
947
        &$PRIV(__m_size),
956
        $P(vr),
948
        $P(vr),
957
        &(integer){$PRIV(__p_size)},
949
        &$PRIV(__p_size),
958
        $P(ilo),
950
        $P(ilo),
959
        $P(ihi),
951
        $P(ihi),
960
        $P(scale),
952
        $P(scale),
961
        $P(abnrm),
953
        $P(abnrm),
962
        $P(rconde),
954
        $P(rconde),
...
...
979
        $TFD(sgeevx_,dgeevx_)(
971
        $TFD(sgeevx_,dgeevx_)(
980
        &balanc,
972
        &balanc,
981
        &jvl,
973
        &jvl,
982
        &jvr,
974
        &jvr,
983
        &sens,
975
        &sens,
984
        &(integer){$PRIV(__n_size)},
976
        &$PRIV(__n_size),
985
        $P(A),
977
        $P(A),
986
        &(integer){$PRIV(__n_size)},
978
        &$PRIV(__n_size),
987
        $P(wr),
979
        $P(wr),
988
        $P(wi),
980
        $P(wi),
989
        $P(vl),
981
        $P(vl),
990
        &(integer){$PRIV(__m_size)},
982
        &$PRIV(__m_size),
991
        $P(vr),
983
        $P(vr),
992
        &(integer){$PRIV(__p_size)},
984
        &$PRIV(__p_size),
993
        $P(ilo),
985
        $P(ilo),
994
        $P(ihi),
986
        $P(ihi),
995
        $P(scale),
987
        $P(scale),
996
        $P(abnrm),
988
        $P(abnrm),
997
        $P(rconde),
989
        $P(rconde),
...
...
1191
            pjobvr = \'V\';
1183
            pjobvr = \'V\';
1192
1184
1193
        $TFD(sggev_,dggev_)(
1185
        $TFD(sggev_,dggev_)(
1194
        &pjobvl,
1186
        &pjobvl,
1195
        &pjobvr,
1187
        &pjobvr,
1196
        &(integer){$PRIV(__n_size)},
1188
        &$PRIV(__n_size),
1197
        $P(A),
1189
        $P(A),
1198
        &(integer){$PRIV(__n_size)},
1190
        &$PRIV(__n_size),
1199
        $P(B),
1191
        $P(B),
1200
        &(integer){$PRIV(__n_size)},
1192
        &$PRIV(__n_size),
1201
        $P(alphar),
1193
        $P(alphar),
1202
        $P(alphai),
1194
        $P(alphai),
1203
        $P(beta),
1195
        $P(beta),
1204
        $P(VL),
1196
        $P(VL),
1205
        &(integer){$PRIV(__m_size)},
1197
        &$PRIV(__m_size),
1206
        $P(VR),
1198
        $P(VR),
1207
        &(integer){$PRIV(__p_size)},
1199
        &$PRIV(__p_size),
1208
        &tmp_work,
1200
        &tmp_work,
1209
        &lwork,
1201
        &lwork,
1210
        $P(info));
1202
        $P(info));
1211
1203
1212
        lwork = (integer )tmp_work;
1204
        lwork = (integer )tmp_work;
...
...
1219
                %}
1211
                %}
1220
1212
1221
        $TFD(sggev_,dggev_)(
1213
        $TFD(sggev_,dggev_)(
1222
        &pjobvl,
1214
        &pjobvl,
1223
        &pjobvr,
1215
        &pjobvr,
1224
        &(integer){$PRIV(__n_size)},
1216
        &$PRIV(__n_size),
1225
        $P(A),
1217
        $P(A),
1226
        &(integer){$PRIV(__n_size)},
1218
        &$PRIV(__n_size),
1227
        $P(B),
1219
        $P(B),
1228
        &(integer){$PRIV(__n_size)},
1220
        &$PRIV(__n_size),
1229
        $P(alphar),
1221
        $P(alphar),
1230
        $P(alphai),
1222
        $P(alphai),
1231
        $P(beta),
1223
        $P(beta),
1232
        $P(VL),
1224
        $P(VL),
1233
        &(integer){$PRIV(__m_size)},
1225
        &$PRIV(__m_size),
1234
        $P(VR),
1226
        $P(VR),
1235
        &(integer){$PRIV(__p_size)},
1227
        &$PRIV(__p_size),
1236
        work,
1228
        work,
1237
        &lwork,
1229
        &lwork,
1238
        $P(info));
1230
        $P(info));
1239
        free(work);
1231
        free(work);
1240
        }
1232
        }
...
...
1407
        $TFD(sggevx_,dggevx_)(
1399
        $TFD(sggevx_,dggevx_)(
1408
        &pbalanc,
1400
        &pbalanc,
1409
        &pjobvl,
1401
        &pjobvl,
1410
        &pjobvr,
1402
        &pjobvr,
1411
        &psens,
1403
        &psens,
1412
        &(integer){$PRIV(__n_size)},
1404
        &$PRIV(__n_size),
1413
        $P(A),
1405
        $P(A),
1414
        &(integer){$PRIV(__n_size)},
1406
        &$PRIV(__n_size),
1415
        $P(B),
1407
        $P(B),
1416
        &(integer){$PRIV(__n_size)},
1408
        &$PRIV(__n_size),
1417
        $P(alphar),
1409
        $P(alphar),
1418
        $P(alphai),
1410
        $P(alphai),
1419
        $P(beta),
1411
        $P(beta),
1420
        $P(VL),
1412
        $P(VL),
1421
        &(integer){$PRIV(__m_size)},
1413
        &$PRIV(__m_size),
1422
        $P(VR),
1414
        $P(VR),
1423
        &(integer){$PRIV(__p_size)},
1415
        &$PRIV(__p_size),
1424
        $P(ilo),
1416
        $P(ilo),
1425
        $P(ihi),
1417
        $P(ihi),
1426
        $P(lscale),
1418
        $P(lscale),
1427
        $P(rscale),
1419
        $P(rscale),
1428
        $P(abnrm),
1420
        $P(abnrm),
...
...
1447
        $TFD(sggevx_,dggevx_)(
1439
        $TFD(sggevx_,dggevx_)(
1448
        &pbalanc,
1440
        &pbalanc,
1449
        &pjobvl,
1441
        &pjobvl,
1450
        &pjobvr,
1442
        &pjobvr,
1451
        &psens,
1443
        &psens,
1452
        &(integer){$PRIV(__n_size)},
1444
        &$PRIV(__n_size),
1453
        $P(A),
1445
        $P(A),
1454
        &(integer){$PRIV(__n_size)},
1446
        &$PRIV(__n_size),
1455
        $P(B),
1447
        $P(B),
1456
        &(integer){$PRIV(__n_size)},
1448
        &$PRIV(__n_size),
1457
        $P(alphar),
1449
        $P(alphar),
1458
        $P(alphai),
1450
        $P(alphai),
1459
        $P(beta),
1451
        $P(beta),
1460
        $P(VL),
1452
        $P(VL),
1461
        &(integer){$PRIV(__m_size)},
1453
        &$PRIV(__m_size),
1462
        $P(VR),
1454
        $P(VR),
1463
        &(integer){$PRIV(__p_size)},
1455
        &$PRIV(__p_size),
1464
        $P(ilo),
1456
        $P(ilo),
1465
        $P(ihi),
1457
        $P(ihi),
1466
        $P(lscale),
1458
        $P(lscale),
1467
        $P(rscale),
1459
        $P(rscale),
1468
        $P(abnrm),
1460
        $P(abnrm),
...
...
1797
             types(F) %{
1789
             types(F) %{
1798
        sgees_(
1790
        sgees_(
1799
        &jvs,
1791
        &jvs,
1800
        &psort,
1792
        &psort,
1801
        fselection_wrapper,
1793
        fselection_wrapper,
1802
        &(integer){$PRIV(__n_size)},
1794
        &$PRIV(__n_size),
1803
        $P(A),
1795
        $P(A),
1804
        &(integer){$PRIV(__n_size)},
1796
        &$PRIV(__n_size),
1805
        $P(sdim),
1797
        $P(sdim),
1806
        $P(wr),
1798
        $P(wr),
1807
        $P(wi),
1799
        $P(wi),
1808
        $P(vs),
1800
        $P(vs),
1809
        &(integer){$PRIV(__p_size)},
1801
        &$PRIV(__p_size),
1810
        &tmp_work,
1802
        &tmp_work,
1811
        &lwork,
1803
        &lwork,
1812
        bwork,
1804
        bwork,
1813
        $P(info));
1805
        $P(info));
1814
        %}
1806
        %}
1815
         types(D) %{
1807
         types(D) %{
1816
        dgees_(
1808
        dgees_(
1817
        &jvs,
1809
        &jvs,
1818
        &psort,
1810
        &psort,
1819
        dselection_wrapper,
1811
        dselection_wrapper,
1820
        &(integer){$PRIV(__n_size)},
1812
        &$PRIV(__n_size),
1821
        $P(A),
1813
        $P(A),
1822
        &(integer){$PRIV(__n_size)},
1814
        &$PRIV(__n_size),
1823
        $P(sdim),
1815
        $P(sdim),
1824
        $P(wr),
1816
        $P(wr),
1825
        $P(wi),
1817
        $P(wi),
1826
        $P(vs),
1818
        $P(vs),
1827
        &(integer){$PRIV(__p_size)},
1819
        &$PRIV(__p_size),
1828
        &tmp_work,
1820
        &tmp_work,
1829
        &lwork,
1821
        &lwork,
1830
        bwork,
1822
        bwork,
1831
        $P(info));
1823
        $P(info));
1832
        %}
1824
        %}
...
...
1845
        types(F) %{
1837
        types(F) %{
1846
        sgees_(
1838
        sgees_(
1847
        &jvs,
1839
        &jvs,
1848
        &psort,
1840
        &psort,
1849
        fselection_wrapper,
1841
        fselection_wrapper,
1850
        &(integer){$PRIV(__n_size)},
1842
        &$PRIV(__n_size),
1851
        $P(A),
1843
        $P(A),
1852
        &(integer){$PRIV(__n_size)},
1844
        &$PRIV(__n_size),
1853
        $P(sdim),
1845
        $P(sdim),
1854
        $P(wr),
1846
        $P(wr),
1855
        $P(wi),
1847
        $P(wi),
1856
        $P(vs),
1848
        $P(vs),
1857
        &(integer){$PRIV(__p_size)},
1849
        &$PRIV(__p_size),
1858
        work,
1850
        work,
1859
        &lwork,
1851
        &lwork,
1860
        bwork,
1852
        bwork,
1861
        $P(info));
1853
        $P(info));
1862
        %}
1854
        %}
...
...
1864
        types(D) %{
1856
        types(D) %{
1865
        dgees_(
1857
        dgees_(
1866
        &jvs,
1858
        &jvs,
1867
        &psort,
1859
        &psort,
1868
        dselection_wrapper,
1860
        dselection_wrapper,
1869
        &(integer){$PRIV(__n_size)},
1861
        &$PRIV(__n_size),
1870
        $P(A),
1862
        $P(A),
1871
        &(integer){$PRIV(__n_size)},
1863
        &$PRIV(__n_size),
1872
        $P(sdim),
1864
        $P(sdim),
1873
        $P(wr),
1865
        $P(wr),
1874
        $P(wi),
1866
        $P(wi),
1875
        $P(vs),
1867
        $P(vs),
1876
        &(integer){$PRIV(__p_size)},
1868
        &$PRIV(__p_size),
1877
        work,
1869
        work,
1878
        &lwork,
1870
        &lwork,
1879
        bwork,
1871
        bwork,
1880
        $P(info));
1872
        $P(info));
1881
        %}
1873
        %}
...
...
2061
        dgeesx_(
2053
        dgeesx_(
2062
        &jvs,
2054
        &jvs,
2063
        &psort,
2055
        &psort,
2064
        dselection_wrapper,
2056
        dselection_wrapper,
2065
        &sens,
2057
        &sens,
2066
        &(integer){$PRIV(__n_size)},
2058
        &$PRIV(__n_size),
2067
        $P(A),
2059
        $P(A),
2068
        &(integer){$PRIV(__n_size)},
2060
        &$PRIV(__n_size),
2069
        $P(sdim),
2061
        $P(sdim),
2070
        $P(wr),
2062
        $P(wr),
2071
        $P(wi),
2063
        $P(wi),
2072
        $P(vs),
2064
        $P(vs),
2073
        &(integer){$PRIV(__p_size)},
2065
        &$PRIV(__p_size),
2074
        $P(rconde),
2066
        $P(rconde),
2075
        $P(rcondv),
2067
        $P(rcondv),
2076
        work,
2068
        work,
2077
        &lwork,
2069
        &lwork,
2078
        iwork,
2070
        iwork,
...
...
2086
        sgeesx_(
2078
        sgeesx_(
2087
        &jvs,
2079
        &jvs,
2088
        &psort,
2080
        &psort,
2089
        fselection_wrapper,
2081
        fselection_wrapper,
2090
        &sens,
2082
        &sens,
2091
        &(integer){$PRIV(__n_size)},
2083
        &$PRIV(__n_size),
2092
        $P(A),
2084
        $P(A),
2093
        &(integer){$PRIV(__n_size)},
2085
        &$PRIV(__n_size),
2094
        $P(sdim),
2086
        $P(sdim),
2095
        $P(wr),
2087
        $P(wr),
2096
        $P(wi),
2088
        $P(wi),
2097
        $P(vs),
2089
        $P(vs),
2098
        &(integer){$PRIV(__p_size)},
2090
        &$PRIV(__p_size),
2099
        $P(rconde),
2091
        $P(rconde),
2100
        $P(rcondv),
2092
        $P(rcondv),
2101
        work,
2093
        work,
2102
        &lwork,
2094
        &lwork,
2103
        iwork,
2095
        iwork,
...
...
2340
        sgges_(
2332
        sgges_(
2341
        &pjobvsl,
2333
        &pjobvsl,
2342
        &pjobvsr,
2334
        &pjobvsr,
2343
        &psort,
2335
        &psort,
2344
        fgselection_wrapper,
2336
        fgselection_wrapper,
2345
        &(integer){$PRIV(__n_size)},
2337
        &$PRIV(__n_size),
2346
        $P(A),
2338
        $P(A),
2347
        &(integer){$PRIV(__n_size)},
2339
        &$PRIV(__n_size),
2348
        $P(B),
2340
        $P(B),
2349
        &(integer){$PRIV(__n_size)},
2341
        &$PRIV(__n_size),
2350
        $P(sdim),
2342
        $P(sdim),
2351
        $P(alphar),
2343
        $P(alphar),
2352
        $P(alphai),
2344
        $P(alphai),
2353
        $P(beta),
2345
        $P(beta),
2354
        $P(VSL),
2346
        $P(VSL),
2355
        &(integer){$PRIV(__m_size)},
2347
        &$PRIV(__m_size),
2356
        $P(VSR),
2348
        $P(VSR),
2357
        &(integer){$PRIV(__p_size)},
2349
        &$PRIV(__p_size),
2358
        &tmp_work,
2350
        &tmp_work,
2359
        &lwork,
2351
        &lwork,
2360
        bwork,
2352
        bwork,
2361
        $P(info));
2353
        $P(info));
2362
        %}
2354
        %}
...
...
2364
        dgges_(
2356
        dgges_(
2365
        &pjobvsl,
2357
        &pjobvsl,
2366
        &pjobvsr,
2358
        &pjobvsr,
2367
        &psort,
2359
        &psort,
2368
        dgselection_wrapper,
2360
        dgselection_wrapper,
2369
        &(integer){$PRIV(__n_size)},
2361
        &$PRIV(__n_size),
2370
        $P(A),
2362
        $P(A),
2371
        &(integer){$PRIV(__n_size)},
2363
        &$PRIV(__n_size),
2372
        $P(B),
2364
        $P(B),
2373
        &(integer){$PRIV(__n_size)},
2365
        &$PRIV(__n_size),
2374
        $P(sdim),
2366
        $P(sdim),
2375
        $P(alphar),
2367
        $P(alphar),
2376
        $P(alphai),
2368
        $P(alphai),
2377
        $P(beta),
2369
        $P(beta),
2378
        $P(VSL),
2370
        $P(VSL),
2379
        &(integer){$PRIV(__m_size)},
2371
        &$PRIV(__m_size),
2380
        $P(VSR),
2372
        $P(VSR),
2381
        &(integer){$PRIV(__p_size)},
2373
        &$PRIV(__p_size),
2382
        &tmp_work,
2374
        &tmp_work,
2383
        &lwork,
2375
        &lwork,
2384
        bwork,
2376
        bwork,
2385
        $P(info));
2377
        $P(info));
2386
        %}
2378
        %}
...
...
2397
        sgges_(
2389
        sgges_(
2398
        &pjobvsl,
2390
        &pjobvsl,
2399
        &pjobvsr,
2391
        &pjobvsr,
2400
        &psort,
2392
        &psort,
2401
        fgselection_wrapper,
2393
        fgselection_wrapper,
2402
        &(integer){$PRIV(__n_size)},
2394
        &$PRIV(__n_size),
2403
        $P(A),
2395
        $P(A),
2404
        &(integer){$PRIV(__n_size)},
2396
        &$PRIV(__n_size),
2405
        $P(B),
2397
        $P(B),
2406
        &(integer){$PRIV(__n_size)},
2398
        &$PRIV(__n_size),
2407
        $P(sdim),
2399
        $P(sdim),
2408
        $P(alphar),
2400
        $P(alphar),
2409
        $P(alphai),
2401
        $P(alphai),
2410
        $P(beta),
2402
        $P(beta),
2411
        $P(VSL),
2403
        $P(VSL),
2412
        &(integer){$PRIV(__m_size)},
2404
        &$PRIV(__m_size),
2413
        $P(VSR),
2405
        $P(VSR),
2414
        &(integer){$PRIV(__p_size)},
2406
        &$PRIV(__p_size),
2415
        work,
2407
        work,
2416
        &lwork,
2408
        &lwork,
2417
        bwork,
2409
        bwork,
2418
        $P(info));
2410
        $P(info));
2419
        %}
2411
        %}
...
...
2422
        dgges_(
2414
        dgges_(
2423
        &pjobvsl,
2415
        &pjobvsl,
2424
        &pjobvsr,
2416
        &pjobvsr,
2425
        &psort,
2417
        &psort,
2426
        dgselection_wrapper,
2418
        dgselection_wrapper,
2427
        &(integer){$PRIV(__n_size)},
2419
        &$PRIV(__n_size),
2428
        $P(A),
2420
        $P(A),
2429
        &(integer){$PRIV(__n_size)},
2421
        &$PRIV(__n_size),
2430
        $P(B),
2422
        $P(B),
2431
        &(integer){$PRIV(__n_size)},
2423
        &$PRIV(__n_size),
2432
        $P(sdim),
2424
        $P(sdim),
2433
        $P(alphar),
2425
        $P(alphar),
2434
        $P(alphai),
2426
        $P(alphai),
2435
        $P(beta),
2427
        $P(beta),
2436
        $P(VSL),
2428
        $P(VSL),
2437
        &(integer){$PRIV(__m_size)},
2429
        &$PRIV(__m_size),
2438
        $P(VSR),
2430
        $P(VSR),
2439
        &(integer){$PRIV(__p_size)},
2431
        &$PRIV(__p_size),
2440
        work,
2432
        work,
2441
        &lwork,
2433
        &lwork,
2442
        bwork,
2434
        bwork,
2443
        $P(info));
2435
        $P(info));
2444
        %}
2436
        %}
...
...
2664
        // The actual updated release (clapack 09/20/2000) do not allow
2656
        // The actual updated release (clapack 09/20/2000) do not allow
2665
        // querying the workspace. See release notes of Lapack
2657
        // querying the workspace. See release notes of Lapack
2666
        // for this feature.
2658
        // for this feature.
2667
2659
2668
        minwrk = ($SIZE(n) + 1 << 3) + 16;
2660
        minwrk = ($SIZE(n) + 1 << 3) + 16;
2669
        maxwrk = ($SIZE(n) + 1) * 7 + $SIZE(n) * (integer ) ilaenv_(&c__1, "DGEQRF", " ", &(integer){$PRIV(__n_size)}, &c__1,
2661
        maxwrk = ($SIZE(n) + 1) * 7 + $SIZE(n) * (integer ) ilaenv_(&c__1, "DGEQRF", " ", &$PRIV(__n_size), &c__1,
2670
        &(integer){$PRIV(__n_size)}, &c__0, (ftnlen)6, (ftnlen)1) + 16;
2662
        &$PRIV(__n_size), &c__0, (ftnlen)6, (ftnlen)1) + 16;
2671
2663
2672
        if ($jobvsl())
2664
        if ($jobvsl())
2673
        {
2665
        {
2674
            integer i__1 = maxwrk;
2666
            integer i__1 = maxwrk;
2675
            integer i__2 = minwrk + $SIZE(n) * (integer )ilaenv_(&c__1, "DORGQR"
2667
            integer i__2 = minwrk + $SIZE(n) * (integer )ilaenv_(&c__1, "DORGQR"
2676
                    , " ", &(integer){$PRIV(__n_size)}, &c__1, &(integer){$PRIV(__n_size)}, &c_n1, (ftnlen)6, (ftnlen)1);
2668
                    , " ", &$PRIV(__n_size), &c__1, &$PRIV(__n_size), &c_n1, (ftnlen)6, (ftnlen)1);
2677
                maxwrk = (integer ) max(i__1,i__2);
2669
                maxwrk = (integer ) max(i__1,i__2);
2678
            pjobvsl = \'V\';
2670
            pjobvsl = \'V\';
2679
        }
2671
        }
2680
        lwork =  (integer ) max(maxwrk,minwrk);
2672
        lwork =  (integer ) max(maxwrk,minwrk);
2681
2673
...
...
2686
        &pjobvsl,
2678
        &pjobvsl,
2687
        &pjobvsr,
2679
        &pjobvsr,
2688
        &psort,
2680
        &psort,
2689
        fgselection_wrapper,
2681
        fgselection_wrapper,
2690
        &psens,
2682
        &psens,
2691
        &(integer){$PRIV(__n_size)},
2683
        &$PRIV(__n_size),
2692
        $P(A),
2684
        $P(A),
2693
        &(integer){$PRIV(__n_size)},
2685
        &$PRIV(__n_size),
2694
        $P(B),
2686
        $P(B),
2695
        &(integer){$PRIV(__n_size)},
2687
        &$PRIV(__n_size),
2696
        $P(sdim),
2688
        $P(sdim),
2697
        $P(alphar),
2689
        $P(alphar),
2698
        $P(alphai),
2690
        $P(alphai),
2699
        $P(beta),
2691
        $P(beta),
2700
        $P(VSL),
2692
        $P(VSL),
2701
        &(integer){$PRIV(__m_size)},
2693
        &$PRIV(__m_size),
2702
        $P(VSR),
2694
        $P(VSR),
2703
        &(integer){$PRIV(__p_size)},
2695
        &$PRIV(__p_size),
2704
        $P(rconde),
2696
        $P(rconde),
2705
        $P(rcondv),
2697
        $P(rcondv),
2706
        work,
2698
        work,
2707
        &lwork,
2699
        &lwork,
2708
        iwork,
2700
        iwork,
...
...
2717
        &pjobvsl,
2709
        &pjobvsl,
2718
        &pjobvsr,
2710
        &pjobvsr,
2719
        &psort,
2711
        &psort,
2720
        dgselection_wrapper,
2712
        dgselection_wrapper,
2721
        &psens,
2713
        &psens,
2722
        &(integer){$PRIV(__n_size)},
2714
        &$PRIV(__n_size),
2723
        $P(A),
2715
        $P(A),
2724
        &(integer){$PRIV(__n_size)},
2716
        &$PRIV(__n_size),
2725
        $P(B),
2717
        $P(B),
2726
        &(integer){$PRIV(__n_size)},
2718
        &$PRIV(__n_size),
2727
        $P(sdim),
2719
        $P(sdim),
2728
        $P(alphar),
2720
        $P(alphar),
2729
        $P(alphai),
2721
        $P(alphai),
2730
        $P(beta),
2722
        $P(beta),
2731
        $P(VSL),
2723
        $P(VSL),
2732
        &(integer){$PRIV(__m_size)},
2724
        &$PRIV(__m_size),
2733
        $P(VSR),
2725
        $P(VSR),
2734
        &(integer){$PRIV(__p_size)},
2726
        &$PRIV(__p_size),
2735
        $P(rconde),
2727
        $P(rconde),
2736
        $P(rcondv),
2728
        $P(rcondv),
2737
        work,
2729
        work,
2738
        &lwork,
2730
        &lwork,
2739
        iwork,
2731
        iwork,
...
...
2966
2958
2967
2959
2968
        $TFD(ssyev_,dsyev_)(
2960
        $TFD(ssyev_,dsyev_)(
2969
        &jz,
2961
        &jz,
2970
        &puplo,
2962
        &puplo,
2971
        &(integer){$PRIV(__n_size)},
2963
        &$PRIV(__n_size),
2972
        $P(A),
2964
        $P(A),
2973
        &(integer){$PRIV(__n_size)},
2965
        &$PRIV(__n_size),
2974
        $P(w),
2966
        $P(w),
2975
        &tmp_work,
2967
        &tmp_work,
2976
        &lwork,
2968
        &lwork,
2977
        $P(info));
2969
        $P(info));
2978
2970
...
...
2987
        double *work = (double *)malloc(lwork *  sizeof(double));
2979
        double *work = (double *)malloc(lwork *  sizeof(double));
2988
             %}
2980
             %}
2989
        $TFD(ssyev_,dsyev_)(
2981
        $TFD(ssyev_,dsyev_)(
2990
        &jz,
2982
        &jz,
2991
        &puplo,
2983
        &puplo,
2992
        &(integer){$PRIV(__n_size)},
2984
        &$PRIV(__n_size),
2993
        $P(A),
2985
        $P(A),
2994
        &(integer){$PRIV(__n_size)},
2986
        &$PRIV(__n_size),
2995
        $P(w),
2987
        $P(w),
2996
        work,
2988
        work,
2997
        &lwork,
2989
        &lwork,
2998
        $P(info));
2990
        $P(info));
2999
        free(work);
2991
        free(work);
...
...
3083
3075
3084
3076
3085
        $TFD(ssyevd_,dsyevd_)(
3077
        $TFD(ssyevd_,dsyevd_)(
3086
        &jz,
3078
        &jz,
3087
        &puplo,
3079
        &puplo,
3088
        &(integer){$PRIV(__n_size)},
3080
        &$PRIV(__n_size),
3089
        $P(A),
3081
        $P(A),
3090
        &(integer){$PRIV(__n_size)},
3082
        &$PRIV(__n_size),
3091
        $P(w),
3083
        $P(w),
3092
        &tmp_work,
3084
        &tmp_work,
3093
        &lwork,
3085
        &lwork,
3094
        &tmp_liwork,
3086
        &tmp_liwork,
3095
        &liwork,
3087
        &liwork,
...
...
3108
        double *work = (double *)malloc(lwork *  sizeof(double));
3100
        double *work = (double *)malloc(lwork *  sizeof(double));
3109
             %}
3101
             %}
3110
        $TFD(ssyevd_,dsyevd_)(
3102
        $TFD(ssyevd_,dsyevd_)(
3111
        &jz,
3103
        &jz,
3112
        &puplo,
3104
        &puplo,
3113
        &(integer){$PRIV(__n_size)},
3105
        &$PRIV(__n_size),
3114
        $P(A),
3106
        $P(A),
3115
        &(integer){$PRIV(__n_size)},
3107
        &$PRIV(__n_size),
3116
        $P(w),
3108
        $P(w),
3117
        work,
3109
        work,
3118
        &lwork,
3110
        &lwork,
3119
        iwork,
3111
        iwork,
3120
        &liwork,
3112
        &liwork,
...
...
3232
3224
3233
        $TFD(ssyevx_,dsyevx_)(
3225
        $TFD(ssyevx_,dsyevx_)(
3234
        &jz,
3226
        &jz,
3235
        &prange,
3227
        &prange,
3236
        &puplo,
3228
        &puplo,
3237
        &(integer){$PRIV(__n_size)},
3229
        &$PRIV(__n_size),
3238
        $P(A),
3230
        $P(A),
3239
        &(integer){$PRIV(__n_size)},
3231
        &$PRIV(__n_size),
3240
        $P(vl),
3232
        $P(vl),
3241
        $P(vu),
3233
        $P(vu),
3242
        $P(il),
3234
        $P(il),
3243
        $P(iu),
3235
        $P(iu),
3244
        $P(abstol),
3236
        $P(abstol),
3245
        $P(m),
3237
        $P(m),
3246
        $P(w),
3238
        $P(w),
3247
        $P(z),
3239
        $P(z),
3248
        &(integer){$PRIV(__p_size)},
3240
        &$PRIV(__p_size),
3249
        &tmp_work,
3241
        &tmp_work,
3250
        &lwork,
3242
        &lwork,
3251
        iwork,
3243
        iwork,
3252
        $P(ifail),
3244
        $P(ifail),
3253
        $P(info));
3245
        $P(info));
...
...
3264
             %}
3256
             %}
3265
        $TFD(ssyevx_,dsyevx_)(
3257
        $TFD(ssyevx_,dsyevx_)(
3266
        &jz,
3258
        &jz,
3267
        &prange,
3259
        &prange,
3268
        &puplo,
3260
        &puplo,
3269
        &(integer){$PRIV(__n_size)},
3261
        &$PRIV(__n_size),
3270
        $P(A),
3262
        $P(A),
3271
        &(integer){$PRIV(__n_size)},
3263
        &$PRIV(__n_size),
3272
        $P(vl),
3264
        $P(vl),
3273
        $P(vu),
3265
        $P(vu),
3274
        $P(il),
3266
        $P(il),
3275
        $P(iu),
3267
        $P(iu),
3276
        $P(abstol),
3268
        $P(abstol),
3277
        $P(m),
3269
        $P(m),
3278
        $P(w),
3270
        $P(w),
3279
        $P(z),
3271
        $P(z),
3280
        &(integer){$PRIV(__p_size)},
3272
        &$PRIV(__p_size),
3281
        work,
3273
        work,
3282
        &lwork,
3274
        &lwork,
3283
        iwork,
3275
        iwork,
3284
        $P(ifail),
3276
        $P(ifail),
3285
        $P(info));
3277
        $P(info));
...
...
3455
3447
3456
        $TFD(ssyevr_,dsyevr_)(
3448
        $TFD(ssyevr_,dsyevr_)(
3457
        &jz,
3449
        &jz,
3458
        &prange,
3450
        &prange,
3459
        &puplo,
3451
        &puplo,
3460
        &(integer){$PRIV(__n_size)},
3452
        &$PRIV(__n_size),
3461
        $P(A),
3453
        $P(A),
3462
        &(integer){$PRIV(__n_size)},
3454
        &$PRIV(__n_size),
3463
        $P(vl),
3455
        $P(vl),
3464
        $P(vu),
3456
        $P(vu),
3465
        $P(il),
3457
        $P(il),
3466
        $P(iu),
3458
        $P(iu),
3467
        $P(abstol),
3459
        $P(abstol),
3468
        $P(m),
3460
        $P(m),
3469
        $P(w),
3461
        $P(w),
3470
        $P(z),
3462
        $P(z),
3471
        &(integer){$PRIV(__p_size)},
3463
        &$PRIV(__p_size),
3472
        $P(isuppz),
3464
        $P(isuppz),
3473
        &tmp_work,
3465
        &tmp_work,
3474
        &lwork,
3466
        &lwork,
3475
        &tmp_iwork,
3467
        &tmp_iwork,
3476
        &liwork,
3468
        &liwork,
...
...
3491
3483
3492
        $TFD(ssyevr_,dsyevr_)(
3484
        $TFD(ssyevr_,dsyevr_)(
3493
        &jz,
3485
        &jz,
3494
        &prange,
3486
        &prange,
3495
        &puplo,
3487
        &puplo,
3496
        &(integer){$PRIV(__n_size)},
3488
        &$PRIV(__n_size),
3497
        $P(A),
3489
        $P(A),
3498
        &(integer){$PRIV(__n_size)},
3490
        &$PRIV(__n_size),
3499
        $P(vl),
3491
        $P(vl),
3500
        $P(vu),
3492
        $P(vu),
3501
        $P(il),
3493
        $P(il),
3502
        $P(iu),
3494
        $P(iu),
3503
        $P(abstol),
3495
        $P(abstol),
3504
        $P(m),
3496
        $P(m),
3505
        $P(w),
3497
        $P(w),
3506
        $P(z),
3498
        $P(z),
3507
        &(integer){$PRIV(__p_size)},
3499
        &$PRIV(__p_size),
3508
        $P(isuppz),
3500
        $P(isuppz),
3509
        work,
3501
        work,
3510
        &lwork,
3502
        &lwork,
3511
        iwork,
3503
        iwork,
3512
        &liwork,
3504
        &liwork,
...
...
3701
3693
3702
        $TFD(ssygv_,dsygv_)(
3694
        $TFD(ssygv_,dsygv_)(
3703
        $P(itype),
3695
        $P(itype),
3704
        &jz,
3696
        &jz,
3705
        &puplo,
3697
        &puplo,
3706
        &(integer){$PRIV(__n_size)},
3698
        &$PRIV(__n_size),
3707
        $P(A),
3699
        $P(A),
3708
        &(integer){$PRIV(__n_size)},
3700
        &$PRIV(__n_size),
3709
        $P(B),
3701
        $P(B),
3710
        &(integer){$PRIV(__n_size)},
3702
        &$PRIV(__n_size),
3711
        $P(w),
3703
        $P(w),
3712
        &tmp_work,
3704
        &tmp_work,
3713
        &lwork,
3705
        &lwork,
3714
        $P(info));
3706
        $P(info));
3715
3707
...
...
3725
             %}
3717
             %}
3726
        $TFD(ssygv_,dsygv_)(
3718
        $TFD(ssygv_,dsygv_)(
3727
        $P(itype),
3719
        $P(itype),
3728
        &jz,
3720
        &jz,
3729
        &puplo,
3721
        &puplo,
3730
        &(integer){$PRIV(__n_size)},
3722
        &$PRIV(__n_size),
3731
        $P(A),
3723
        $P(A),
3732
        &(integer){$PRIV(__n_size)},
3724
        &$PRIV(__n_size),
3733
        $P(B),
3725
        $P(B),
3734
        &(integer){$PRIV(__n_size)},
3726
        &$PRIV(__n_size),
3735
        $P(w),
3727
        $P(w),
3736
        work,
3728
        work,
3737
        &lwork,
3729
        &lwork,
3738
        $P(info));
3730
        $P(info));
3739
        free(work);
3731
        free(work);
...
...
3849
3841
3850
        $TFD(ssygvd_,dsygvd_)(
3842
        $TFD(ssygvd_,dsygvd_)(
3851
        $P(itype),
3843
        $P(itype),
3852
        &jz,
3844
        &jz,
3853
        &puplo,
3845
        &puplo,
3854
        &(integer){$PRIV(__n_size)},
3846
        &$PRIV(__n_size),
3855
        $P(A),
3847
        $P(A),
3856
        &(integer){$PRIV(__n_size)},
3848
        &$PRIV(__n_size),
3857
        $P(B),
3849
        $P(B),
3858
        &(integer){$PRIV(__n_size)},
3850
        &$PRIV(__n_size),
3859
        $P(w),
3851
        $P(w),
3860
        &tmp_work,
3852
        &tmp_work,
3861
        &lwork,
3853
        &lwork,
3862
        &tmp_iwork,
3854
        &tmp_iwork,
3863
        &liwork,
3855
        &liwork,
...
...
3878
             %}
3870
             %}
3879
        $TFD(ssygvd_,dsygvd_)(
3871
        $TFD(ssygvd_,dsygvd_)(
3880
        $P(itype),
3872
        $P(itype),
3881
        &jz,
3873
        &jz,
3882
        &puplo,
3874
        &puplo,
3883
        &(integer){$PRIV(__n_size)},
3875
        &$PRIV(__n_size),
3884
        $P(A),
3876
        $P(A),
3885
        &(integer){$PRIV(__n_size)},
3877
        &$PRIV(__n_size),
3886
        $P(B),
3878
        $P(B),
3887
        &(integer){$PRIV(__n_size)},
3879
        &$PRIV(__n_size),
3888
        $P(w),
3880
        $P(w),
3889
        work,
3881
        work,
3890
        &lwork,
3882
        &lwork,
3891
        iwork,
3883
        iwork,
3892
        &liwork,
3884
        &liwork,
...
...
4025
        $TFD(ssygvx_,dsygvx_)(
4017
        $TFD(ssygvx_,dsygvx_)(
4026
        $P(itype),
4018
        $P(itype),
4027
        &jz,
4019
        &jz,
4028
        &prange,
4020
        &prange,
4029
        &puplo,
4021
        &puplo,
4030
        &(integer){$PRIV(__n_size)},
4022
        &$PRIV(__n_size),
4031
        $P(A),
4023
        $P(A),
4032
        &(integer){$PRIV(__n_size)},
4024
        &$PRIV(__n_size),
4033
        $P(B),
4025
        $P(B),
4034
        &(integer){$PRIV(__n_size)},
4026
        &$PRIV(__n_size),
4035
        $P(vl),
4027
        $P(vl),
4036
        $P(vu),
4028
        $P(vu),
4037
        $P(il),
4029
        $P(il),
4038
        $P(iu),
4030
        $P(iu),
4039
        $P(abstol),
4031
        $P(abstol),
4040
        $P(m),
4032
        $P(m),
4041
        $P(w),
4033
        $P(w),
4042
        $P(Z),
4034
        $P(Z),
4043
        &(integer){$PRIV(__p_size)},
4035
        &$PRIV(__p_size),
4044
        &tmp_work,
4036
        &tmp_work,
4045
        &lwork,
4037
        &lwork,
4046
        iwork,
4038
        iwork,
4047
        $P(ifail),
4039
        $P(ifail),
4048
        $P(info));
4040
        $P(info));
...
...
4060
        $TFD(ssygvx_,dsygvx_)(
4052
        $TFD(ssygvx_,dsygvx_)(
4061
        $P(itype),
4053
        $P(itype),
4062
        &jz,
4054
        &jz,
4063
        &prange,
4055
        &prange,
4064
        &puplo,
4056
        &puplo,
4065
        &(integer){$PRIV(__n_size)},
4057
        &$PRIV(__n_size),
4066
        $P(A),
4058
        $P(A),
4067
        &(integer){$PRIV(__n_size)},
4059
        &$PRIV(__n_size),
4068
        $P(B),
4060
        $P(B),
4069
        &(integer){$PRIV(__n_size)},
4061
        &$PRIV(__n_size),
4070
        $P(vl),
4062
        $P(vl),
4071
        $P(vu),
4063
        $P(vu),
4072
        $P(il),
4064
        $P(il),
4073
        $P(iu),
4065
        $P(iu),
4074
        $P(abstol),
4066
        $P(abstol),
4075
        $P(m),
4067
        $P(m),
4076
        $P(w),
4068
        $P(w),
4077
        $P(Z),
4069
        $P(Z),
4078
        &(integer){$PRIV(__p_size)},
4070
        &$PRIV(__p_size),
4079
        work,
4071
        work,
4080
        &lwork,
4072
        &lwork,
4081
        iwork,
4073
        iwork,
4082
        $P(ifail),
4074
        $P(ifail),
4083
        $P(info));
4075
        $P(info));
...
...
4235
        extern int dgesv_(integer *n, integer *nrhs, double *a, integer
4227
        extern int dgesv_(integer *n, integer *nrhs, double *a, integer
4236
        *lda, integer *ipiv, double *b, integer *ldb, integer *info);
4228
        *lda, integer *ipiv, double *b, integer *ldb, integer *info);
4237
             %}
4229
             %}
4238
4230
4239
        $TFD(sgesv_,dgesv_)(
4231
        $TFD(sgesv_,dgesv_)(
4240
        &(integer){$PRIV(__n_size)},
4232
        &$PRIV(__n_size),
4241
        &(integer){$PRIV(__m_size)},
4233
        &$PRIV(__m_size),
4242
        $P(A),
4234
        $P(A),
4243
        &(integer){$PRIV(__n_size)},
4235
        &$PRIV(__n_size),
4244
        $P(ipiv),
4236
        $P(ipiv),
4245
        $P(B),
4237
        $P(B),
4246
        &(integer){$PRIV(__n_size)},
4238
        &$PRIV(__n_size),
4247
        $P(info));
4239
        $P(info));
4248
',
4240
',
4249
      Doc => '
4241
      Doc => '
4250
4242
4251
=for ref
4243
=for ref
...
...
4362
        iwork  = (integer *) malloc ($PRIV(__n_size)* sizeof (integer));
4354
        iwork  = (integer *) malloc ($PRIV(__n_size)* sizeof (integer));
4363
4355
4364
        $TFD(sgesvx_,dgesvx_)(
4356
        $TFD(sgesvx_,dgesvx_)(
4365
        &pfact,
4357
        &pfact,
4366
        &ptrans,
4358
        &ptrans,
4367
        &(integer){$PRIV(__n_size)},
4359
        &$PRIV(__n_size),
4368
        &(integer){$PRIV(__m_size)},
4360
        &$PRIV(__m_size),
4369
        $P(A),
4361
        $P(A),
4370
        &(integer){$PRIV(__n_size)},
4362
        &$PRIV(__n_size),
4371
        $P(af),
4363
        $P(af),
4372
        &(integer){$PRIV(__n_size)},
4364
        &$PRIV(__n_size),
4373
        $P(ipiv),
4365
        $P(ipiv),
4374
        &pequed,
4366
        &pequed,
4375
        $P(r),
4367
        $P(r),
4376
        $P(c),
4368
        $P(c),
4377
        $P(B),
4369
        $P(B),
4378
        &(integer){$PRIV(__n_size)},
4370
        &$PRIV(__n_size),
4379
        $P(X),
4371
        $P(X),
4380
        &(integer){$PRIV(__n_size)},
4372
        &$PRIV(__n_size),
4381
        $P(rcond),
4373
        $P(rcond),
4382
        $P(ferr),
4374
        $P(ferr),
4383
        $P(berr),
4375
        $P(berr),
4384
        work,
4376
        work,
4385
        iwork,
4377
        iwork,
...
...
4662
        if ($uplo())
4654
        if ($uplo())
4663
            puplo = \'L\';
4655
            puplo = \'L\';
4664
4656
4665
        $TFD(ssysv_,dsysv_)(
4657
        $TFD(ssysv_,dsysv_)(
4666
        &puplo,
4658
        &puplo,
4667
        &(integer){$PRIV(__n_size)},
4659
        &$PRIV(__n_size),
4668
        &(integer){$PRIV(__m_size)},
4660
        &$PRIV(__m_size),
4669
        $P(A),
4661
        $P(A),
4670
        &(integer){$PRIV(__n_size)},
4662
        &$PRIV(__n_size),
4671
        $P(ipiv),
4663
        $P(ipiv),
4672
        $P(B),
4664
        $P(B),
4673
        &(integer){$PRIV(__n_size)},
4665
        &$PRIV(__n_size),
4674
                &tmp_work,
4666
                &tmp_work,
4675
        &lwork,
4667
        &lwork,
4676
        $P(info));
4668
        $P(info));
4677
4669
4678
4670
...
...
4686
4678
4687
        double *work = (double *)malloc(lwork *  sizeof(double));
4679
        double *work = (double *)malloc(lwork *  sizeof(double));
4688
             %}
4680
             %}
4689
        $TFD(ssysv_,dsysv_)(
4681
        $TFD(ssysv_,dsysv_)(
4690
        &puplo,
4682
        &puplo,
4691
        &(integer){$PRIV(__n_size)},
4683
        &$PRIV(__n_size),
4692
        &(integer){$PRIV(__m_size)},
4684
        &$PRIV(__m_size),
4693
        $P(A),
4685
        $P(A),
4694
        &(integer){$PRIV(__n_size)},
4686
        &$PRIV(__n_size),
4695
        $P(ipiv),
4687
        $P(ipiv),
4696
        $P(B),
4688
        $P(B),
4697
        &(integer){$PRIV(__n_size)},
4689
        &$PRIV(__n_size),
4698
                work,
4690
                work,
4699
        &lwork,
4691
        &lwork,
4700
        $P(info));
4692
        $P(info));
4701
4693
4702
4694
...
...
4819
4811
4820
4812
4821
        $TFD(ssysvx_,dsysvx_)(
4813
        $TFD(ssysvx_,dsysvx_)(
4822
        &pfact,
4814
        &pfact,
4823
        &puplo,
4815
        &puplo,
4824
        &(integer){$PRIV(__n_size)},
4816
        &$PRIV(__n_size),
4825
        &(integer){$PRIV(__m_size)},
4817
        &$PRIV(__m_size),
4826
        $P(A),
4818
        $P(A),
4827
        &(integer){$PRIV(__n_size)},
4819
        &$PRIV(__n_size),
4828
        $P(af),
4820
        $P(af),
4829
        &(integer){$PRIV(__n_size)},
4821
        &$PRIV(__n_size),
4830
        $P(ipiv),
4822
        $P(ipiv),
4831
        $P(B),
4823
        $P(B),
4832
        &(integer){$PRIV(__n_size)},
4824
        &$PRIV(__n_size),
4833
        $P(X),
4825
        $P(X),
4834
        &(integer){$PRIV(__n_size)},
4826
        &$PRIV(__n_size),
4835
        $P(rcond),
4827
        $P(rcond),
4836
        $P(ferr),
4828
        $P(ferr),
4837
        $P(berr),
4829
        $P(berr),
4838
        &tmp_work,
4830
        &tmp_work,
4839
        &lwork,
4831
        &lwork,
...
...
4850
                %}
4842
                %}
4851
4843
4852
        $TFD(ssysvx_,dsysvx_)(
4844
        $TFD(ssysvx_,dsysvx_)(
4853
        &pfact,
4845
        &pfact,
4854
        &puplo,
4846
        &puplo,
4855
        &(integer){$PRIV(__n_size)},
4847
        &$PRIV(__n_size),
4856
        &(integer){$PRIV(__m_size)},
4848
        &$PRIV(__m_size),
4857
        $P(A),
4849
        $P(A),
4858
        &(integer){$PRIV(__n_size)},
4850
        &$PRIV(__n_size),
4859
        $P(af),
4851
        $P(af),
4860
        &(integer){$PRIV(__n_size)},
4852
        &$PRIV(__n_size),
4861
        $P(ipiv),
4853
        $P(ipiv),
4862
        $P(B),
4854
        $P(B),
4863
        &(integer){$PRIV(__n_size)},
4855
        &$PRIV(__n_size),
4864
        $P(X),
4856
        $P(X),
4865
        &(integer){$PRIV(__n_size)},
4857
        &$PRIV(__n_size),
4866
        $P(rcond),
4858
        $P(rcond),
4867
        $P(ferr),
4859
        $P(ferr),
4868
        $P(berr),
4860
        $P(berr),
4869
        work,
4861
        work,
4870
        &lwork,
4862
        &lwork,
...
...
5055
        if ($uplo())
5047
        if ($uplo())
5056
            puplo = \'L\';
5048
            puplo = \'L\';
5057
5049
5058
        $TFD(sposv_,dposv_)(
5050
        $TFD(sposv_,dposv_)(
5059
        &puplo,
5051
        &puplo,
5060
        &(integer){$PRIV(__n_size)},
5052
        &$PRIV(__n_size),
5061
        &(integer){$PRIV(__m_size)},
5053
        &$PRIV(__m_size),
5062
        $P(A),
5054
        $P(A),
5063
        &(integer){$PRIV(__n_size)},
5055
        &$PRIV(__n_size),
5064
        $P(B),
5056
        $P(B),
5065
        &(integer){$PRIV(__n_size)},
5057
        &$PRIV(__n_size),
5066
        $P(info));
5058
        $P(info));
5067
',
5059
',
5068
      Doc => '
5060
      Doc => '
5069
5061
5070
=for ref
5062
=for ref
...
...
5181
        iwork  = (integer *) malloc ($PRIV(__n_size)* sizeof (integer));
5173
        iwork  = (integer *) malloc ($PRIV(__n_size)* sizeof (integer));
5182
5174
5183
        $TFD(sposvx_,dposvx_)(
5175
        $TFD(sposvx_,dposvx_)(
5184
        &pfact,
5176
        &pfact,
5185
        &puplo,
5177
        &puplo,
5186
        &(integer){$PRIV(__n_size)},
5178
        &$PRIV(__n_size),
5187
        &(integer){$PRIV(__m_size)},
5179
        &$PRIV(__m_size),
5188
        $P(A),
5180
        $P(A),
5189
        &(integer){$PRIV(__n_size)},
5181
        &$PRIV(__n_size),
5190
        $P(af),
5182
        $P(af),
5191
        &(integer){$PRIV(__n_size)},
5183
        &$PRIV(__n_size),
5192
        &pequed,
5184
        &pequed,
5193
        $P(s),
5185
        $P(s),
5194
        $P(B),
5186
        $P(B),
5195
        &(integer){$PRIV(__n_size)},
5187
        &$PRIV(__n_size),
5196
        $P(X),
5188
        $P(X),
5197
        &(integer){$PRIV(__n_size)},
5189
        &$PRIV(__n_size),
5198
        $P(rcond),
5190
        $P(rcond),
5199
        $P(ferr),
5191
        $P(ferr),
5200
        $P(berr),
5192
        $P(berr),
5201
        work,
5193
        work,
5202
        iwork,
5194
        iwork,
...
...
5440
5432
5441
5433
5442
5434
5443
        $TFD(sgels_,dgels_)(
5435
        $TFD(sgels_,dgels_)(
5444
        &ptrans,
5436
        &ptrans,
5445
        &(integer){$PRIV(__m_size)},
5437
        &$PRIV(__m_size),
5446
        &(integer){$PRIV(__n_size)},
5438
        &$PRIV(__n_size),
5447
        &(integer){$PRIV(__q_size)},
5439
        &$PRIV(__q_size),
5448
        $P(A),
5440
        $P(A),
5449
        &(integer){$PRIV(__m_size)},
5441
        &$PRIV(__m_size),
5450
        $P(B),
5442
        $P(B),
5451
        &(integer){$PRIV(__p_size)},
5443
        &$PRIV(__p_size),
5452
        &tmp_work,
5444
        &tmp_work,
5453
        &lwork,
5445
        &lwork,
5454
        $P(info));
5446
        $P(info));
5455
5447
5456
        lwork = (integer )tmp_work;
5448
        lwork = (integer )tmp_work;
...
...
5462
            double *work = (double *)malloc(lwork *  sizeof(double));
5454
            double *work = (double *)malloc(lwork *  sizeof(double));
5463
                %}
5455
                %}
5464
5456
5465
        $TFD(sgels_,dgels_)(
5457
        $TFD(sgels_,dgels_)(
5466
        &ptrans,
5458
        &ptrans,
5467
        &(integer){$PRIV(__m_size)},
5459
        &$PRIV(__m_size),
5468
        &(integer){$PRIV(__n_size)},
5460
        &$PRIV(__n_size),
5469
        &(integer){$PRIV(__q_size)},
5461
        &$PRIV(__q_size),
5470
        $P(A),
5462
        $P(A),
5471
        &(integer){$PRIV(__m_size)},
5463
        &$PRIV(__m_size),
5472
        $P(B),
5464
        $P(B),
5473
        &(integer){$PRIV(__p_size)},
5465
        &$PRIV(__p_size),
5474
        work,
5466
        work,
5475
        &lwork,
5467
        &lwork,
5476
        $P(info));
5468
        $P(info));
5477
        free(work);
5469
        free(work);
5478
        }
5470
        }
...
...
5592
        lwork, integer *info);
5584
        lwork, integer *info);
5593
        double tmp_work;
5585
        double tmp_work;
5594
             %}
5586
             %}
5595
5587
5596
        $TFD(sgelsy_,dgelsy_)(
5588
        $TFD(sgelsy_,dgelsy_)(
5597
        &(integer){$PRIV(__m_size)},
5589
        &$PRIV(__m_size),
5598
        &(integer){$PRIV(__n_size)},
5590
        &$PRIV(__n_size),
5599
        &(integer){$PRIV(__q_size)},
5591
        &$PRIV(__q_size),
5600
        $P(A),
5592
        $P(A),
5601
        &(integer){$PRIV(__m_size)},
5593
        &$PRIV(__m_size),
5602
        $P(B),
5594
        $P(B),
5603
        &(integer){$PRIV(__p_size)},
5595
        &$PRIV(__p_size),
5604
        $P(jpvt),
5596
        $P(jpvt),
5605
        $P(rcond),
5597
        $P(rcond),
5606
        $P(rank),
5598
        $P(rank),
5607
        &tmp_work,
5599
        &tmp_work,
5608
        &lwork,
5600
        &lwork,
...
...
5616
                types(D) %{
5608
                types(D) %{
5617
            double *work = (double *)malloc(lwork *  sizeof(double));
5609
            double *work = (double *)malloc(lwork *  sizeof(double));
5618
                %}
5610
                %}
5619
5611
5620
        $TFD(sgelsy_,dgelsy_)(
5612
        $TFD(sgelsy_,dgelsy_)(
5621
        &(integer){$PRIV(__m_size)},
5613
        &$PRIV(__m_size),
5622
        &(integer){$PRIV(__n_size)},
5614
        &$PRIV(__n_size),
5623
        &(integer){$PRIV(__q_size)},
5615
        &$PRIV(__q_size),
5624
        $P(A),
5616
        $P(A),
5625
        &(integer){$PRIV(__m_size)},
5617
        &$PRIV(__m_size),
5626
        $P(B),
5618
        $P(B),
5627
        &(integer){$PRIV(__p_size)},
5619
        &$PRIV(__p_size),
5628
        $P(jpvt),
5620
        $P(jpvt),
5629
        $P(rcond),
5621
        $P(rcond),
5630
        $P(rank),
5622
        $P(rank),
5631
        work,
5623
        work,
5632
        &lwork,
5624
        &lwork,
...
...
5747
        lwork, integer *info);
5739
        lwork, integer *info);
5748
        double tmp_work;
5740
        double tmp_work;
5749
             %}
5741
             %}
5750
5742
5751
        $TFD(sgelss_,dgelss_)(
5743
        $TFD(sgelss_,dgelss_)(
5752
        &(integer){$PRIV(__m_size)},
5744
        &$PRIV(__m_size),
5753
        &(integer){$PRIV(__n_size)},
5745
        &$PRIV(__n_size),
5754
        &(integer){$PRIV(__q_size)},
5746
        &$PRIV(__q_size),
5755
        $P(A),
5747
        $P(A),
5756
        &(integer){$PRIV(__m_size)},
5748
        &$PRIV(__m_size),
5757
        $P(B),
5749
        $P(B),
5758
        &(integer){$PRIV(__p_size)},
5750
        &$PRIV(__p_size),
5759
        $P(s),
5751
        $P(s),
5760
        $P(rcond),
5752
        $P(rcond),
5761
        $P(rank),
5753
        $P(rank),
5762
        &tmp_work,
5754
        &tmp_work,
5763
        &lwork,
5755
        &lwork,
...
...
5771
                types(D) %{
5763
                types(D) %{
5772
            double *work = (double *)malloc(lwork *  sizeof(double));
5764
            double *work = (double *)malloc(lwork *  sizeof(double));
5773
                %}
5765
                %}
5774
5766
5775
        $TFD(sgelss_,dgelss_)(
5767
        $TFD(sgelss_,dgelss_)(
5776
        &(integer){$PRIV(__m_size)},
5768
        &$PRIV(__m_size),
5777
        &(integer){$PRIV(__n_size)},
5769
        &$PRIV(__n_size),
5778
        &(integer){$PRIV(__q_size)},
5770
        &$PRIV(__q_size),
5779
        $P(A),
5771
        $P(A),
5780
        &(integer){$PRIV(__m_size)},
5772
        &$PRIV(__m_size),
5781
        $P(B),
5773
        $P(B),
5782
        &(integer){$PRIV(__p_size)},
5774
        &$PRIV(__p_size),
5783
        $P(s),
5775
        $P(s),
5784
        $P(rcond),
5776
        $P(rcond),
5785
        $P(rank),
5777
        $P(rank),
5786
        work,
5778
        work,
5787
        &lwork,
5779
        &lwork,
...
...
5905
        nlvl = max(size_i, 0);
5897
        nlvl = max(size_i, 0);
5906
        iwork = (integer *)malloc((3 * minmn * nlvl + 11 * minmn) *  sizeof(integer));
5898
        iwork = (integer *)malloc((3 * minmn * nlvl + 11 * minmn) *  sizeof(integer));
5907
5899
5908
5900
5909
        $TFD(sgelsd_,dgelsd_)(
5901
        $TFD(sgelsd_,dgelsd_)(
5910
        &(integer){$PRIV(__m_size)},
5902
        &$PRIV(__m_size),
5911
        &(integer){$PRIV(__n_size)},
5903
        &$PRIV(__n_size),
5912
        &(integer){$PRIV(__q_size)},
5904
        &$PRIV(__q_size),
5913
        $P(A),
5905
        $P(A),
5914
        &(integer){$PRIV(__m_size)},
5906
        &$PRIV(__m_size),
5915
        $P(B),
5907
        $P(B),
5916
        &(integer){$PRIV(__p_size)},
5908
        &$PRIV(__p_size),
5917
        $P(s),
5909
        $P(s),
5918
        $P(rcond),
5910
        $P(rcond),
5919
        $P(rank),
5911
        $P(rank),
5920
        &tmp_work,
5912
        &tmp_work,
5921
        &lwork,
5913
        &lwork,
...
...
5930
                types(D) %{
5922
                types(D) %{
5931
            double *work = (double *)malloc(lwork *  sizeof(double));
5923
            double *work = (double *)malloc(lwork *  sizeof(double));
5932
                %}
5924
                %}
5933
5925
5934
        $TFD(sgelsd_,dgelsd_)(
5926
        $TFD(sgelsd_,dgelsd_)(
5935
        &(integer){$PRIV(__m_size)},
5927
        &$PRIV(__m_size),
5936
        &(integer){$PRIV(__n_size)},
5928
        &$PRIV(__n_size),
5937
        &(integer){$PRIV(__q_size)},
5929
        &$PRIV(__q_size),
5938
        $P(A),
5930
        $P(A),
5939
        &(integer){$PRIV(__m_size)},
5931
        &$PRIV(__m_size),
5940
        $P(B),
5932
        $P(B),
5941
        &(integer){$PRIV(__p_size)},
5933
        &$PRIV(__p_size),
5942
        $P(s),
5934
        $P(s),
5943
        $P(rcond),
5935
        $P(rcond),
5944
        $P(rank),
5936
        $P(rank),
5945
        work,
5937
        work,
5946
        &lwork,
5938
        &lwork,
...
...
6072
        double tmp_work;
6064
        double tmp_work;
6073
             %}
6065
             %}
6074
6066
6075
6067
6076
        $TFD(sgglse_,dgglse_)(
6068
        $TFD(sgglse_,dgglse_)(
6077
        &(integer){$PRIV(__m_size)},
6069
        &$PRIV(__m_size),
6078
        &(integer){$PRIV(__n_size)},
6070
        &$PRIV(__n_size),
6079
        &(integer){$PRIV(__p_size)},
6071
        &$PRIV(__p_size),
6080
        $P(A),
6072
        $P(A),
6081
        &(integer){$PRIV(__m_size)},
6073
        &$PRIV(__m_size),
6082
        $P(B),
6074
        $P(B),
6083
        &(integer){$PRIV(__p_size)},
6075
        &$PRIV(__p_size),
6084
        $P(c),
6076
        $P(c),
6085
        $P(d),
6077
        $P(d),
6086
        $P(x),
6078
        $P(x),
6087
        &tmp_work,
6079
        &tmp_work,
6088
        &lwork,
6080
        &lwork,
...
...
6096
                types(D) %{
6088
                types(D) %{
6097
            double *work = (double *)malloc(lwork *  sizeof(double));
6089
            double *work = (double *)malloc(lwork *  sizeof(double));
6098
                %}
6090
                %}
6099
6091
6100
        $TFD(sgglse_,dgglse_)(
6092
        $TFD(sgglse_,dgglse_)(
6101
        &(integer){$PRIV(__m_size)},
6093
        &$PRIV(__m_size),
6102
        &(integer){$PRIV(__n_size)},
6094
        &$PRIV(__n_size),
6103
        &(integer){$PRIV(__p_size)},
6095
        &$PRIV(__p_size),
6104
        $P(A),
6096
        $P(A),
6105
        &(integer){$PRIV(__m_size)},
6097
        &$PRIV(__m_size),
6106
        $P(B),
6098
        $P(B),
6107
        &(integer){$PRIV(__p_size)},
6099
        &$PRIV(__p_size),
6108
        $P(c),
6100
        $P(c),
6109
        $P(d),
6101
        $P(d),
6110
        $P(x),
6102
        $P(x),
6111
        work,
6103
        work,
6112
        &lwork,
6104
        &lwork,
...
...
6200
        double tmp_work;
6192
        double tmp_work;
6201
             %}
6193
             %}
6202
6194
6203
6195
6204
        $TFD(sggglm_,dggglm_)(
6196
        $TFD(sggglm_,dggglm_)(
6205
        &(integer){$PRIV(__n_size)},
6197
        &$PRIV(__n_size),
6206
        &(integer){$PRIV(__m_size)},
6198
        &$PRIV(__m_size),
6207
        &(integer){$PRIV(__p_size)},
6199
        &$PRIV(__p_size),
6208
        $P(A),
6200
        $P(A),
6209
        &(integer){$PRIV(__n_size)},
6201
        &$PRIV(__n_size),
6210
        $P(B),
6202
        $P(B),
6211
        &(integer){$PRIV(__n_size)},
6203
        &$PRIV(__n_size),
6212
        $P(d),
6204
        $P(d),
6213
        $P(x),
6205
        $P(x),
6214
        $P(y),
6206
        $P(y),
6215
        &tmp_work,
6207
        &tmp_work,
6216
        &lwork,
6208
        &lwork,
...
...
6224
                types(D) %{
6216
                types(D) %{
6225
            double *work = (double *)malloc(lwork *  sizeof(double));
6217
            double *work = (double *)malloc(lwork *  sizeof(double));
6226
                %}
6218
                %}
6227
6219
6228
        $TFD(sggglm_,dggglm_)(
6220
        $TFD(sggglm_,dggglm_)(
6229
        &(integer){$PRIV(__n_size)},
6221
        &$PRIV(__n_size),
6230
        &(integer){$PRIV(__m_size)},
6222
        &$PRIV(__m_size),
6231
        &(integer){$PRIV(__p_size)},
6223
        &$PRIV(__p_size),
6232
        $P(A),
6224
        $P(A),
6233
        &(integer){$PRIV(__n_size)},
6225
        &$PRIV(__n_size),
6234
        $P(B),
6226
        $P(B),
6235
        &(integer){$PRIV(__n_size)},
6227
        &$PRIV(__n_size),
6236
        $P(d),
6228
        $P(d),
6237
        $P(x),
6229
        $P(x),
6238
        $P(y),
6230
        $P(y),
6239
        work,
6231
        work,
6240
        &lwork,
6232
        &lwork,
...
...
6324
6316
6325
        extern int dgetrf_(integer *m, integer *n, double *a, integer *
6317
        extern int dgetrf_(integer *m, integer *n, double *a, integer *
6326
        lda, integer *ipiv, integer *info);
6318
        lda, integer *ipiv, integer *info);
6327
             %}
6319
             %}
6328
        $TFD(sgetrf_,dgetrf_)(
6320
        $TFD(sgetrf_,dgetrf_)(
6329
        &(integer){$PRIV(__m_size)},
6321
        &$PRIV(__m_size),
6330
        &(integer){$PRIV(__n_size)},
6322
        &$PRIV(__n_size),
6331
        $P(A),
6323
        $P(A),
6332
        &(integer){$PRIV(__m_size)},
6324
        &$PRIV(__m_size),
6333
        $P(ipiv),
6325
        $P(ipiv),
6334
        $P(info));
6326
        $P(info));
6335
',
6327
',
6336
      Doc => '
6328
      Doc => '
6337
6329
...
...
6391
6383
6392
        extern int dgetf2_(integer *m, integer *n, double *a, integer *
6384
        extern int dgetf2_(integer *m, integer *n, double *a, integer *
6393
        lda, integer *ipiv, integer *info);
6385
        lda, integer *ipiv, integer *info);
6394
             %}
6386
             %}
6395
        $TFD(sgetf2_,dgetf2_)(
6387
        $TFD(sgetf2_,dgetf2_)(
6396
        &(integer){$PRIV(__m_size)},
6388
        &$PRIV(__m_size),
6397
        &(integer){$PRIV(__n_size)},
6389
        &$PRIV(__n_size),
6398
        $P(A),
6390
        $P(A),
6399
        &(integer){$PRIV(__m_size)},
6391
        &$PRIV(__m_size),
6400
        $P(ipiv),
6392
        $P(ipiv),
6401
        $P(info));
6393
        $P(info));
6402
',
6394
',
6403
      Doc => '
6395
      Doc => '
6404
6396
...
...
6467
        if ($uplo())
6459
        if ($uplo())
6468
            puplo = \'L\';
6460
            puplo = \'L\';
6469
6461
6470
        $TFD(ssytrf_,dsytrf_)(
6462
        $TFD(ssytrf_,dsytrf_)(
6471
        &puplo,
6463
        &puplo,
6472
        &(integer){$PRIV(__n_size)},
6464
        &$PRIV(__n_size),
6473
        $P(A),
6465
        $P(A),
6474
        &(integer){$PRIV(__n_size)},
6466
        &$PRIV(__n_size),
6475
        $P(ipiv),
6467
        $P(ipiv),
6476
        &tmp_work,
6468
        &tmp_work,
6477
        &lwork,
6469
        &lwork,
6478
        $P(info));
6470
        $P(info));
6479
6471
...
...
6485
                types(D) %{
6477
                types(D) %{
6486
            double *work = (double *)malloc(lwork *  sizeof(double));
6478
            double *work = (double *)malloc(lwork *  sizeof(double));
6487
                %}
6479
                %}
6488
        $TFD(ssytrf_,dsytrf_)(
6480
        $TFD(ssytrf_,dsytrf_)(
6489
        &puplo,
6481
        &puplo,
6490
        &(integer){$PRIV(__n_size)},
6482
        &$PRIV(__n_size),
6491
        $P(A),
6483
        $P(A),
6492
        &(integer){$PRIV(__n_size)},
6484
        &$PRIV(__n_size),
6493
        $P(ipiv),
6485
        $P(ipiv),
6494
        work,
6486
        work,
6495
        &lwork,
6487
        &lwork,
6496
        $P(info));
6488
        $P(info));
6497
        free (work);
6489
        free (work);
...
...
6611
        if ($uplo())
6603
        if ($uplo())
6612
            puplo = \'L\';
6604
            puplo = \'L\';
6613
6605
6614
        $TFD(ssytf2_,dsytf2_)(
6606
        $TFD(ssytf2_,dsytf2_)(
6615
        &puplo,
6607
        &puplo,
6616
        &(integer){$PRIV(__n_size)},
6608
        &$PRIV(__n_size),
6617
        $P(A),
6609
        $P(A),
6618
        &(integer){$PRIV(__n_size)},
6610
        &$PRIV(__n_size),
6619
        $P(ipiv),
6611
        $P(ipiv),
6620
        $P(info));
6612
        $P(info));
6621
',
6613
',
6622
      Doc => '
6614
      Doc => '
6623
6615
...
...
6700
        if ($uplo())
6692
        if ($uplo())
6701
            puplo = \'L\';
6693
            puplo = \'L\';
6702
6694
6703
        $TFD(spotrf_,dpotrf_)(
6695
        $TFD(spotrf_,dpotrf_)(
6704
        &puplo,
6696
        &puplo,
6705
        &(integer){$PRIV(__n_size)},
6697
        &$PRIV(__n_size),
6706
        $P(A),
6698
        $P(A),
6707
        &(integer){$PRIV(__n_size)},
6699
        &$PRIV(__n_size),
6708
        $P(info));
6700
        $P(info));
6709
',
6701
',
6710
      Doc => '
6702
      Doc => '
6711
6703
6712
=for ref
6704
=for ref
...
...
6773
        if ($uplo())
6765
        if ($uplo())
6774
            puplo = \'L\';
6766
            puplo = \'L\';
6775
6767
6776
        $TFD(spotf2_,dpotf2_)(
6768
        $TFD(spotf2_,dpotf2_)(
6777
        &puplo,
6769
        &puplo,
6778
        &(integer){$PRIV(__n_size)},
6770
        &$PRIV(__n_size),
6779
        $P(A),
6771
        $P(A),
6780
        &(integer){$PRIV(__n_size)},
6772
        &$PRIV(__n_size),
6781
        $P(info));
6773
        $P(info));
6782
',
6774
',
6783
      Doc => '
6775
      Doc => '
6784
6776
6785
=for ref
6777
=for ref
...
...
6847
        double tmp_work;
6839
        double tmp_work;
6848
             %}
6840
             %}
6849
6841
6850
6842
6851
        $TFD(sgetri_,dgetri_)(
6843
        $TFD(sgetri_,dgetri_)(
6852
        &(integer){$PRIV(__n_size)},
6844
        &$PRIV(__n_size),
6853
        $P(A),
6845
        $P(A),
6854
        &(integer){$PRIV(__n_size)},
6846
        &$PRIV(__n_size),
6855
        $P(ipiv),
6847
        $P(ipiv),
6856
        &tmp_work,
6848
        &tmp_work,
6857
        &lwork,
6849
        &lwork,
6858
        $P(info));
6850
        $P(info));
6859
6851
...
...
6864
        %}
6856
        %}
6865
        types(D) %{
6857
        types(D) %{
6866
            double *work = (double *)malloc(lwork *  sizeof(double));
6858
            double *work = (double *)malloc(lwork *  sizeof(double));
6867
        %}
6859
        %}
6868
        $TFD(sgetri_,dgetri_)(
6860
        $TFD(sgetri_,dgetri_)(
6869
        &(integer){$PRIV(__n_size)},
6861
        &$PRIV(__n_size),
6870
        $P(A),
6862
        $P(A),
6871
        &(integer){$PRIV(__n_size)},
6863
        &$PRIV(__n_size),
6872
        $P(ipiv),
6864
        $P(ipiv),
6873
        work,
6865
        work,
6874
        &lwork,
6866
        &lwork,
6875
        $P(info));
6867
        $P(info));
6876
        free(work);
6868
        free(work);
...
...
6940
        if ($uplo())
6932
        if ($uplo())
6941
            puplo = \'L\';
6933
            puplo = \'L\';
6942
6934
6943
        $TFD(ssytri_, dsytri_)(
6935
        $TFD(ssytri_, dsytri_)(
6944
        &puplo,
6936
        &puplo,
6945
        &(integer){$PRIV(__n_size)},
6937
        &$PRIV(__n_size),
6946
        $P(A),
6938
        $P(A),
6947
        &(integer){$PRIV(__n_size)},
6939
        &$PRIV(__n_size),
6948
        $P(ipiv),
6940
        $P(ipiv),
6949
        work,
6941
        work,
6950
        $P(info));
6942
        $P(info));
6951
        free(work);
6943
        free(work);
6952
',
6944
',
...
...
7016
        if ($uplo())
7008
        if ($uplo())
7017
            puplo = \'L\';
7009
            puplo = \'L\';
7018
7010
7019
        $TFD(spotri_,dpotri_)(
7011
        $TFD(spotri_,dpotri_)(
7020
        &puplo,
7012
        &puplo,
7021
        &(integer){$PRIV(__n_size)},
7013
        &$PRIV(__n_size),
7022
        $P(A),
7014
        $P(A),
7023
        &(integer){$PRIV(__n_size)},
7015
        &$PRIV(__n_size),
7024
        $P(info));
7016
        $P(info));
7025
',
7017
',
7026
      Doc => '
7018
      Doc => '
7027
7019
7028
=for ref
7020
=for ref
...
...
7085
            pdiag = \'U\';
7077
            pdiag = \'U\';
7086
7078
7087
        $TFD(strtri_, dtrtri_)(
7079
        $TFD(strtri_, dtrtri_)(
7088
        &puplo,
7080
        &puplo,
7089
        &pdiag,
7081
        &pdiag,
7090
        &(integer){$PRIV(__n_size)},
7082
        &$PRIV(__n_size),
7091
        $P(A),
7083
        $P(A),
7092
        &(integer){$PRIV(__n_size)},
7084
        &$PRIV(__n_size),
7093
        $P(info));
7085
        $P(info));
7094
',
7086
',
7095
      Doc => '
7087
      Doc => '
7096
7088
7097
=for ref
7089
=for ref
...
...
7161
            pdiag = \'U\';
7153
            pdiag = \'U\';
7162
7154
7163
        $TFD(strti2_, dtrti2_)(
7155
        $TFD(strti2_, dtrti2_)(
7164
        &puplo,
7156
        &puplo,
7165
        &pdiag,
7157
        &pdiag,
7166
        &(integer){$PRIV(__n_size)},
7158
        &$PRIV(__n_size),
7167
        $P(A),
7159
        $P(A),
7168
        &(integer){$PRIV(__n_size)},
7160
        &$PRIV(__n_size),
7169
        $P(info));
7161
        $P(info));
7170
',
7162
',
7171
      Doc => '
7163
      Doc => '
7172
7164
7173
=for ref
7165
=for ref
...
...
7230
        if($trans())
7222
        if($trans())
7231
            transp = \'T\';
7223
            transp = \'T\';
7232
7224
7233
        $TFD(sgetrs_,dgetrs_)(
7225
        $TFD(sgetrs_,dgetrs_)(
7234
        &transp,
7226
        &transp,
7235
        &(integer){$PRIV(__n_size)},
7227
        &$PRIV(__n_size),
7236
        &(integer){$PRIV(__m_size)},
7228
        &$PRIV(__m_size),
7237
        $P(A),
7229
        $P(A),
7238
        &(integer){$PRIV(__n_size)},
7230
        &$PRIV(__n_size),
7239
        $P(ipiv),
7231
        $P(ipiv),
7240
        $P(B),
7232
        $P(B),
7241
        &(integer){$PRIV(__n_size)},
7233
        &$PRIV(__n_size),
7242
        $P(info));
7234
        $P(info));
7243
',
7235
',
7244
      Doc => '
7236
      Doc => '
7245
7237
7246
=for ref
7238
=for ref
...
...
7303
        if($uplo())
7295
        if($uplo())
7304
            puplo = \'L\';
7296
            puplo = \'L\';
7305
7297
7306
        $TFD(ssytrs_,dsytrs_)(
7298
        $TFD(ssytrs_,dsytrs_)(
7307
        &puplo,
7299
        &puplo,
7308
        &(integer){$PRIV(__n_size)},
7300
        &$PRIV(__n_size),
7309
        &(integer){$PRIV(__m_size)},
7301
        &$PRIV(__m_size),
7310
        $P(A),
7302
        $P(A),
7311
        &(integer){$PRIV(__n_size)},
7303
        &$PRIV(__n_size),
7312
        $P(ipiv),
7304
        $P(ipiv),
7313
        $P(B),
7305
        $P(B),
7314
        &(integer){$PRIV(__n_size)},
7306
        &$PRIV(__n_size),
7315
        $P(info));
7307
        $P(info));
7316
',
7308
',
7317
      Doc => '
7309
      Doc => '
7318
7310
7319
=for ref
7311
=for ref
...
...
7378
        if($uplo())
7370
        if($uplo())
7379
            puplo = \'L\';
7371
            puplo = \'L\';
7380
7372
7381
        $TFD(spotrs_,dpotrs_)(
7373
        $TFD(spotrs_,dpotrs_)(
7382
        &puplo,
7374
        &puplo,
7383
        &(integer){$PRIV(__n_size)},
7375
        &$PRIV(__n_size),
7384
        &(integer){$PRIV(__m_size)},
7376
        &$PRIV(__m_size),
7385
        $P(A),
7377
        $P(A),
7386
        &(integer){$PRIV(__n_size)},
7378
        &$PRIV(__n_size),
7387
        $P(B),
7379
        $P(B),
7388
        &(integer){$PRIV(__n_size)},
7380
        &$PRIV(__n_size),
7389
        $P(info));
7381
        $P(info));
7390
',
7382
',
7391
      Doc => '
7383
      Doc => '
7392
7384
7393
=for ref
7385
=for ref
...
...
7455
7447
7456
        $TFD(strtrs_,dtrtrs_)(
7448
        $TFD(strtrs_,dtrtrs_)(
7457
        &puplo,
7449
        &puplo,
7458
        &ptrans,
7450
        &ptrans,
7459
        &pdiag,
7451
        &pdiag,
7460
        &(integer){$PRIV(__n_size)},
7452
        &$PRIV(__n_size),
7461
        &(integer){$PRIV(__m_size)},
7453
        &$PRIV(__m_size),
7462
        $P(A),
7454
        $P(A),
7463
        &(integer){$PRIV(__n_size)},
7455
        &$PRIV(__n_size),
7464
        $P(B),
7456
        $P(B),
7465
        &(integer){$PRIV(__n_size)},
7457
        &$PRIV(__n_size),
7466
        $P(info));
7458
        $P(info));
7467
',
7459
',
7468
      Doc => '
7460
      Doc => '
7469
7461
7470
=for ref
7462
=for ref
...
...
7556
        $TFD(slatrs_,dlatrs_)(
7548
        $TFD(slatrs_,dlatrs_)(
7557
        &puplo,
7549
        &puplo,
7558
        &ptrans,
7550
        &ptrans,
7559
        &pdiag,
7551
        &pdiag,
7560
        &pnormin,
7552
        &pnormin,
7561
        &(integer){$PRIV(__n_size)},
7553
        &$PRIV(__n_size),
7562
        $P(A),
7554
        $P(A),
7563
        &(integer){$PRIV(__n_size)},
7555
        &$PRIV(__n_size),
7564
        $P(x),
7556
        $P(x),
7565
        $P(scale),
7557
        $P(scale),
7566
        $P(cnorm),
7558
        $P(cnorm),
7567
        $P(info));
7559
        $P(info));
7568
',
7560
',
...
...
7748
        if($norm())
7740
        if($norm())
7749
            pnorm = \'O\';
7741
            pnorm = \'O\';
7750
7742
7751
        $TFD(sgecon_,dgecon_)(
7743
        $TFD(sgecon_,dgecon_)(
7752
        &pnorm,
7744
        &pnorm,
7753
        &(integer){$PRIV(__n_size)},
7745
        &$PRIV(__n_size),
7754
        $P(A),
7746
        $P(A),
7755
        &(integer){$PRIV(__n_size)},
7747
        &$PRIV(__n_size),
7756
        $P(anorm),
7748
        $P(anorm),
7757
        $P(rcond),
7749
        $P(rcond),
7758
        work,
7750
        work,
7759
        iwork,
7751
        iwork,
7760
        $P(info));
7752
        $P(info));
...
...
7831
        if($uplo())
7823
        if($uplo())
7832
            puplo = \'L\';
7824
            puplo = \'L\';
7833
7825
7834
        $TFD(ssycon_,dsycon_)(
7826
        $TFD(ssycon_,dsycon_)(
7835
        &puplo,
7827
        &puplo,
7836
        &(integer){$PRIV(__n_size)},
7828
        &$PRIV(__n_size),
7837
        $P(A),
7829
        $P(A),
7838
        &(integer){$PRIV(__n_size)},
7830
        &$PRIV(__n_size),
7839
        $P(ipiv),
7831
        $P(ipiv),
7840
        $P(anorm),
7832
        $P(anorm),
7841
        $P(rcond),
7833
        $P(rcond),
7842
        work,
7834
        work,
7843
        iwork,
7835
        iwork,
...
...
7917
        if($uplo())
7909
        if($uplo())
7918
            puplo = \'L\';
7910
            puplo = \'L\';
7919
7911
7920
        $TFD(spocon_,dpocon_)(
7912
        $TFD(spocon_,dpocon_)(
7921
        &puplo,
7913
        &puplo,
7922
        &(integer){$PRIV(__n_size)},
7914
        &$PRIV(__n_size),
7923
        $P(A),
7915
        $P(A),
7924
        &(integer){$PRIV(__n_size)},
7916
        &$PRIV(__n_size),
7925
        $P(anorm),
7917
        $P(anorm),
7926
        $P(rcond),
7918
        $P(rcond),
7927
        work,
7919
        work,
7928
        iwork,
7920
        iwork,
7929
        $P(info));
7921
        $P(info));
...
...
8001
7993
8002
        $TFD(strcon_,dtrcon_)(
7994
        $TFD(strcon_,dtrcon_)(
8003
        &pnorm,
7995
        &pnorm,
8004
        &puplo,
7996
        &puplo,
8005
        &pdiag,
7997
        &pdiag,
8006
        &(integer){$PRIV(__n_size)},
7998
        &$PRIV(__n_size),
8007
        $P(A),
7999
        $P(A),
8008
        &(integer){$PRIV(__n_size)},
8000
        &$PRIV(__n_size),
8009
        $P(rcond),
8001
        $P(rcond),
8010
        work,
8002
        work,
8011
        iwork,
8003
        iwork,
8012
        $P(info));
8004
        $P(info));
8013
        free (work);
8005
        free (work);
...
...
8086
         integer *info);
8078
         integer *info);
8087
         double tmp_work;
8079
         double tmp_work;
8088
             %}
8080
             %}
8089
8081
8090
        $TFD(sgeqp3_,dgeqp3_)(
8082
        $TFD(sgeqp3_,dgeqp3_)(
8091
        &(integer){$PRIV(__m_size)},
8083
        &$PRIV(__m_size),
8092
        &(integer){$PRIV(__n_size)},
8084
        &$PRIV(__n_size),
8093
        $P(A),
8085
        $P(A),
8094
        &(integer){$PRIV(__m_size)},
8086
        &$PRIV(__m_size),
8095
        $P(jpvt),
8087
        $P(jpvt),
8096
        $P(tau),
8088
        $P(tau),
8097
        &tmp_work,
8089
        &tmp_work,
8098
        &lwork,
8090
        &lwork,
8099
        $P(info));
8091
        $P(info));
...
...
8107
             types(D) %{
8099
             types(D) %{
8108
8100
8109
        double *work = (double *)malloc(lwork *  sizeof(double));
8101
        double *work = (double *)malloc(lwork *  sizeof(double));
8110
             %}
8102
             %}
8111
        $TFD(sgeqp3_,dgeqp3_)(
8103
        $TFD(sgeqp3_,dgeqp3_)(
8112
        &(integer){$PRIV(__m_size)},
8104
        &$PRIV(__m_size),
8113
        &(integer){$PRIV(__n_size)},
8105
        &$PRIV(__n_size),
8114
        $P(A),
8106
        $P(A),
8115
        &(integer){$PRIV(__m_size)},
8107
        &$PRIV(__m_size),
8116
        $P(jpvt),
8108
        $P(jpvt),
8117
        $P(tau),
8109
        $P(tau),
8118
        work,
8110
        work,
8119
        &lwork,
8111
        &lwork,
8120
        $P(info));
8112
        $P(info));
...
...
8192
         integer *info);
8184
         integer *info);
8193
         double tmp_work;
8185
         double tmp_work;
8194
             %}
8186
             %}
8195
8187
8196
        $TFD(sgeqrf_,dgeqrf_)(
8188
        $TFD(sgeqrf_,dgeqrf_)(
8197
        &(integer){$PRIV(__m_size)},
8189
        &$PRIV(__m_size),
8198
        &(integer){$PRIV(__n_size)},
8190
        &$PRIV(__n_size),
8199
        $P(A),
8191
        $P(A),
8200
        &(integer){$PRIV(__m_size)},
8192
        &$PRIV(__m_size),
8201
        $P(tau),
8193
        $P(tau),
8202
        &tmp_work,
8194
        &tmp_work,
8203
        &lwork,
8195
        &lwork,
8204
        $P(info));
8196
        $P(info));
8205
8197
...
...
8212
             types(D) %{
8204
             types(D) %{
8213
8205
8214
        double *work = (double *)malloc(lwork *  sizeof(double));
8206
        double *work = (double *)malloc(lwork *  sizeof(double));
8215
             %}
8207
             %}
8216
        $TFD(sgeqrf_,dgeqrf_)(
8208
        $TFD(sgeqrf_,dgeqrf_)(
8217
        &(integer){$PRIV(__m_size)},
8209
        &$PRIV(__m_size),
8218
        &(integer){$PRIV(__n_size)},
8210
        &$PRIV(__n_size),
8219
        $P(A),
8211
        $P(A),
8220
        &(integer){$PRIV(__m_size)},
8212
        &$PRIV(__m_size),
8221
        $P(tau),
8213
        $P(tau),
8222
        work,
8214
        work,
8223
        &lwork,
8215
        &lwork,
8224
        $P(info));
8216
        $P(info));
8225
        free(work);
8217
        free(work);
...
...
8289
        integer *info);
8281
        integer *info);
8290
         double tmp_work;
8282
         double tmp_work;
8291
             %}
8283
             %}
8292
8284
8293
        $TFD(sorgqr_,dorgqr_)(
8285
        $TFD(sorgqr_,dorgqr_)(
8294
        &(integer){$PRIV(__m_size)},
8286
        &$PRIV(__m_size),
8295
        &(integer){$PRIV(__n_size)},
8287
        &$PRIV(__n_size),
8296
        &(integer){$PRIV(__k_size)},
8288
        &$PRIV(__k_size),
8297
        $P(A),
8289
        $P(A),
8298
        &(integer){$PRIV(__m_size)},
8290
        &$PRIV(__m_size),
8299
        $P(tau),
8291
        $P(tau),
8300
        &tmp_work,
8292
        &tmp_work,
8301
        &lwork,
8293
        &lwork,
8302
        $P(info));
8294
        $P(info));
8303
8295
...
...
8310
             types(D) %{
8302
             types(D) %{
8311
8303
8312
        double *work = (double *)malloc(lwork *  sizeof(double));
8304
        double *work = (double *)malloc(lwork *  sizeof(double));
8313
             %}
8305
             %}
8314
        $TFD(sorgqr_,dorgqr_)(
8306
        $TFD(sorgqr_,dorgqr_)(
8315
        &(integer){$PRIV(__m_size)},
8307
        &$PRIV(__m_size),
8316
        &(integer){$PRIV(__n_size)},
8308
        &$PRIV(__n_size),
8317
        &(integer){$PRIV(__k_size)},
8309
        &$PRIV(__k_size),
8318
        $P(A),
8310
        $P(A),
8319
        &(integer){$PRIV(__m_size)},
8311
        &$PRIV(__m_size),
8320
        $P(tau),
8312
        $P(tau),
8321
        work,
8313
        work,
8322
        &lwork,
8314
        &lwork,
8323
        $P(info));
8315
        $P(info));
8324
        free(work);
8316
        free(work);
...
...
8389
            pside = \'R\';
8381
            pside = \'R\';
8390
8382
8391
        $TFD(sormqr_,dormqr_)(
8383
        $TFD(sormqr_,dormqr_)(
8392
        &pside,
8384
        &pside,
8393
        &ptrans,
8385
        &ptrans,
8394
        &(integer){$PRIV(__m_size)},
8386
        &$PRIV(__m_size),
8395
        &(integer){$PRIV(__n_size)},
8387
        &$PRIV(__n_size),
8396
        &(integer){$PRIV(__k_size)},
8388
        &$PRIV(__k_size),
8397
        $P(A),
8389
        $P(A),
8398
        &(integer){$PRIV(__p_size)},
8390
        &$PRIV(__p_size),
8399
        $P(tau),
8391
        $P(tau),
8400
        $P(C),
8392
        $P(C),
8401
        &(integer){$PRIV(__m_size)},
8393
        &$PRIV(__m_size),
8402
        &tmp_work,
8394
        &tmp_work,
8403
        &lwork,
8395
        &lwork,
8404
        $P(info));
8396
        $P(info));
8405
8397
8406
        lwork = (integer )tmp_work;
8398
        lwork = (integer )tmp_work;
...
...
8414
        double *work = (double *)malloc(lwork *  sizeof(double));
8406
        double *work = (double *)malloc(lwork *  sizeof(double));
8415
             %}
8407
             %}
8416
        $TFD(sormqr_,dormqr_)(
8408
        $TFD(sormqr_,dormqr_)(
8417
        &pside,
8409
        &pside,
8418
        &ptrans,
8410
        &ptrans,
8419
        &(integer){$PRIV(__m_size)},
8411
        &$PRIV(__m_size),
8420
        &(integer){$PRIV(__n_size)},
8412
        &$PRIV(__n_size),
8421
        &(integer){$PRIV(__k_size)},
8413
        &$PRIV(__k_size),
8422
        $P(A),
8414
        $P(A),
8423
        &(integer){$PRIV(__p_size)},
8415
        &$PRIV(__p_size),
8424
        $P(tau),
8416
        $P(tau),
8425
        $P(C),
8417
        $P(C),
8426
        &(integer){$PRIV(__m_size)},
8418
        &$PRIV(__m_size),
8427
        work,
8419
        work,
8428
        &lwork,
8420
        &lwork,
8429
        $P(info));
8421
        $P(info));
8430
        free(work);
8422
        free(work);
8431
        }
8423
        }
...
...
8506
        lda, double *tau, double *work, integer *lwork, integer *info);
8498
        lda, double *tau, double *work, integer *lwork, integer *info);
8507
         double tmp_work;
8499
         double tmp_work;
8508
             %}
8500
             %}
8509
8501
8510
        $TFD(sgelqf_,dgelqf_)(
8502
        $TFD(sgelqf_,dgelqf_)(
8511
        &(integer){$PRIV(__m_size)},
8503
        &$PRIV(__m_size),
8512
        &(integer){$PRIV(__n_size)},
8504
        &$PRIV(__n_size),
8513
        $P(A),
8505
        $P(A),
8514
        &(integer){$PRIV(__m_size)},
8506
        &$PRIV(__m_size),
8515
        $P(tau),
8507
        $P(tau),
8516
        &tmp_work,
8508
        &tmp_work,
8517
        &lwork,
8509
        &lwork,
8518
        $P(info));
8510
        $P(info));
8519
8511
...
...
8526
             types(D) %{
8518
             types(D) %{
8527
8519
8528
        double *work = (double *)malloc(lwork *  sizeof(double));
8520
        double *work = (double *)malloc(lwork *  sizeof(double));
8529
             %}
8521
             %}
8530
        $TFD(sgelqf_,dgelqf_)(
8522
        $TFD(sgelqf_,dgelqf_)(
8531
        &(integer){$PRIV(__m_size)},
8523
        &$PRIV(__m_size),
8532
        &(integer){$PRIV(__n_size)},
8524
        &$PRIV(__n_size),
8533
        $P(A),
8525
        $P(A),
8534
        &(integer){$PRIV(__m_size)},
8526
        &$PRIV(__m_size),
8535
        $P(tau),
8527
        $P(tau),
8536
        work,
8528
        work,
8537
        &lwork,
8529
        &lwork,
8538
        $P(info));
8530
        $P(info));
8539
        free(work);
8531
        free(work);
...
...
8602
        integer *info);
8594
        integer *info);
8603
         double tmp_work;
8595
         double tmp_work;
8604
             %}
8596
             %}
8605
8597
8606
        $TFD(sorglq_,dorglq_)(
8598
        $TFD(sorglq_,dorglq_)(
8607
        &(integer){$PRIV(__m_size)},
8599
        &$PRIV(__m_size),
8608
        &(integer){$PRIV(__n_size)},
8600
        &$PRIV(__n_size),
8609
        &(integer){$PRIV(__k_size)},
8601
        &$PRIV(__k_size),
8610
        $P(A),
8602
        $P(A),
8611
        &(integer){$PRIV(__m_size)},
8603
        &$PRIV(__m_size),
8612
        $P(tau),
8604
        $P(tau),
8613
        &tmp_work,
8605
        &tmp_work,
8614
        &lwork,
8606
        &lwork,
8615
        $P(info));
8607
        $P(info));
8616
8608
...
...
8623
             types(D) %{
8615
             types(D) %{
8624
8616
8625
        double *work = (double *)malloc(lwork *  sizeof(double));
8617
        double *work = (double *)malloc(lwork *  sizeof(double));
8626
             %}
8618
             %}
8627
        $TFD(sorglq_,dorglq_)(
8619
        $TFD(sorglq_,dorglq_)(
8628
        &(integer){$PRIV(__m_size)},
8620
        &$PRIV(__m_size),
8629
        &(integer){$PRIV(__n_size)},
8621
        &$PRIV(__n_size),
8630
        &(integer){$PRIV(__k_size)},
8622
        &$PRIV(__k_size),
8631
        $P(A),
8623
        $P(A),
8632
        &(integer){$PRIV(__m_size)},
8624
        &$PRIV(__m_size),
8633
        $P(tau),
8625
        $P(tau),
8634
        work,
8626
        work,
8635
        &lwork,
8627
        &lwork,
8636
        $P(info));
8628
        $P(info));
8637
        free(work);
8629
        free(work);
...
...
8700
            pside = \'R\';
8692
            pside = \'R\';
8701
8693
8702
        $TFD(sormlq_,dormlq_)(
8694
        $TFD(sormlq_,dormlq_)(
8703
        &pside,
8695
        &pside,
8704
        &ptrans,
8696
        &ptrans,
8705
        &(integer){$PRIV(__m_size)},
8697
        &$PRIV(__m_size),
8706
        &(integer){$PRIV(__n_size)},
8698
        &$PRIV(__n_size),
8707
        &(integer){$PRIV(__k_size)},
8699
        &$PRIV(__k_size),
8708
        $P(A),
8700
        $P(A),
8709
        &(integer){$PRIV(__k_size)},
8701
        &$PRIV(__k_size),
8710
        $P(tau),
8702
        $P(tau),
8711
        $P(C),
8703
        $P(C),
8712
        &(integer){$PRIV(__m_size)},
8704
        &$PRIV(__m_size),
8713
        &tmp_work,
8705
        &tmp_work,
8714
        &lwork,
8706
        &lwork,
8715
        $P(info));
8707
        $P(info));
8716
8708
8717
        lwork = (integer )tmp_work;
8709
        lwork = (integer )tmp_work;
...
...
8725
        double *work = (double *)malloc(lwork *  sizeof(double));
8717
        double *work = (double *)malloc(lwork *  sizeof(double));
8726
             %}
8718
             %}
8727
        $TFD(sormlq_,dormlq_)(
8719
        $TFD(sormlq_,dormlq_)(
8728
        &pside,
8720
        &pside,
8729
        &ptrans,
8721
        &ptrans,
8730
        &(integer){$PRIV(__m_size)},
8722
        &$PRIV(__m_size),
8731
        &(integer){$PRIV(__n_size)},
8723
        &$PRIV(__n_size),
8732
        &(integer){$PRIV(__k_size)},
8724
        &$PRIV(__k_size),
8733
        $P(A),
8725
        $P(A),
8734
        &(integer){$PRIV(__k_size)},
8726
        &$PRIV(__k_size),
8735
        $P(tau),
8727
        $P(tau),
8736
        $P(C),
8728
        $P(C),
8737
        &(integer){$PRIV(__m_size)},
8729
        &$PRIV(__m_size),
8738
        work,
8730
        work,
8739
        &lwork,
8731
        &lwork,
8740
        $P(info));
8732
        $P(info));
8741
        free(work);
8733
        free(work);
8742
        }
8734
        }
...
...
8817
        lda, double *tau, double *work, integer *lwork, integer *info);
8809
        lda, double *tau, double *work, integer *lwork, integer *info);
8818
         double tmp_work;
8810
         double tmp_work;
8819
             %}
8811
             %}
8820
8812
8821
        $TFD(sgeqlf_,dgeqlf_)(
8813
        $TFD(sgeqlf_,dgeqlf_)(
8822
        &(integer){$PRIV(__m_size)},
8814
        &$PRIV(__m_size),
8823
        &(integer){$PRIV(__n_size)},
8815
        &$PRIV(__n_size),
8824
        $P(A),
8816
        $P(A),
8825
        &(integer){$PRIV(__m_size)},
8817
        &$PRIV(__m_size),
8826
        $P(tau),
8818
        $P(tau),
8827
        &tmp_work,
8819
        &tmp_work,
8828
        &lwork,
8820
        &lwork,
8829
        $P(info));
8821
        $P(info));
8830
8822
...
...
8837
             types(D) %{
8829
             types(D) %{
8838
8830
8839
        double *work = (double *)malloc(lwork *  sizeof(double));
8831
        double *work = (double *)malloc(lwork *  sizeof(double));
8840
             %}
8832
             %}
8841
        $TFD(sgeqlf_,dgeqlf_)(
8833
        $TFD(sgeqlf_,dgeqlf_)(
8842
        &(integer){$PRIV(__m_size)},
8834
        &$PRIV(__m_size),
8843
        &(integer){$PRIV(__n_size)},
8835
        &$PRIV(__n_size),
8844
        $P(A),
8836
        $P(A),
8845
        &(integer){$PRIV(__m_size)},
8837
        &$PRIV(__m_size),
8846
        $P(tau),
8838
        $P(tau),
8847
        work,
8839
        work,
8848
        &lwork,
8840
        &lwork,
8849
        $P(info));
8841
        $P(info));
8850
        free(work);
8842
        free(work);
...
...
8915
        integer *info);
8907
        integer *info);
8916
         double tmp_work;
8908
         double tmp_work;
8917
             %}
8909
             %}
8918
8910
8919
        $TFD(sorgql_,dorgql_)(
8911
        $TFD(sorgql_,dorgql_)(
8920
        &(integer){$PRIV(__m_size)},
8912
        &$PRIV(__m_size),
8921
        &(integer){$PRIV(__n_size)},
8913
        &$PRIV(__n_size),
8922
        &(integer){$PRIV(__k_size)},
8914
        &$PRIV(__k_size),
8923
        $P(A),
8915
        $P(A),
8924
        &(integer){$PRIV(__m_size)},
8916
        &$PRIV(__m_size),
8925
        $P(tau),
8917
        $P(tau),
8926
        &tmp_work,
8918
        &tmp_work,
8927
        &lwork,
8919
        &lwork,
8928
        $P(info));
8920
        $P(info));
8929
8921
...
...
8936
             types(D) %{
8928
             types(D) %{
8937
8929
8938
        double *work = (double *)malloc(lwork *  sizeof(double));
8930
        double *work = (double *)malloc(lwork *  sizeof(double));
8939
             %}
8931
             %}
8940
        $TFD(sorgql_,dorgql_)(
8932
        $TFD(sorgql_,dorgql_)(
8941
        &(integer){$PRIV(__m_size)},
8933
        &$PRIV(__m_size),
8942
        &(integer){$PRIV(__n_size)},
8934
        &$PRIV(__n_size),
8943
        &(integer){$PRIV(__k_size)},
8935
        &$PRIV(__k_size),
8944
        $P(A),
8936
        $P(A),
8945
        &(integer){$PRIV(__m_size)},
8937
        &$PRIV(__m_size),
8946
        $P(tau),
8938
        $P(tau),
8947
        work,
8939
        work,
8948
        &lwork,
8940
        &lwork,
8949
        $P(info));
8941
        $P(info));
8950
        free(work);
8942
        free(work);
...
...
9014
            pside = \'R\';
9006
            pside = \'R\';
9015
9007
9016
        $TFD(sormql_,dormql_)(
9008
        $TFD(sormql_,dormql_)(
9017
        &pside,
9009
        &pside,
9018
        &ptrans,
9010
        &ptrans,
9019
        &(integer){$PRIV(__m_size)},
9011
        &$PRIV(__m_size),
9020
        &(integer){$PRIV(__n_size)},
9012
        &$PRIV(__n_size),
9021
        &(integer){$PRIV(__k_size)},
9013
        &$PRIV(__k_size),
9022
        $P(A),
9014
        $P(A),
9023
        &(integer){$PRIV(__p_size)},
9015
        &$PRIV(__p_size),
9024
        $P(tau),
9016
        $P(tau),
9025
        $P(C),
9017
        $P(C),
9026
        &(integer){$PRIV(__m_size)},
9018
        &$PRIV(__m_size),
9027
        &tmp_work,
9019
        &tmp_work,
9028
        &lwork,
9020
        &lwork,
9029
        $P(info));
9021
        $P(info));
9030
9022
9031
        lwork = (integer )tmp_work;
9023
        lwork = (integer )tmp_work;
...
...
9039
        double *work = (double *)malloc(lwork *  sizeof(double));
9031
        double *work = (double *)malloc(lwork *  sizeof(double));
9040
             %}
9032
             %}
9041
        $TFD(sormql_,dormql_)(
9033
        $TFD(sormql_,dormql_)(
9042
        &pside,
9034
        &pside,
9043
        &ptrans,
9035
        &ptrans,
9044
        &(integer){$PRIV(__m_size)},
9036
        &$PRIV(__m_size),
9045
        &(integer){$PRIV(__n_size)},
9037
        &$PRIV(__n_size),
9046
        &(integer){$PRIV(__k_size)},
9038
        &$PRIV(__k_size),
9047
        $P(A),
9039
        $P(A),
9048
        &(integer){$PRIV(__p_size)},
9040
        &$PRIV(__p_size),
9049
        $P(tau),
9041
        $P(tau),
9050
        $P(C),
9042
        $P(C),
9051
        &(integer){$PRIV(__m_size)},
9043
        &$PRIV(__m_size),
9052
        work,
9044
        work,
9053
        &lwork,
9045
        &lwork,
9054
        $P(info));
9046
        $P(info));
9055
        free(work);
9047
        free(work);
9056
        }
9048
        }
...
...
9131
        lda, double *tau, double *work, integer *lwork, integer *info);
9123
        lda, double *tau, double *work, integer *lwork, integer *info);
9132
         double tmp_work;
9124
         double tmp_work;
9133
             %}
9125
             %}
9134
9126
9135
        $TFD(sgerqf_,dgerqf_)(
9127
        $TFD(sgerqf_,dgerqf_)(
9136
        &(integer){$PRIV(__m_size)},
9128
        &$PRIV(__m_size),
9137
        &(integer){$PRIV(__n_size)},
9129
        &$PRIV(__n_size),
9138
        $P(A),
9130
        $P(A),
9139
        &(integer){$PRIV(__m_size)},
9131
        &$PRIV(__m_size),
9140
        $P(tau),
9132
        $P(tau),
9141
        &tmp_work,
9133
        &tmp_work,
9142
        &lwork,
9134
        &lwork,
9143
        $P(info));
9135
        $P(info));
9144
9136
...
...
9151
             types(D) %{
9143
             types(D) %{
9152
9144
9153
        double *work = (double *)malloc(lwork *  sizeof(double));
9145
        double *work = (double *)malloc(lwork *  sizeof(double));
9154
             %}
9146
             %}
9155
        $TFD(sgerqf_,dgerqf_)(
9147
        $TFD(sgerqf_,dgerqf_)(
9156
        &(integer){$PRIV(__m_size)},
9148
        &$PRIV(__m_size),
9157
        &(integer){$PRIV(__n_size)},
9149
        &$PRIV(__n_size),
9158
        $P(A),
9150
        $P(A),
9159
        &(integer){$PRIV(__m_size)},
9151
        &$PRIV(__m_size),
9160
        $P(tau),
9152
        $P(tau),
9161
        work,
9153
        work,
9162
        &lwork,
9154
        &lwork,
9163
        $P(info));
9155
        $P(info));
9164
        free(work);
9156
        free(work);
...
...
9230
        integer *info);
9222
        integer *info);
9231
         double tmp_work;
9223
         double tmp_work;
9232
             %}
9224
             %}
9233
9225
9234
        $TFD(sorgrq_,dorgrq_)(
9226
        $TFD(sorgrq_,dorgrq_)(
9235
        &(integer){$PRIV(__m_size)},
9227
        &$PRIV(__m_size),
9236
        &(integer){$PRIV(__n_size)},
9228
        &$PRIV(__n_size),
9237
        &(integer){$PRIV(__k_size)},
9229
        &$PRIV(__k_size),
9238
        $P(A),
9230
        $P(A),
9239
        &(integer){$PRIV(__m_size)},
9231
        &$PRIV(__m_size),
9240
        $P(tau),
9232
        $P(tau),
9241
        &tmp_work,
9233
        &tmp_work,
9242
        &lwork,
9234
        &lwork,
9243
        $P(info));
9235
        $P(info));
9244
9236
...
...
9251
             types(D) %{
9243
             types(D) %{
9252
9244
9253
        double *work = (double *)malloc(lwork *  sizeof(double));
9245
        double *work = (double *)malloc(lwork *  sizeof(double));
9254
             %}
9246
             %}
9255
        $TFD(sorgrq_,dorgrq_)(
9247
        $TFD(sorgrq_,dorgrq_)(
9256
        &(integer){$PRIV(__m_size)},
9248
        &$PRIV(__m_size),
9257
        &(integer){$PRIV(__n_size)},
9249
        &$PRIV(__n_size),
9258
        &(integer){$PRIV(__k_size)},
9250
        &$PRIV(__k_size),
9259
        $P(A),
9251
        $P(A),
9260
        &(integer){$PRIV(__m_size)},
9252
        &$PRIV(__m_size),
9261
        $P(tau),
9253
        $P(tau),
9262
        work,
9254
        work,
9263
        &lwork,
9255
        &lwork,
9264
        $P(info));
9256
        $P(info));
9265
        free(work);
9257
        free(work);
...
...
9329
            pside = \'R\';
9321
            pside = \'R\';
9330
9322
9331
        $TFD(sormrq_,dormrq_)(
9323
        $TFD(sormrq_,dormrq_)(
9332
        &pside,
9324
        &pside,
9333
        &ptrans,
9325
        &ptrans,
9334
        &(integer){$PRIV(__m_size)},
9326
        &$PRIV(__m_size),
9335
        &(integer){$PRIV(__n_size)},
9327
        &$PRIV(__n_size),
9336
        &(integer){$PRIV(__k_size)},
9328
        &$PRIV(__k_size),
9337
        $P(A),
9329
        $P(A),
9338
        &(integer){$PRIV(__k_size)},
9330
        &$PRIV(__k_size),
9339
        $P(tau),
9331
        $P(tau),
9340
        $P(C),
9332
        $P(C),
9341
        &(integer){$PRIV(__m_size)},
9333
        &$PRIV(__m_size),
9342
        &tmp_work,
9334
        &tmp_work,
9343
        &lwork,
9335
        &lwork,
9344
        $P(info));
9336
        $P(info));
9345
9337
9346
        lwork = (integer )tmp_work;
9338
        lwork = (integer )tmp_work;
...
...
9354
        double *work = (double *)malloc(lwork *  sizeof(double));
9346
        double *work = (double *)malloc(lwork *  sizeof(double));
9355
             %}
9347
             %}
9356
        $TFD(sormrq_,dormrq_)(
9348
        $TFD(sormrq_,dormrq_)(
9357
        &pside,
9349
        &pside,
9358
        &ptrans,
9350
        &ptrans,
9359
        &(integer){$PRIV(__m_size)},
9351
        &$PRIV(__m_size),
9360
        &(integer){$PRIV(__n_size)},
9352
        &$PRIV(__n_size),
9361
        &(integer){$PRIV(__k_size)},
9353
        &$PRIV(__k_size),
9362
        $P(A),
9354
        $P(A),
9363
        &(integer){$PRIV(__k_size)},
9355
        &$PRIV(__k_size),
9364
        $P(tau),
9356
        $P(tau),
9365
        $P(C),
9357
        $P(C),
9366
        &(integer){$PRIV(__m_size)},
9358
        &$PRIV(__m_size),
9367
        work,
9359
        work,
9368
        &lwork,
9360
        &lwork,
9369
        $P(info));
9361
        $P(info));
9370
        free(work);
9362
        free(work);
9371
        }
9363
        }
...
...
9446
        lda, double *tau, double *work, integer *lwork, integer *info);
9438
        lda, double *tau, double *work, integer *lwork, integer *info);
9447
         double tmp_work;
9439
         double tmp_work;
9448
             %}
9440
             %}
9449
9441
9450
        $TFD(stzrzf_,dtzrzf_)(
9442
        $TFD(stzrzf_,dtzrzf_)(
9451
        &(integer){$PRIV(__m_size)},
9443
        &$PRIV(__m_size),
9452
        &(integer){$PRIV(__n_size)},
9444
        &$PRIV(__n_size),
9453
        $P(A),
9445
        $P(A),
9454
        &(integer){$PRIV(__m_size)},
9446
        &$PRIV(__m_size),
9455
        $P(tau),
9447
        $P(tau),
9456
        &tmp_work,
9448
        &tmp_work,
9457
        &lwork,
9449
        &lwork,
9458
        $P(info));
9450
        $P(info));
9459
9451
...
...
9466
             types(D) %{
9458
             types(D) %{
9467
9459
9468
        double *work = (double *)malloc(lwork *  sizeof(double));
9460
        double *work = (double *)malloc(lwork *  sizeof(double));
9469
             %}
9461
             %}
9470
        $TFD(stzrzf_,dtzrzf_)(
9462
        $TFD(stzrzf_,dtzrzf_)(
9471
        &(integer){$PRIV(__m_size)},
9463
        &$PRIV(__m_size),
9472
        &(integer){$PRIV(__n_size)},
9464
        &$PRIV(__n_size),
9473
        $P(A),
9465
        $P(A),
9474
        &(integer){$PRIV(__m_size)},
9466
        &$PRIV(__m_size),
9475
        $P(tau),
9467
        $P(tau),
9476
        work,
9468
        work,
9477
        &lwork,
9469
        &lwork,
9478
        $P(info));
9470
        $P(info));
9479
        free(work);
9471
        free(work);
...
...
9572
            pside = \'R\';
9564
            pside = \'R\';
9573
9565
9574
        $TFD(sormrz_,dormrz_)(
9566
        $TFD(sormrz_,dormrz_)(
9575
        &pside,
9567
        &pside,
9576
        &ptrans,
9568
        &ptrans,
9577
        &(integer){$PRIV(__m_size)},
9569
        &$PRIV(__m_size),
9578
        &(integer){$PRIV(__n_size)},
9570
        &$PRIV(__n_size),
9579
        &(integer){$PRIV(__k_size)},
9571
        &$PRIV(__k_size),
9580
        &kk,
9572
        &kk,
9581
        $P(A),
9573
        $P(A),
9582
        &(integer){$PRIV(__k_size)},
9574
        &$PRIV(__k_size),
9583
        $P(tau),
9575
        $P(tau),
9584
        $P(C),
9576
        $P(C),
9585
        &(integer){$PRIV(__m_size)},
9577
        &$PRIV(__m_size),
9586
        &tmp_work,
9578
        &tmp_work,
9587
        &lwork,
9579
        &lwork,
9588
        $P(info));
9580
        $P(info));
9589
9581
9590
        lwork = (integer )tmp_work;
9582
        lwork = (integer )tmp_work;
...
...
9598
        double *work = (double *)malloc(lwork *  sizeof(double));
9590
        double *work = (double *)malloc(lwork *  sizeof(double));
9599
             %}
9591
             %}
9600
        $TFD(sormrz_,dormrz_)(
9592
        $TFD(sormrz_,dormrz_)(
9601
        &pside,
9593
        &pside,
9602
        &ptrans,
9594
        &ptrans,
9603
        &(integer){$PRIV(__m_size)},
9595
        &$PRIV(__m_size),
9604
        &(integer){$PRIV(__n_size)},
9596
        &$PRIV(__n_size),
9605
        &(integer){$PRIV(__k_size)},
9597
        &$PRIV(__k_size),
9606
        &kk,
9598
        &kk,
9607
        $P(A),
9599
        $P(A),
9608
        &(integer){$PRIV(__k_size)},
9600
        &$PRIV(__k_size),
9609
        $P(tau),
9601
        $P(tau),
9610
        $P(C),
9602
        $P(C),
9611
        &(integer){$PRIV(__m_size)},
9603
        &$PRIV(__m_size),
9612
        work,
9604
        work,
9613
        &lwork,
9605
        &lwork,
9614
        $P(info));
9606
        $P(info));
9615
        free(work);
9607
        free(work);
9616
        }
9608
        }
...
...
9695
        integer *lwork, integer *info);
9687
        integer *lwork, integer *info);
9696
         double tmp_work;
9688
         double tmp_work;
9697
             %}
9689
             %}
9698
9690
9699
        $TFD(sgehrd_,dgehrd_)(
9691
        $TFD(sgehrd_,dgehrd_)(
9700
        &(integer){$PRIV(__n_size)},
9692
        &$PRIV(__n_size),
9701
        $P(ilo),
9693
        $P(ilo),
9702
        $P(ihi),
9694
        $P(ihi),
9703
        $P(A),
9695
        $P(A),
9704
        &(integer){$PRIV(__n_size)},
9696
        &$PRIV(__n_size),
9705
        $P(tau),
9697
        $P(tau),
9706
        &tmp_work,
9698
        &tmp_work,
9707
        &lwork,
9699
        &lwork,
9708
        $P(info));
9700
        $P(info));
9709
9701
...
...
9716
             types(D) %{
9708
             types(D) %{
9717
9709
9718
        double *work = (double *)malloc(lwork *  sizeof(double));
9710
        double *work = (double *)malloc(lwork *  sizeof(double));
9719
             %}
9711
             %}
9720
        $TFD(sgehrd_,dgehrd_)(
9712
        $TFD(sgehrd_,dgehrd_)(
9721
        &(integer){$PRIV(__n_size)},
9713
        &$PRIV(__n_size),
9722
        $P(ilo),
9714
        $P(ilo),
9723
        $P(ihi),
9715
        $P(ihi),
9724
        $P(A),
9716
        $P(A),
9725
        &(integer){$PRIV(__n_size)},
9717
        &$PRIV(__n_size),
9726
        $P(tau),
9718
        $P(tau),
9727
        work,
9719
        work,
9728
        &lwork,
9720
        &lwork,
9729
        $P(info));
9721
        $P(info));
9730
        free(work);
9722
        free(work);
...
...
9825
        integer *lwork, integer *info);
9817
        integer *lwork, integer *info);
9826
         double tmp_work;
9818
         double tmp_work;
9827
             %}
9819
             %}
9828
9820
9829
        $TFD(sorghr_,dorghr_)(
9821
        $TFD(sorghr_,dorghr_)(
9830
        &(integer){$PRIV(__n_size)},
9822
        &$PRIV(__n_size),
9831
        $P(ilo),
9823
        $P(ilo),
9832
        $P(ihi),
9824
        $P(ihi),
9833
        $P(A),
9825
        $P(A),
9834
        &(integer){$PRIV(__n_size)},
9826
        &$PRIV(__n_size),
9835
        $P(tau),
9827
        $P(tau),
9836
        &tmp_work,
9828
        &tmp_work,
9837
        &lwork,
9829
        &lwork,
9838
        $P(info));
9830
        $P(info));
9839
9831
...
...
9846
             types(D) %{
9838
             types(D) %{
9847
9839
9848
        double *work = (double *)malloc(lwork *  sizeof(double));
9840
        double *work = (double *)malloc(lwork *  sizeof(double));
9849
             %}
9841
             %}
9850
        $TFD(sorghr_,dorghr_)(
9842
        $TFD(sorghr_,dorghr_)(
9851
        &(integer){$PRIV(__n_size)},
9843
        &$PRIV(__n_size),
9852
        $P(ilo),
9844
        $P(ilo),
9853
        $P(ihi),
9845
        $P(ihi),
9854
        $P(A),
9846
        $P(A),
9855
        &(integer){$PRIV(__n_size)},
9847
        &$PRIV(__n_size),
9856
        $P(tau),
9848
        $P(tau),
9857
        work,
9849
        work,
9858
        &lwork,
9850
        &lwork,
9859
        $P(info));
9851
        $P(info));
9860
        free(work);
9852
        free(work);
...
...
9940
        }
9932
        }
9941
9933
9942
        $TFD(shseqr_,dhseqr_)(
9934
        $TFD(shseqr_,dhseqr_)(
9943
        &pjob,
9935
        &pjob,
9944
        &pcompz,
9936
        &pcompz,
9945
        &(integer){$PRIV(__n_size)},
9937
        &$PRIV(__n_size),
9946
        $P(ilo),
9938
        $P(ilo),
9947
        $P(ihi),
9939
        $P(ihi),
9948
        $P(H),
9940
        $P(H),
9949
        &(integer){$PRIV(__n_size)},
9941
        &$PRIV(__n_size),
9950
        $P(wr),
9942
        $P(wr),
9951
        $P(wi),
9943
        $P(wi),
9952
        $P(Z),
9944
        $P(Z),
9953
        &(integer){$PRIV(__m_size)},
9945
        &$PRIV(__m_size),
9954
        &tmp_work,
9946
        &tmp_work,
9955
        &lwork,
9947
        &lwork,
9956
        $P(info));
9948
        $P(info));
9957
9949
9958
        lwork = (integer )tmp_work;
9950
        lwork = (integer )tmp_work;
...
...
9966
        double *work = (double *)malloc(lwork *  sizeof(double));
9958
        double *work = (double *)malloc(lwork *  sizeof(double));
9967
             %}
9959
             %}
9968
        $TFD(shseqr_,dhseqr_)(
9960
        $TFD(shseqr_,dhseqr_)(
9969
        &pjob,
9961
        &pjob,
9970
        &pcompz,
9962
        &pcompz,
9971
        &(integer){$PRIV(__n_size)},
9963
        &$PRIV(__n_size),
9972
        $P(ilo),
9964
        $P(ilo),
9973
        $P(ihi),
9965
        $P(ihi),
9974
        $P(H),
9966
        $P(H),
9975
        &(integer){$PRIV(__n_size)},
9967
        &$PRIV(__n_size),
9976
        $P(wr),
9968
        $P(wr),
9977
        $P(wi),
9969
        $P(wi),
9978
        $P(Z),
9970
        $P(Z),
9979
        &(integer){$PRIV(__m_size)},
9971
        &$PRIV(__m_size),
9980
        work,
9972
        work,
9981
        &lwork,
9973
        &lwork,
9982
        $P(info));
9974
        $P(info));
9983
        free(work);
9975
        free(work);
9984
        }
9976
        }
...
...
10113
10105
10114
        $TFD(strevc_,dtrevc_)(
10106
        $TFD(strevc_,dtrevc_)(
10115
        &pside,
10107
        &pside,
10116
        &phowmny,
10108
        &phowmny,
10117
        $P(select),
10109
        $P(select),
10118
        &(integer){$PRIV(__n_size)},
10110
        &$PRIV(__n_size),
10119
        $P(T),
10111
        $P(T),
10120
        &(integer){$PRIV(__n_size)},
10112
        &$PRIV(__n_size),
10121
        $P(VL),
10113
        $P(VL),
10122
        &(integer){$PRIV(__m_size)},
10114
        &$PRIV(__m_size),
10123
        $P(VR),
10115
        $P(VR),
10124
        &(integer){$PRIV(__p_size)},
10116
        &$PRIV(__p_size),
10125
        &mm,
10117
        &mm,
10126
        $P(m), 
10118
        $P(m), 
10127
        work,
10119
        work,
10128
        $P(info));
10120
        $P(info));
10129
        free(work);
10121
        free(work);
...
...
10313
10305
10314
        $TFD(stgevc_,dtgevc_)(
10306
        $TFD(stgevc_,dtgevc_)(
10315
        &pside,
10307
        &pside,
10316
        &phowmny,
10308
        &phowmny,
10317
        $P(select),
10309
        $P(select),
10318
        &(integer){$PRIV(__n_size)},
10310
        &$PRIV(__n_size),
10319
        $P(A),
10311
        $P(A),
10320
        &(integer){$PRIV(__n_size)},
10312
        &$PRIV(__n_size),
10321
        $P(B),
10313
        $P(B),
10322
        &(integer){$PRIV(__n_size)},
10314
        &$PRIV(__n_size),
10323
        $P(VL),
10315
        $P(VL),
10324
        &(integer){$PRIV(__m_size)},
10316
        &$PRIV(__m_size),
10325
        $P(VR),
10317
        $P(VR),
10326
        &(integer){$PRIV(__p_size)},
10318
        &$PRIV(__p_size),
10327
        &mm,
10319
        &mm,
10328
        $P(m), 
10320
        $P(m), 
10329
        work,
10321
        work,
10330
        $P(info));
10322
        $P(info));
10331
        free(work);
10323
        free(work);
...
...
10476
            default:  pjob = \'N\';
10468
            default:  pjob = \'N\';
10477
        }
10469
        }
10478
        
10470
        
10479
        $TFD(sgebal_,dgebal_)(
10471
        $TFD(sgebal_,dgebal_)(
10480
        &pjob,
10472
        &pjob,
10481
        &(integer){$PRIV(__n_size)},
10473
        &$PRIV(__n_size),
10482
        $P(A),
10474
        $P(A),
10483
        &(integer){$PRIV(__n_size)},
10475
        &$PRIV(__n_size),
10484
        $P(ilo),
10476
        $P(ilo),
10485
        $P(ihi),
10477
        $P(ihi),
10486
        $P(scale),
10478
        $P(scale),
10487
        $P(info));
10479
        $P(info));
10488
10480
...
...
10610
                pside = \'R\';
10602
                pside = \'R\';
10611
10603
10612
        $TFD(sgebak_,dgebak_)(
10604
        $TFD(sgebak_,dgebak_)(
10613
        &pjob,
10605
        &pjob,
10614
        &pside,
10606
        &pside,
10615
        &(integer){$PRIV(__n_size)},
10607
        &$PRIV(__n_size),
10616
        $P(ilo),
10608
        $P(ilo),
10617
        $P(ihi),
10609
        $P(ihi),
10618
        $P(scale),
10610
        $P(scale),
10619
        &(integer){$PRIV(__m_size)},
10611
        &$PRIV(__m_size),
10620
        $P(A),
10612
        $P(A),
10621
        &(integer){$PRIV(__n_size)},
10613
        &$PRIV(__n_size),
10622
        $P(info));
10614
        $P(info));
10623
10615
10624
',
10616
',
10625
      Doc => '
10617
      Doc => '
10626
10618
...
...
10710
            default: pnorm = \'M\';
10702
            default: pnorm = \'M\';
10711
        }
10703
        }
10712
10704
10713
        $b() = $TFD(slange_,dlange_)(
10705
        $b() = $TFD(slange_,dlange_)(
10714
        &pnorm,
10706
        &pnorm,
10715
        &(integer){$PRIV(__n_size)},
10707
        &$PRIV(__n_size),
10716
        &(integer){$PRIV(__m_size)},
10708
        &$PRIV(__m_size),
10717
        $P(A),
10709
        $P(A),
10718
        &(integer){$PRIV(__n_size)},
10710
        &$PRIV(__n_size),
10719
        work);
10711
        work);
10720
        if ($norm() == 2)
10712
        if ($norm() == 2)
10721
            free (work);
10713
            free (work);
10722
10714
10723
',
10715
',
...
...
10807
            puplo = \'L\';
10799
            puplo = \'L\';
10808
10800
10809
        $b() = $TFD(slansy_,dlansy_)(
10801
        $b() = $TFD(slansy_,dlansy_)(
10810
        &pnorm,
10802
        &pnorm,
10811
        &puplo,
10803
        &puplo,
10812
        &(integer){$PRIV(__n_size)},
10804
        &$PRIV(__n_size),
10813
        $P(A),
10805
        $P(A),
10814
        &(integer){$PRIV(__n_size)},
10806
        &$PRIV(__n_size),
10815
        work);
10807
        work);
10816
        if ($norm() == 2 || $norm() == 1)
10808
        if ($norm() == 2 || $norm() == 1)
10817
            free (work);
10809
            free (work);
10818
10810
10819
',
10811
',
...
...
10910
10902
10911
        $b() = $TFD(slantr_,dlantr_)(
10903
        $b() = $TFD(slantr_,dlantr_)(
10912
        &pnorm,
10904
        &pnorm,
10913
        &puplo,
10905
        &puplo,
10914
        &pdiag,
10906
        &pdiag,
10915
        &(integer){$PRIV(__m_size)},
10907
        &$PRIV(__m_size),
10916
        &(integer){$PRIV(__n_size)},
10908
        &$PRIV(__n_size),
10917
        $P(A),
10909
        $P(A),
10918
        &(integer){$PRIV(__n_size)},
10910
        &$PRIV(__n_size),
10919
        work);
10911
        work);
10920
        if ($norm() == 2)
10912
        if ($norm() == 2)
10921
            free (work);
10913
            free (work);
10922
10914
10923
',
10915
',
...
...
11013
11005
11014
11006
11015
        $TFD(sgemm_,dgemm_)(
11007
        $TFD(sgemm_,dgemm_)(
11016
        &ptransa,
11008
        &ptransa,
11017
        &ptransb,
11009
        &ptransb,
11018
        &(integer){$PRIV(__r_size)},
11010
        &$PRIV(__r_size),
11019
        &(integer){$PRIV(__s_size)},
11011
        &$PRIV(__s_size),
11020
        &kk,
11012
        &kk,
11021
        $P(alpha),
11013
        $P(alpha),
11022
        $P(A),
11014
        $P(A),
11023
        &(integer){$PRIV(__m_size)},
11015
        &$PRIV(__m_size),
11024
        $P(B),
11016
        $P(B),
11025
        &(integer){$PRIV(__p_size)},
11017
        &$PRIV(__p_size),
11026
        $P(beta),
11018
        $P(beta),
11027
        $P(C),
11019
        $P(C),
11028
        &(integer){$PRIV(__r_size)});
11020
        &$PRIV(__r_size));
11029
',
11021
',
11030
      Doc => '
11022
      Doc => '
11031
11023
11032
=for ref
11024
=for ref
11033
11025
...
...
11171
        %}
11163
        %}
11172
11164
11173
        $TFD(sgemm_,dgemm_)(
11165
        $TFD(sgemm_,dgemm_)(
11174
        &ptrans,
11166
        &ptrans,
11175
        &ptrans,
11167
        &ptrans,
11176
        &(integer){$PRIV(__p_size)},
11168
        &$PRIV(__p_size),
11177
        &(integer){$PRIV(__n_size)},
11169
        &$PRIV(__n_size),
11178
        &(integer){$PRIV(__m_size)},
11170
        &$PRIV(__m_size),
11179
        &alpha,
11171
        &alpha,
11180
        $P(B),
11172
        $P(B),
11181
        &(integer){$PRIV(__p_size)},
11173
        &$PRIV(__p_size),
11182
        $P(A),
11174
        $P(A),
11183
        &(integer){$PRIV(__m_size)},
11175
        &$PRIV(__m_size),
11184
        &beta,
11176
        &beta,
11185
        $P(C),
11177
        $P(C),
11186
        &(integer){$PRIV(__p_size)});
11178
        &$PRIV(__p_size));
11187
',
11179
',
11188
      Doc => '
11180
      Doc => '
11189
11181
11190
=for ref
11182
=for ref
11191
11183
...
...
11217
        %}
11209
        %}
11218
11210
11219
        $TFD(sgemmb_,dgemmb_)(
11211
        $TFD(sgemmb_,dgemmb_)(
11220
        &ptrans,
11212
        &ptrans,
11221
        &ptrans,
11213
        &ptrans,
11222
        &(integer){$PRIV(__p_size)},
11214
        &$PRIV(__p_size),
11223
        &(integer){$PRIV(__n_size)},
11215
        &$PRIV(__n_size),
11224
        &(integer){$PRIV(__m_size)},
11216
        &$PRIV(__m_size),
11225
        &alpha,
11217
        &alpha,
11226
        $P(B),
11218
        $P(B),
11227
        &(integer){$PRIV(__p_size)},
11219
        &$PRIV(__p_size),
11228
        $P(A),
11220
        $P(A),
11229
        &(integer){$PRIV(__m_size)},
11221
        &$PRIV(__m_size),
11230
        &beta,
11222
        &beta,
11231
        $P(C),
11223
        $P(C),
11232
        &(integer){$PRIV(__p_size)});
11224
        &$PRIV(__p_size));
11233
',
11225
',
11234
      Doc => '
11226
      Doc => '
11235
11227
11236
=for ref
11228
=for ref
11237
11229
...
...
11266
        %}
11258
        %}
11267
11259
11268
        $TFD(sgemm_,dgemm_)(
11260
        $TFD(sgemm_,dgemm_)(
11269
        &btrans,
11261
        &btrans,
11270
        &atrans,
11262
        &atrans,
11271
        &(integer){$PRIV(__p_size)},
11263
        &$PRIV(__p_size),
11272
        &(integer){$PRIV(__n_size)},
11264
        &$PRIV(__n_size),
11273
        &(integer){$PRIV(__m_size)},
11265
        &$PRIV(__m_size),
11274
        &alpha,
11266
        &alpha,
11275
        $P(B),
11267
        $P(B),
11276
        &(integer){$PRIV(__p_size)},
11268
        &$PRIV(__p_size),
11277
        $P(A),
11269
        $P(A),
11278
        &(integer){$PRIV(__n_size)},
11270
        &$PRIV(__n_size),
11279
        &beta,
11271
        &beta,
11280
        $P(C),
11272
        $P(C),
11281
        &(integer){$PRIV(__p_size)});
11273
        &$PRIV(__p_size));
11282
',
11274
',
11283
      Doc => '
11275
      Doc => '
11284
11276
11285
=for ref
11277
=for ref
11286
11278
...
...
11316
11308
11317
11309
11318
        $TFD(ssyrk_,dsyrk_)(
11310
        $TFD(ssyrk_,dsyrk_)(
11319
        &puplo,
11311
        &puplo,
11320
        &ptrans,
11312
        &ptrans,
11321
        &(integer){$PRIV(__p_size)},
11313
        &$PRIV(__p_size),
11322
        &kk,
11314
        &kk,
11323
        $P(alpha),
11315
        $P(alpha),
11324
        $P(A),
11316
        $P(A),
11325
        &(integer){$PRIV(__m_size)},
11317
        &$PRIV(__m_size),
11326
        $P(beta),
11318
        $P(beta),
11327
        $P(C),
11319
        $P(C),
11328
        &(integer){$PRIV(__p_size)});
11320
        &$PRIV(__p_size));
11329
',
11321
',
11330
      Doc => '
11322
      Doc => '
11331
11323
11332
=for ref
11324
=for ref
11333
11325
...
...
11731
        if ($id())
11723
        if ($id())
11732
            pwork = \'D\';
11724
            pwork = \'D\';
11733
11725
11734
        $TFD(slasrt_,dlasrt_)(
11726
        $TFD(slasrt_,dlasrt_)(
11735
        &pwork,
11727
        &pwork,
11736
        &(integer){$PRIV(__n_size)},
11728
        &$PRIV(__n_size),
11737
        $P(d),
11729
        $P(d),
11738
        $P(info));
11730
        $P(info));
11739
',
11731
',
11740
      Doc => '
11732
      Doc => '
11741
11733
...
...
11795
            default: puplo = \'A\';
11787
            default: puplo = \'A\';
11796
        }
11788
        }
11797
11789
11798
        $TFD(slacpy_,dlacpy_)(
11790
        $TFD(slacpy_,dlacpy_)(
11799
        &puplo,
11791
        &puplo,
11800
        &(integer){$PRIV(__m_size)},
11792
        &$PRIV(__m_size),
11801
        &(integer){$PRIV(__n_size)},
11793
        &$PRIV(__n_size),
11802
        $P(A),
11794
        $P(A),
11803
        &(integer){$PRIV(__m_size)},
11795
        &$PRIV(__m_size),
11804
        $P(B),
11796
        $P(B),
11805
        &(integer){$PRIV(__p_size)});
11797
        &$PRIV(__p_size));
11806
',
11798
',
11807
      Doc => '
11799
      Doc => '
11808
11800
11809
=for ref
11801
=for ref
11810
11802
...
...
11849
            *k1, integer *k2, integer *ipiv, integer *incx);
11841
            *k1, integer *k2, integer *ipiv, integer *incx);
11850
        %}
11842
        %}
11851
11843
11852
11844
11853
        $TFD(slaswp_,dlaswp_)(
11845
        $TFD(slaswp_,dlaswp_)(
11854
        &(integer){$PRIV(__n_size)},
11846
        &$PRIV(__n_size),
11855
        $P(A),
11847
        $P(A),
11856
        &(integer){$PRIV(__m_size)},
11848
        &$PRIV(__m_size),
11857
        $P(k1),
11849
        $P(k1),
11858
        $P(k2),
11850
        $P(k2),
11859
        $P(ipiv),
11851
        $P(ipiv),
11860
        $P(inc));
11852
        $P(inc));
11861
',
11853
',
...
...
12302
12294
12303
    i = 0;
12295
    i = 0;
12304
    for (;;)
12296
    for (;;)
12305
    {
12297
    {
12306
        i++;
12298
        i++;
12307
        $TFD(sgemm_,dgemm_)(&ptrans,&ptrans,&(integer){$PRIV(__n_size)},&(integer){$PRIV(__n_size)},
12299
        $TFD(sgemm_,dgemm_)(&ptrans,&ptrans,&$PRIV(__n_size),&$PRIV(__n_size),
12308
            &(integer){$PRIV(__n_size)},&alpha,$P(A),&(integer){$PRIV(__n_size)},   $P(Y), &(integer){$PRIV(__n_size)},
12300
            &$PRIV(__n_size),&alpha,$P(A),&$PRIV(__n_size), $P(Y), &$PRIV(__n_size),
12309
            &beta, p, &(integer){$PRIV(__n_size)});
12301
            &beta, p, &$PRIV(__n_size));
12310
        
12302
        
12311
        if (i == $SIZE(n)) break;
12303
        if (i == $SIZE(n)) break;
12312
12304
12313
        //tmp = $P(Y);
12305
        //tmp = $P(Y);
12314
        //$P(Y) = p;
12306
        //$P(Y) = p;