Hi,

I'm currently up to working on building the dependencies for our Nemo
computer algebra package for Julia:

https://github.com/wbhart/Nemo.jl

We have dependencies on the following C libraries:

libpari (Pari/GP)
Antic (https://github.com/wbhart/Antic)
Flint (https://github.com/wbhart/flint2)
mpfr >= 3.1.2
gmp >= 5.1

Whatever logic I had already coded up in our build.jl to build these on
Windows 64 and use them from within Julia no longer works. We always knew
that there were going to be changes in the way things worked, so this is
not unexpected.

So I thought I would take a look at the OpenSUSE build service. But flint,
pari and antic are not available on there. (I found the WebRPM package for
Julia and have been using that.)

It looks like someone has tried to build flint on there, but their system
doesn't cope with the flint build system (or vice versa if you prefer).

Pari only builds on Windows 64 with some coaxing (I have succeeded in doing
that). It certainly won't build with OpenSUSE.

So this means I have to build these binaries myself perhaps and just
download them from somewhere on the web, which I'm happy to do.

So I tried building binaries in both msys2 and mingw64. After much work I
cannot figure out where Julia expects to find the binaries. I've tried
setting PATH and Libdl.LD_LOAD_PATH appropriately. I've tried static and
dynamic libraries, but under no circumstances can I get Julia to find the
libraries. It just says the "module is not found" when trying to ccall them.

Moreover, OpenSUSE doesn't provide a "make" package, as far as I can see.
And make is not available from the GitBash shell in Julia on Windows 64. So
even building the software from within Julia currently seems impossible.

I also had problems with the gcc not wanting to build 64 bit binaries.

Given that OpenSUSE appears out of the question for us on Windows 64. can
anyone shed any light on how to get Julia compatible libraries built
(msys2, mingw64??) and what the current best practice is for ccall'ing
those binaries (how to set the linker path?).

Note that flint and pari both have custom configure arguments that must be
set and neither flint nor pari uses autotools, though both roughly emulate
an autotools build with some extra bells and whistles.

Any help would be very much appreciated. We have everything working
beautifully on Linux, but one of the big selling points for us is that the
entire Julia stack works natively on Windows. This is an especially big
thing for us given that IJulia also works on Windows (most computer algebra
systems do not work on Windows).

Julia is working beautifully for us and we have 40-50,000 lines of Julia
code locally for our computer algebra package (Nemo + Hecke). But getting
it working on Windows just seems to be outside of my current skill set.

One other minor question: because we currently need to build the libraries
ourselves, we have to (or would like to) run configure and make, etc., from
the shell in Julia. This means directories have to be converted from the
C:\\abc\\def style to /c/abc/def/ style. Is there a Julia function for
doing this, or a best practice?

Bill.

Reply via email to