C / C++ / MFC

Andraw111 wrote:

I don't where should I put my Fortran question, so I put it here.

Maybe a std::shared_ptr can be helpful for you.

You can use it as follows:

#include <memory>

using namespace std;

class Person
{
    shared_ptr<Person> parent;
 
public:
    Person(shared_ptr<Person> p) {parent = p;}
 
};

void DoSomething(shared_ptr<Person> p)
{
    // Do something here
}

int main()
{
    shared_ptr<Person> grandfather = make_shared<Person>(nullptr);
    shared_ptr<Person> father = make_shared<Person>(grandfather);
    shared_ptr<Person> son = make_shared<Person>(father);

    DoSomething(father);

    return 0;
}

class Person
{
	shared_ptr<Person> parent;

public:
	Person(shared_ptr<Person> p){ parent = p; }

};

int main()
{
	auto grandfather(make_shared<Person>(nullptr));
	auto father(make_shared<Person>(grandfather));
	auto son(make_shared<Person>(father));

	// Do something here

	return 0;
}

void function1(Person p)
{
	// p is a copy
}

void function2(Person& p)
{
    // p is a reference to the object passed 
    // in as a parameter, not a copy
}

Quote:

double sqrt (double f)
{
double x, z, tempf;
unsigned long *tfptr = ((unsigned long *)&tempf) + 1;
tempf = f;
*tfptr = (0xbfcdd90a - *tfptr)>>1;
x = tempf;
z = f*0.5;
x = (1.5*x) - (x*x)*(x*z); //The more you make replicates of this statement
//the higher the accuracy, here only 2 replicates are used
x = (1.5*x) - (x*x)*(x*z);
return x*f;
}

void initial_guess(double r, int *pa, int *pn)
{
  *pn = 0;

  while ( r < 1.0)
  {
    r *= 100.0;
    --(*pn);
  }
  while ( r >= 100.0 )
  {
    r /= 100.0;
    ++(*pn);
  }

  *pa = (r < 10.0) ? 2 : 6;
}

double square_root(double r)
{
  int a, i, n;
  initial_guess(r, &a, &n);
  double x=1.0;

  while (n < 0)
  {
    x/=10.0;
    ++n;
  }
  while(n > 0)
  {
    x *= 10.0;
    --n;
  }

  x *= a;

  for (i = 0; i<10; ++i) // 10 is the arbitrary number of iterations I chose
  {
    x = 0.5 * (x + r/x);
  }

  return x;
}

for(i=0;i<5;i++)
              {  //float y,sum;
		float f= ((float)rand()/(float)(RAND_MAX))*a;
		y=square(f);
        	sum +=y;
	      }		
		printf("\n summation of squared number is:=%f\t",sum);

Quote:

Generated random number || Squaring of random number:
=========================================================
0.035679 ----- 0.001273
0.079935 ----- 0.006390
0.033320 ----- 0.001110
0.042424 ----- 0.001800
0.012387 ----- 0.000153

summation of squared number is:=0.010346

int main()
{
  int i;
  double sum = 0.0;
  double a[] =
  {
    0.035679,
    0.079935,
    0.03332,
    0.042424,
    0.012387
  };


  for (i=0; i<sizeof(a)/sizeof(a[0]); ++i)
  {
    double sq = square_root(a[i]);
    printf("a[%d] = %g, sqrt(a[%d])=%g\n", i, a[i], i, sq);
    sum += sq;
  }
  printf("sum of square roots = %g\n", sum);
}

a[0] = 0.035679, sqrt(a[0])=0.188889
a[1] = 0.079935, sqrt(a[1])=0.282728
a[2] = 0.03332, sqrt(a[2])=0.182538
a[3] = 0.042424, sqrt(a[3])=0.205971
a[4] = 0.012387, sqrt(a[4])=0.111297
sum of square roots = 0.971422

#include <stdio.h>
int main()
{
  double a [] =
  {
    0.035679,
    0.079935,
    0.033320,
    0.042424,
    0.012387
  };
  double sum, square;
  int n;

  sum = 0.0;
  for (n=0; n<sizeof(a)/sizeof(a[0]); ++n)
  {
    square = a[n]*a[n];
    sum += square;
    printf("%g ----> %g\n", a[n], square);
  }

  printf("sum of squares: %g\n", sum);

  return 0;
}

0.035679 ----> 0.00127299
0.079935 ----> 0.0063896
0.03332 ----> 0.00111022
0.042424 ----> 0.0017998
0.012387 ----> 0.000153438
sum of squares: 0.0107261