1. Build a custom library: To interface with Intel MKL from Python we recommend you use the custom library builder in the tools/builder sub-directory of the Intel MKL package. The Intel® MKL User's Guide has documentation on this tool (docs online). Here briefly are the steps I took to do this:
   
   
   1. Set up your environment to use the desired version of Intel MKL:
      source /<MKLpath>/tools/environment/mklvarsem64t.sh
   2. Build the DLL:
      cd /<MKLpath>/tools/builder
make em64t name=~/libmkl4py export=cblas_list
   3. The library as built above will depend on the OpenMP* threading runtime library used by Intel MKL (libiomp5.so). You should make sure that both libraries, libmkl4py.so and libiomp5.so, are in a directory specified in the LD_LIBRARY_PATH environment variable.
2. Call Intel MKL in your Python script: The following is a simple script (also available here) that loads the shared library just created and calls the matrix function.
   

   from ctypes import *
   
   # Load the share library
   mkl = cdll.LoadLibrary("./libmkl4py.so")
   cblas_dgemm = mkl.cblas_dgemm
   
   def print_mat(mat, m, n):
     for i in xrange(0,m):
       print " ",
       for j in xrange(0,n):
         print mat[i*n+j],
       print 
   
   # Initialize scalar data
   Order = 101  # 101 for row-major, 102 for column major data structures
   TransA = 111 # 111 for no transpose, 112 for transpose, and 113 for conjugate transpose
   TransB = 111
   m = 2
   n = 4
   k = 3
   lda = k
   ldb = n
   ldc = n
   alpha = 1.0
   beta = -1.0
   
   # Create contiguous space for the double precision array
   amat = c_double * 6      
   bmat = c_double * 12
   cmat = c_double * 8
   
   # Initialize the data arrays
   a = amat(1,2,3, 4,5,6)
   b = bmat(0,1,0,1, 1,0,0,1, 1,0,1,0)
   c = cmat(5,1,3,3, 11,4,6,9)
   
   print "\nMatrix A ="
   print_mat(a,2,3) 
   print "\nMatrix B ="
   print_mat(b,3,4)
   print "\nMatrix C ="
   print_mat(c,2,4)
   
   print "\nCompute", alpha, "* A * B + ", beta, "* C"
   
   # Call Intel MKL by casting scalar parameters and passing arrays by reference
   cblas_dgemm( c_int(Order), c_int(TransA), c_int(TransB), \
                c_int(m), c_int(n), c_int(k), c_double(alpha), byref(a), c_int(lda), \
                byref(b), c_int(ldb), c_double(beta), byref(c), c_int(ldc))
   
   print_mat(c,2,4)
   print

3. A few notes:
   • Matrices in the BLAS and LAPACK parts of Intel MKL are stored in one dimensional arrays and integers are used to specify their geometry.
   • I've actually loaded here CBLAS interface to the general matrix multiply function which allows you to choose how the matrix is specified. In my script I've listed the matrix by rows (row-major ordering). If you do not use the cblas interface to the BLAS or if you use LAPACK you should keep in mind that these functions assume the Fortran method of listing matrices by columns (column-major ordering).

We extended the list of examples demonstrate how possible to call different ( not only widespread example like dgemm ) from the Python program:

See the list of 3 different examples attached:
dft.zip  - shows the Python program calls 1D DFTI API
spblas.zip - shows how to call  matrix-matrix multiplication routine for a sparse matrix stored in the block compressed format (BSR)
vsl.zip - shows how to call vdRngGaussian routine ( generates normally distributed random numbers)  from VSL domain.

Notes:
Each zip file contains  *.res and *_list files mean input file and file for custom library building correspondingly

Dear all,

In this note I would like to remove some confusion about FFT interfaces supported by Intel® MKL.

Firstly, some history. The library has been providing Discrete Fourier Transforms Interface (DFTI) since MKL 6.0 (2002). In 2005, Intel MKL 8.1 added open source FFTW2 and FFTW3 wrappers to support essential functionality of the widely known Fastest Fourier Transform in the West library. In order to use the wrappers one had to compile them by their favourite C compiler.

Starting with Intel MKL 10.2 (2009), in particular with the latest release of MKL 10.2 Update 2, the FFTW3 interface has been fully integrated in MKL, so that an application using FFTW3 can be linked directly to the Intel MKL. Thus, an application using FFT functionality of Intel MKL can use either DFTI or FFTW3 interface, without extra effort for building the wrappers.

You are encouraged to upgrade your copy of Intel MKL to the latest MKL release.

With Intel MKL 10.2 and later all you need to use FFT functionality, either via DFTI or FFTW3 interface, is to link with Intel MKL.

For advanced use however the FFTW2 and FFTW3 wrappers to Intel MKL are provided in open source. For example,

• The FFTW2 interface doesn't support single precision and double precision interface in separate name spaces, so one has to compile the FFTW2 wrappers for the particular case of use.
• The Fortran interface of FFTW3 in Intel MKL does not support GNU g77 name decoration scheme. In that case one can still use FFTW3 interface with Intel MKL by compiling FFTW3 wrappers specially for use with g77 compiler.
• The implementation of the FFTW2 and FFTW3 wrappers may serve an additional usage example of MKL DFTI.

More details on FFTW2 and FFTW3 interfaces to Intel MKL can be found in MKL Reference Manual, Appendix G.

2. Intel® MKL for windows
   You can install MKL seperately or install the intergarted MKL when install Intel Fortran Compiler Professional version. 

3. Microsoft* Visual Studio 2005 or 2008.
For who'd like to build x64 bit appliation, please install the MSVC* package which supports X64 development.

Step1 : Which kind of application: ia32, em64t or ia64 application you need to build?
Which target machine you need your application run on?
ia32: 32 bit application. 
EM64t: Intel 64 bit application
IA64:  Intel Itanium 64bit application. 

Most of us may build ia32 or em64t application on a xeon machine with windows*. Then in MSVC* environment, please check the project configuration manager=> active platform.  They should be  "ia32" or "X64" (which is corresponding to em64t).

Step 2 : Which MKL library you need link against?
2.1) please check the on-line KB article Intel® Math Kernel Library Link Line Advisor  After choose it, you can get which libraries you need to list. 

For example,
"mkl_intel_c.lib mkl_intel_thread.lib mkl_core.lib libiomp5md.lib" are enough for a ia32 windows application generally.
"mkl_intel_lp64.lib mkl_intel_thread.lib mkl_core.lib libiomp5md.lib" are ok for a X64 windows appliation

Step 3: How to link MKL in your project manually?
3.1)  Please follow the steps in how to use MKL in MSVC  to add the include path, library path and mkl library as the article show. 

For example, add include path manually


please take care of about library path,  you need enter right directory:
<MKL install dir>\ia32,  for ia32 application
<MKL install dir>\em64t, for X64 application
<MKL install dir>\ia64, for IA64 application
they can't be mixed. 


Step 4: How to link MKL in your project automatically - One Button Support  (optional)
The recent MKL version have provided one "build" menu in MSVC environment. Click one button, all of environment setting and required library are ready in your project.
* This step can replace the step3 in most of case.  
Or if the button is not show, please try step3, set the paths and library manually.
4.1) See below sreencopy in MSVC 2005, click the version you need

Then the required library will be added in your project automatically.


4.2) In Visual Fortran compiler, it is a little different, to integrate MKL,  please click the compiler option as below, change the "No" to value like /Qmkl:parallel or /Qmkl:sequential

Please note: some interface libraries (i.e mkl_lapack95.lib mkl_blas95.lib fftw3xc_ms) are not MKL standard library,  so the "one button" integration don't support it.  You may add them manually if you need to use them.

Step 5: About Compaq*Visual Fortran support and porting from 32bit to 64bit (Optional for who have used CVF)
CVF and Intel Fortran compiler use different call convention by default:
CVF: stdcall
Intel Fortran, C Compiler: cdecl (default interface of the Microsoft Visual C* application)

5.1) MKL support both of them on ia32 platform, but if you are porting from CVF to intel Fortran, you may take care of the required library: mkl_intel_s or mkl_intel_c.lib

• Using the CVF compiler
  The CVF compiler will link with mkl_intel_s[_dll].lib if routines are compiled with the default interface. However, if you compile with the option /iface=(cref,nomixed_str_len_arg), the compiler will link with mkl_intel_c[_dll].lib .
• Using the Intel® Fortran compiler
  The Intel Fortran compiler will link with mkl_intel_c[_dll].lib by default. But if the /Gm option is used, call mkl_intel_s  [_dll].lib (/Gm enables CVF and Powerstation calling convention compatibility, so does /iface:cvf).

5.2) MKL don't provide em64t and IA64 CVF interface support.  So if you are porting CVF 32bit application to X64 or IA64 platform with Intel Fortran compiler and MKL. Please note, you must to link "mkl_intel_lp64|ilp64, mkl_intel_thread, mkl_core.lib" and remove the compiler option /Gm or /iface:cvf.

Here is a MSVC 2005 project (Intel fortran 11.0.0.074 IA32 application) for your reference.DFT_VF_sample.zip

Troubleshooting
When build the project,
1. fatal error LNK1104: cannot open file 'mkl_xxx.lib'
please make sure the library is in the library path and the path you marked in step 3 or step 4 are right one

2. "error #7002: Error opening the compiled module file.  Check INCLUDE paths. [MKL_DFTI]."
Please add the header file mkl_dfti.f90 in your code, for example,

! Include to build module MKL_DFTI
INCLUDE 'mkl_dfti.f90'
before  the code line
USE MKL_DFTI

Or copy the mkl_dfti.f90 file to the source directory of your project and include it in your Project. 

To see what libraries are recommended for a particular use case, specify the parameters in the drop down lists below.

Note: For applications running on IA-32 with the Windows* operating system it is possible to use mkl_intel_s.lib instead of mkl_intel_c.lib (or mkl_intel_s_dll.lib instead of mkl_intel_c_dll.lib). This interface is compatible with the Compaq* Visual Fortran calling convention.

Note: For applications calling Fortan 95 Interface library for BLAS an LAPCK: mkl_blas95.lib mkl_blas95_lp64.lib mkl_lapack95.lib and so on. Please add them manually. For example,  the link line is like:
mkl_lapack95.lib mkl_intel_c.lib mkl_intel_thread.lib mkl_core.lib libiomp5md.lib

Note: if the option "-Qopenmp or -openmp" are not recognized by the compiler, please use libiomp5md.lib or -liomp5 instead.

Find more information on linking in the Intel® MKL User's Guide