Comparison Python, Numpy, MatLab, Fortran

Useful info for optimization

https://modelingguru.nasa.gov/docs/DOC-1762

debugging and optimization flags

http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/fortran-mac/GUID-1DB4628E-2171-47B1-83CB-1D26FF71C5A0.htm

HDF5 undefined reference and can't find hdf5.h

-lhdf5
http://ubuntuforums.org/showthread.php?t=1246165

HDF5 and Ubuntu

http://micro.stanford.edu/wiki/Install_HDF5#Ubuntu

Tuning a Monte Carlo Algo on GPU

http://www.pgroup.com/lit/articles/insider/v2n1a4.htm

Array of Vectors using Thrust

thrust::device_vector<float> vectors[3];
//thrust::device_vector<float> *vectors = new thrust::device_vector<float>[3];

vectors[0] = thrust::device_vector<float>(10);
vectors[1] = thrust::device_vector<float>(10);
vectors[2] = thrust::device_vector<float>(10);

http://stackoverflow.com/questions/12406948/array-of-vectors-using-thrust

Generating a random number vector between 0 and 1.0 using Thrust

http://stackoverflow.com/questions/12614164/generating-a-random-number-vector-between-0-and-1-0-using-thrust

#include <thrust/random.h>
#include <thrust/device_vector.h>
#include <thrust/transform.h>
#include <thrust/iterator/counting_iterator.h>
#include <iostream>

struct prg
{
    float a, b;

    __host__ __device__
    prg(float _a=0.f, float _b=1.f) : a(_a), b(_b) {};

    __host__ __device__
        float operator()(const unsigned int n) const
        {
            thrust::default_random_engine rng;
            thrust::uniform_real_distribution<float> dist(a, b);
            rng.discard(n);

            return dist(rng);
        }
};


int main(void)
{
    const int N = 20;

    thrust::device_vector<float> numbers(N);
    thrust::counting_iterator<unsigned int> index_sequence_begin(0);

    thrust::transform(index_sequence_begin,
            index_sequence_begin + N,
            numbers.begin(),
            prg(1.f,2.f));

    for(int i = 0; i < N; i++)
    {
        std::cout << numbers[i] << std::endl;
    }

    return 0;
}

Template library for linear algebra: Eigen

Eigen
http://eigen.tuxfamily.org/index.php?title=Main_Page

A MATLAB toolbox for the time-domain simulation of acoustic wave fields (in Fluid)

http://www.k-wave.org/index.php

Natural Units

http://en.wikipedia.org/wiki/Natural_units

Plank Unit

"Natural units" (particle physics) [edit]

Unit	Metric value	Derivation
1 eV−1 of length	1.97×10−7 m
1 eV of mass	1.78×10−36 kg
1 eV−1 of time	6.58×10−16 s
1 eV of temperature	1.16×104 K
1 unit of electric charge (L–H)	5.29×10−19 C
1 unit of electric charge (G)	1.88×10−18 C

In particle physics, the phrase "natural units" generally means:^[4][5]

where  is the reduced Planck constant, c is the speed of light, and k_B is the Boltzmann constant.

Like the other systems (see above), the electromagnetism units in Planck units can be based on either Lorentz–Heaviside units or Gaussian units. The unit of charge is different in each.

Finally, one more unit is needed. Most commonly, electron-volt (eV) is used, despite the fact that this is not a "natural" unit in the sense discussed above – it is defined by a natural property, the elementary charge, and the anthropogenic unit of electric potential, the volt. (The SI prefixed multiples of eV are used as well: keV, MeV, GeV, etc.)

With the addition of eV (or any other auxiliary unit), any quantity can be expressed. For example, a distance of 1 cm can be expressed in terms of eV, in natural units, as:^[5]

Rounding float point number to nearest integer

http://blog.frama-c.com/index.php?post/2013/05/02/nearbyintf1

GNU Scientific Library

http://www.physics.buffalo.edu/phy411-506/tools/gsl/gsl.hpp

gsl.hpp

pointer to 2D vector c++

complex<double>* m_pMatA = new complex<double> [size*size];

Passing Objects by Reference and By Pointer

http://people.cs.vt.edu/~kafura/cs2704/reference.html


??

   window.Display(box1);  // uses by reference
   window.Display(box2);  // uses by pointer
   window.Display(&box3);  // uses by pointer
   window.Display(*box4);  // uses by referen

http://stackoverflow.com/questions/410593/pass-by-reference-value-in-c

Pointer to C++ STL vector

http://stackoverflow.com/questions/6946217/pointer-to-a-vector

Fortran data type

http://en.wikibooks.org/wiki/Fortran/complex_types

If you want double-precision complex numbers, you're pretty much stuck with specifying a precision, and hoping that the compiler likes that format. Here's where portability comes in: If, for instance, the machine has floating point types of lengths 4, 8, and 16, and I specify a complex length of 8, 16, or 32, I'm likely to get a pair of floating point numbers at the size I expect. If, however, I specify a length of some other value, for instance, 10, then I'm likely to get a pair of 4s or 8s, depending on what the compiler likes to do. So, in general, to get the values as double-precision, I'd code:

 COMPLEX*16 myVariable, anotherVariable, anArray(2,3)

iterating through 2d "vector" c++

http://stackoverflow.com/questions/1784573/iterator-for-2d-vector

Although your question is not very clear, I'm going to assume you mean a 2D vector to mean a vector of vectors:

vector< vector<int> > vvi;

Then you need to use two iterators to traverse it, the first the iterator of the "rows", the second the iterators of the "columns" in that "row":

//assuming you have a "2D" vector vvi (vector of vector of int's)
vector< vector<int> >::iterator row;
vector<int>::iterator col;
for (row = vvi.begin(); row != vvi.end(); row++) {
    for (col = row->begin(); col != row->end(); col++) {
        // do stuff ...
    }
}

Multi Dimensional Array

The more STL savvy coder will opt for a vector-of-a-vector approach to MD arrays, rather than Nested New:

1 2 3 4

// to make a [5][6] array: vector< vector<int> > stillevil( 5, vector<int>(6) ); stillevil[2][3] = 1;

Not a lot to say about this one. Like Nested New it's incompatible with other MD array flavors. If you need to pass this array to a function, none of the above functions will work.

Also, like Nested New, it's inefficent in that is requires additional memory and has double indirection.

On the plus side, you don't need cleanup code, and the allocation code is not as ugly (but still pretty ugly!)

Homework: Computational Physics Quantum Mechanics: Propagator of a Harmonic Oscillator

http://physweb.bgu.ac.il/COURSES/QuantumMechCohen/ExercisesPool/EXERCISES/ex_8130_sol_Y11.pdf

Linear Algebra Preliminaries and Set Theory

http://www.egr.msu.edu/classes/me851/jchoi/lecture/Linear_Algebra_Notes_Packard.pdf

Quick Description of SVD

http://web.eecs.utk.edu/~dongarra/etemplates/node40.html