* [gentoo-science] [sci-mathemetics/freemat] fixed freemat-3.0 ebuild
@ 2007-04-13 4:54 Carmelo Piccione
0 siblings, 0 replies; only message in thread
From: Carmelo Piccione @ 2007-04-13 4:54 UTC (permalink / raw
To: gentoo-science
[-- Attachment #1: Type: text/plain, Size: 1232 bytes --]
Hello,
I couldn't get freemat 3.0 to build on my amd64 laptop for a variety
of reasonings using your latest svn overlay. First of all, the keyword
"~amd64" wasn't listed in the ebuild. I added it just to see how
things would break.
It did break. And the same way as this user reported:
http://www.mail-archive.com/gentoo-science%40lists.gentoo.org/msg00466.html
I looked into it and the patch was simple. In essence some templates
were in a cpp file rather than an hpp file. Attached are the two
patches that are assumed to exist in "sci-mathematics/freemat/files",
and also a patch to the ebuild itself. It builds (and runs) perfectly
fine on my system.
Thanks,
Carmelo
PS: Another issue with default freemat install is that the main tool
files are contained subdirectories of /usr/share/FreeMat-3.0/toolbox/.
A user has to manually add this via the "pathtool" of an open freemat
session (where it is subsequently saved for that user somewhere). To
me this stinks and should be fixed before this build goes mainstream.
In other words, should be done by the ebuild. I am looking into it.
System info:
Linux version 2.6.20-gentoo-r5 (root@localhost) (gcc version 4.1.1
(Gentoo 4.1.1-r3)) #1 PREEMPT Mon Apr 9 00:16:37 MDT 2007
[-- Attachment #2: Math.cpp.patch --]
[-- Type: text/x-diff, Size: 6955 bytes --]
*** libs/libFreeMat/Math.cpp.orig Mon Apr 9 15:52:18 2007
--- libs/libFreeMat/Math.cpp Mon Apr 9 15:52:32 2007
***************
*** 78,373 ****
}
}
- template <class T>
- void addfullcomplex(int N, T*C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[2*i] = A[2*m] + B[2*p];
- C[2*i+1] = A[2*m+1] + B[2*p+1];
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void subtractfullreal(int N, T*C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = A[m] - B[p];
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void subtractfullcomplex(int N, T*C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[2*i] = A[2*m] - B[2*p];
- C[2*i+1] = A[2*m+1] - B[2*p+1];
- m += stride1;
- p += stride2;
- }
- }
-
-
- template <class T>
- void multiplyfullreal(int N, T*C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = A[m] * B[p];
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void multiplyfullcomplex(int N, T*C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[2*i] = A[2*m] * B[2*p] - A[2*m+1] * B[2*p+1];
- C[2*i+1] = A[2*m] * B[2*p+1] + A[2*m+1] * B[2*p];
- m += stride1;
- p += stride2;
- }
- }
-
-
- template <class T>
- void dividefullreal(int N, T*C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = A[m] / B[p];
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void complex_divide(T* c, const T* a, const T* b) {
- double ratio, den;
- double abr, abi, cr;
-
- if( (abr = b[0]) < 0.)
- abr = - abr;
- if( (abi = b[1]) < 0.)
- abi = - abi;
- if( abr <= abi )
- {
- if(abi == 0) {
- if (a[1] != 0 || a[0] != 0)
- abi = 1.;
- c[1] = c[0] = abi / abr;
- return;
- }
- ratio = b[0] / b[1] ;
- den = b[1] * (1 + ratio*ratio);
- cr = (a[0]*ratio + a[1]) / den;
- c[1] = (a[1]*ratio - a[0]) / den;
- }
- else
- {
- ratio = b[1] / b[0] ;
- den = b[0] * (1 + ratio*ratio);
- cr = (a[0] + a[1]*ratio) / den;
- c[1] = (a[1] - a[0]*ratio) / den;
- }
- c[0] = cr;
- }
-
- template <class T>
- void dividefullcomplex(int N, T*C, const T*A, int stride1, const T*B,
- int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- complex_divide<T>(C+2*i,A+2*m,B+2*p);
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void lessthanfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
- int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (A[m] < B[p]) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- T complex_abs(T real, T imag) {
- double temp;
- if(real < 0)
- real = -real;
- if(imag < 0)
- imag = -imag;
- if(imag > real){
- temp = real;
- real = imag;
- imag = temp;
- }
- if((real+imag) == real)
- return(real);
- temp = imag/real;
- temp = real*sqrt(1.0 + temp*temp); /*overflow!!*/
- return(temp);
- }
-
-
- template <class T>
- void lessthanfunccomplex(int N, logical* C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) <
- complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void lessequalsfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
- int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (A[m] <= B[p]) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void lessequalsfunccomplex(int N, logical* C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) <=
- complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void equalsfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
- int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (A[m] == B[p]) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void equalsfunccomplex(int N, logical* C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = ((A[2*m] == B[2*p]) &&
- (A[2*m+1] == B[2*p+1])) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void notequalsfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
- int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (A[m] != B[p]) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void notequalsfunccomplex(int N, logical* C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = ((A[2*m] != B[2*p]) ||
- (A[2*m+1] != B[2*p+1])) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void greaterthanfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
- int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (A[m] > B[p]) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void greaterthanfunccomplex(int N, logical* C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) >
- complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void greaterequalsfuncreal(int N, logical* C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (A[m] >= B[p]) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
-
- template <class T>
- void greaterequalsfunccomplex(int N, logical* C, const T*A, int stride1,
- const T*B, int stride2) {
- int m, p;
- m = 0; p = 0;
- for (int i=0;i<N;i++) {
- C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) >=
- complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
- m += stride1;
- p += stride2;
- }
- }
/**
* These are the power functions...
--- 78,83 ----
[-- Attachment #3: Math.hpp.patch --]
[-- Type: text/x-diff, Size: 7325 bytes --]
*** libs/libFreeMat/Math.hpp.orig Mon Apr 9 15:52:21 2007
--- libs/libFreeMat/Math.hpp Mon Apr 9 15:52:27 2007
***************
*** 21,27 ****
#define __Math_hpp_
#include "Array.hpp"
!
/**
* Add the two argument arrays together: $$C_n = A_n + B_n$$.
*/
--- 21,27 ----
#define __Math_hpp_
#include "Array.hpp"
! #include <cmath>
/**
* Add the two argument arrays together: $$C_n = A_n + B_n$$.
*/
***************
*** 175,178 ****
--- 175,471 ----
double power_dd(double a, double b);
template <class T>
T complex_abs(T real, T imag);
+
+
+
+ template <class T>
+ void addfullcomplex(int N, T*C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[2*i] = A[2*m] + B[2*p];
+ C[2*i+1] = A[2*m+1] + B[2*p+1];
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void subtractfullreal(int N, T*C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = A[m] - B[p];
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void subtractfullcomplex(int N, T*C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[2*i] = A[2*m] - B[2*p];
+ C[2*i+1] = A[2*m+1] - B[2*p+1];
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+
+ template <class T>
+ void multiplyfullreal(int N, T*C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = A[m] * B[p];
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void multiplyfullcomplex(int N, T*C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[2*i] = A[2*m] * B[2*p] - A[2*m+1] * B[2*p+1];
+ C[2*i+1] = A[2*m] * B[2*p+1] + A[2*m+1] * B[2*p];
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+
+ template <class T>
+ void dividefullreal(int N, T*C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = A[m] / B[p];
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void complex_divide(T* c, const T* a, const T* b) {
+ double ratio, den;
+ double abr, abi, cr;
+
+ if( (abr = b[0]) < 0.)
+ abr = - abr;
+ if( (abi = b[1]) < 0.)
+ abi = - abi;
+ if( abr <= abi )
+ {
+ if(abi == 0) {
+ if (a[1] != 0 || a[0] != 0)
+ abi = 1.;
+ c[1] = c[0] = abi / abr;
+ return;
+ }
+ ratio = b[0] / b[1] ;
+ den = b[1] * (1 + ratio*ratio);
+ cr = (a[0]*ratio + a[1]) / den;
+ c[1] = (a[1]*ratio - a[0]) / den;
+ }
+ else
+ {
+ ratio = b[1] / b[0] ;
+ den = b[0] * (1 + ratio*ratio);
+ cr = (a[0] + a[1]*ratio) / den;
+ c[1] = (a[1] - a[0]*ratio) / den;
+ }
+ c[0] = cr;
+ }
+
+ template <class T>
+ void dividefullcomplex(int N, T*C, const T*A, int stride1, const T*B,
+ int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ complex_divide<T>(C+2*i,A+2*m,B+2*p);
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void lessthanfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
+ int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (A[m] < B[p]) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ T complex_abs(T real, T imag) {
+ double temp;
+ if(real < 0)
+ real = -real;
+ if(imag < 0)
+ imag = -imag;
+ if(imag > real){
+ temp = real;
+ real = imag;
+ imag = temp;
+ }
+ if((real+imag) == real)
+ return(real);
+ temp = imag/real;
+ temp = real*sqrt(1.0 + temp*temp); /*overflow!!*/
+ return(temp);
+ }
+
+
+ template <class T>
+ void lessthanfunccomplex(int N, logical* C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) <
+ complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void lessequalsfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
+ int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (A[m] <= B[p]) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void lessequalsfunccomplex(int N, logical* C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) <=
+ complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void equalsfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
+ int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (A[m] == B[p]) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void equalsfunccomplex(int N, logical* C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = ((A[2*m] == B[2*p]) &&
+ (A[2*m+1] == B[2*p+1])) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void notequalsfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
+ int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (A[m] != B[p]) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void notequalsfunccomplex(int N, logical* C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = ((A[2*m] != B[2*p]) ||
+ (A[2*m+1] != B[2*p+1])) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void greaterthanfuncreal(int N, logical* C, const T*A, int stride1, const T*B,
+ int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (A[m] > B[p]) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void greaterthanfunccomplex(int N, logical* C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) >
+ complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void greaterequalsfuncreal(int N, logical* C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (A[m] >= B[p]) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
+
+ template <class T>
+ void greaterequalsfunccomplex(int N, logical* C, const T*A, int stride1,
+ const T*B, int stride2) {
+ int m, p;
+ m = 0; p = 0;
+ for (int i=0;i<N;i++) {
+ C[i] = (complex_abs<T>(A[2*m],A[2*m+1]) >=
+ complex_abs<T>(B[2*p],B[2*p+1])) ? 1 : 0;
+ m += stride1;
+ p += stride2;
+ }
+ }
#endif
[-- Attachment #4: freemat-3.0.ebuild.patch --]
[-- Type: text/x-diff, Size: 749 bytes --]
*** freemat-3.0.ebuild.orig Thu Apr 12 22:37:48 2007
--- freemat-3.0.ebuild Thu Apr 12 22:37:56 2007
***************
*** 17,23 ****
LICENSE="GPL-2"
SLOT="0"
! KEYWORDS="~x86"
DEPEND=">=sys-libs/ncurses-5.4-r5 virtual/blas virtual/lapack dev-libs/ffcall\
sci-libs/umfpack sci-libs/arpack >=x11-libs/qt-4.2"
--- 17,23 ----
LICENSE="GPL-2"
SLOT="0"
! KEYWORDS="~amd64 ~x86"
DEPEND=">=sys-libs/ncurses-5.4-r5 virtual/blas virtual/lapack dev-libs/ffcall\
sci-libs/umfpack sci-libs/arpack >=x11-libs/qt-4.2"
***************
*** 28,33 ****
--- 28,35 ----
unpack ${A}
cd ${S}
epatch "${FILESDIR}/${PN}-${PV}.patch"
+ epatch "${FILESDIR}/Math.cpp.patch"
+ epatch "${FILESDIR}/Math.hpp.patch"
}
src_compile() {
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2007-04-13 4:55 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2007-04-13 4:54 [gentoo-science] [sci-mathemetics/freemat] fixed freemat-3.0 ebuild Carmelo Piccione
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox