C / C++ / MFC

	// Get the number of processors in this system
	int iCPU = 0;
	iCPU = omp_get_num_procs();
	cout << "# of CPU's " << dec << +iCPU << endl;

gets "4" which is number of CPU's 

	int iMAXThread = 0;
	iMAXThread = omp_get_max_threads();

	cout << "# of iMAXThread " << dec << +iMAXThread << endl;

also gets "4" - apparently default of "one thread to CPU ?" 



	// Now set the number of threads 
	omp_set_num_threads(10);

	iMAXThread = omp_get_max_threads();

returns "10" per "system ?" 

	cout << "# of iMAXThread " << dec << +iMAXThread << endl;

	exit(1);

<div class="op">Quote:</div>$ cat example.c 
 #include <omp.h>
 #include <stdio.h>

int main()
{
 #pragma omp parallel
    {
        int ID = omp_get_thread_num();
        printf("hello(%d)", ID);
        printf("world(%d)\n", ID);
    }

    return 0;
}
$ gcc -fopenmp example.c -o example
$ ./example
hello(1)world(1)
hello(0)world(0)
hello(3)world(3)
hello(2)world(2)
$ ./example
hello(3)world(3)
hello(0)world(0)
hello(1)world(1)
hello(2)world(2)
$ ./example
hello(3)world(3)
hello(2)hello(1)world(1)
hello(0)world(0)
world(2)

int omp_get_num_procs();

Vaclav_ wrote:

I have noticed that some code posts here include manually building the "make".
Why if run of the mill IDE does it "automatically" ?

leon de boer wrote:

all the code is pubic domain

Quote:

I have noticed that some code posts here include manually building the "make". Why if run of the mill IDE does it "automatically" ?

/*-ScanlineLine2D-----------------------------------------------------------
 Scanline (sy) intersect and the line between the two vertices. The return
 will be 0 for no intersect or 1 and px will contain x intersect value.
 A horizontal line on the scan line will return no points as is consistant
 with scan lining.
 ---------------------------------------------------------------------------*/
short ScanlineLine2D(long x1, long y1,				// Vertex 1 (x1,y1)
					 long x2, long y2,				// Vertex 2 (x2,y2)
                     long sy, 		                // Scan line y value
                     long* px1){					// X interection pt
    long xt;
	double t;

	if (y2 == y1) return (0);										// Trivial fail horizontal line even if coincides with sy
	if (((sy >= y1) && (sy <= y2)) || ((sy >= y2) && (sy <= y1))){	// Check sy within range between y1 and y2
		
		// yt = (y2-y1)*t + y1		where 0 <= t <= 1, 
		// Re-arranging  t = (yt - y1)/(y2-y1)
		// Our yt value will be sy-epsilon so we don't get single corner points
		// t = ((sy-epsilon) - y1)/(y2-y1)
		// Re-arranging for floats   t = ((sy-y1)-epsilon)/(y2-y1)
		t = ((double)(sy-y1)-FLT_EPSILON)/(double)(y2-y1);		// Calculate t value

		if ( (t >= 0.0) && (t <= 1.0)) {				// Check valid 't'  0.0 <= t <= 1.0
			// xt = (x2-x1)*t + x1		where 0 <= t <= 1 
			xt = (long)((double)(x2-x1)*t) + x1;				// Calculate x at 't'
			if (px1) (*px1) = xt;											// Update intersect point x value
			return (1);												// We have 1 interesect point
		} else return (0);											// Invalid t value no intersection
	} else return (0);												// Return zero sy not in y1-y2 range
}


/*-ScanlineQuadBezier2D-----------------------------------------------------
 Scanline (sy) intersect and the quad bezier between the 3 control points.
 The return will be 0 for no intersect, 1 and px1 will contain x intersect 
 value or 2 and px1 and px2 will contain the x interect values.
 ---------------------------------------------------------------------------*/
short ScanlineQuadBezier2D(long x1, long y1,			// Vertex 1 (x1,y1) = On grid start pt
						   long x2, long y2,			// Vertex 2 (x2,y2) = Control Pt
						   long x3, long y3,			// Vertex 3 (x1,y1) = On grid End point
               			   long sy, 							// Scan line y value
                     	   long* px1, long* px2){		// Interection pt(s)

    short rslt;
	long dx0, dy0, dx1, dy1, dx2, dy2, xf;
	long* px;
    double tmf, tdf, tf, ymf;

	dx0 = x2 - x1;													// X diff between x2 and x1
	dy0 = y2 - y1;													// Y diff between y2 and y1
	dx1 = x3 - x2;													// X diff between x3 and x2
	dy1 = y3 - y2;													// Y diff between y3 and y2
	if ((dx0 == 0) && (dy0 == 0) && (dx1 == 0) && (dy1 == 0))		// All 3 points are one and same
		return (0);													// Drop point even if coincides with sy	
	if ((dx0 == 0) && (dy0 == 0))									// First 2 points are one and same
		return (ScanlineLine2D(x2, y2, x3, y3, sy, px1));			// Scanline as a line from (x2,y2)<->(x3,y3)
	if((dx1 == 0) && (dy1 == 0))									// Last two points are one and same	
		return (ScanlineLine2D(x1, y1, x2, y2, sy, px1));			// Scanline as a line from (x1,y1)<->(x2,y2)
	dx2 = (dx1-dx0);												// Difference between dx1 and dx0
	dy2 = (dy1-dy0);												// Differnece between dy1 and dy0
	if (dy2 != 0){													// y(t) = a*t*t + b*t + c
		// Calculate apex
		tmf = -(double)dy0/(double)dy2;								// 't' at apex point
		ymf = (double)y1 + FLT_EPSILON + tmf*(double)dy0;		// y at apex point
		tdf = ((double)sy - ymf)/(double)dy2;						// ''t' value at scanline
		if (tdf < 0.0) {									// If t value is invalid
			return (0);												// No intersect
		} else if (tdf != 0.0) tdf = sqrt(tdf);				// Take sqrt of t value
		rslt = 0;													// Preset intersect return count to zero
		px = px1;													// Preset intersect x ptr to px1
		tf = tmf - tdf;												// Calculate first test t value
		if ((tf >= 0.0) && (tf <= 1.0)){				// Valid 't'  0.0 <= t <= 1.0
			xf = (long)(((double)dx2*tf + (double)(dx0*2))*tf) + x1;// Calculate x point of intersec
			(*px) = xf;												// Transfer that result to *px
			rslt++;													// Increment intersect count
			px = px2;												// Advance point to px2
		};
		tf = tmf + tdf;												// Calculate second test t value
		if ((tf >= 0.0) && (tf <= 1.0)){				// Valid 't'  0.0 <= t <= 1.0
			xf = (long)(((double)dx2*tf + (double)(dx0*2))*tf) + x1;// Calculate x point of intersect
			(*px) = xf;												// Transfer that result to *px
			rslt++;													// Increment intersect count
			px = px2;												// Advance ptr to px2
		};		
		return (rslt);												// We can have one or two points returned
	} else if (dy0 != 0) {											// y(t) = b*t + c
		tf = ((double)(sy - y1) - FLT_EPSILON)/(double)(dy0*2);	// Calculate t of intersect
		if  ((tf >= 0.0) && (tf <= 1.0)){			// Valid 't'  0.0 <= t <= 1.0
			xf = (long)(((double)dx2*tf + (double)(dx0*2))*tf) + x1;// Calculate x point of intersect		
			(*px1) = xf;											// Transfer that result to px1
			return (1);												// Return 1 as intersect count
		} else return (0);											// Intersect is outside line segment
	} else return (0);												// Drop horizontal line even if coincides with sy
}