C / C++ / MFC

srand(12345);
    float z=0.0;
    float a=0.2,y=0.0;
    int i;
    for(i=0;i<5;i++)
    {
        float b=((float)rand()/(float)(RAND_MAX))*a;
        printf("%f\n",b);

        z=z+b;
    }
    printf("summation:\n%f\n",z);

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;
}