Mathematical Problems in Engineering

Research Article

Approximate Bisimulation and Optimization of Software Programs Based on Symbolic-Numeric Computation

Algorithm 1

Multithreading program.
#include “main.h”
WINMULTITHREAD Branch2Thread5(LPVOID pParam)
{PThreadArg tharg = (PThreadArg)pParam;
  double y1 = tharg->il, y2 = tharg->i2;
  double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;
  do {
  do {
  if (((y1*y1 - (0.01*y2 + 1)*z1) > -APPZERO &&
  (y1*y1 - (0.01*y2 + 1)*z1) < APPZERO) &&
  ((2*y1*y2 - z2 - 0.01) > -APPZERO &&
  (2*y1*y2 - z2 - 0.01) < APPZERO)) {
  printf(“one solution of HLPS9 is z1 = %f, z2 = %f∖n”, z1, z2);
  }
  z2 += GRANULARITY;
  }while (z2 <= MAXIMUMVALUE);
  z1 += GRANULARITY;
  z2 = MINIMUMVALUE;
  } while (z1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch2Thread4(LPVOID pParam)
{PThreadArg tharg = (PThreadArg)pParam;
  double y1 = tharg->i1, y2 = tharg->i2;
  double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;
  do {
  do {
  if (((y1*y1 - z1) > -APPZERO &&
  (y1*y1 - z1) < APPZERO) &&
  ((2*y1*y2 - z2) > -APPZERO &&
  (2*y1*y2 - z2) < APPZERO)) {
  printf(“one solution of NLPS8 is z1 = %f, z2 = %f∖n”, z1, z2);
  }
  z2 += GRANULARITY;
  }while (z2 <= MAXIMUMVALUE);
  z1 += GRANULARITY;
  z2 = MINIMUMVALUE;
  } while (z1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch1Thread3(LPVOID pParam)
{PThreadArg tharg = (PThreadArg)pParam;
  double y1 = tharg->i1, y2 = tharg->i2;
  double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;
  do {
  do {
  if (((-(y1*y2 + 1)*(y1*y2 + 1) + 3*z1) > -APPZERO &&
  (-(y1*y2 + 1)*(y1*y2 + 1) + 3*z1) < APPZERO) &&
  ((-z1 + z2*(y1*y2 + 1)) > -APPZERO &&
  (-z1 + z2*(y1*y2 + 1)) < APPZERO)) {
  printf(“one solution of NLPS6 is z1 = %f, z2 = %f∖n”, z1, z2);
  }
  z2 += GRANULARITY;
  }while (z2 <= MAXIMUMVALUE);
  z1 += GRANULARITY;
  z2 = MINIMUMVALUE;
  } while (z1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch1Thread4(LPVOID pParam)
{PThreadArg tharg = (PThreadArg)pParam;
  double y1 = tharg->i1, y2 = tharg->i2;
  double z1 = MINIMUMVALUE, z2 = MINIMUMVALUE;
  do {
  do {
  if (((-z1 + (y1*y2 + 1)*z2) > -APPZERO &&
  (-z1 + (y1*y2 + 1)*z2) < APPZERO) &&
  ((-(y1*y2 + 1)*(y1*y2 + 1) + 2*z1 + z2*(y1*y2 + 1)) >
  -APPZERO &&
  (-(y1*y2 + 1)*(y1*y2 + 1) + 2*z1 + z2*(y1*y2 + 1)) <
  APPZERO)) {
  printf(“one solution of NLPS7 is z1 = %f, z2 = %f∖n”, z1, z2);
  }
  z2 += GRANULARITY;
  }while (z2 <= MAXIMUMVALUE);
  z1 += GRANULARITY;
  z2 = MINIMUMVALUE;
  } while (z1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch1Thread2(LPVOID pParam)
{HANDLE hThread13 = NULL;
  PThreadArg tharg = (PThreadArg)pParam;
  ThreadArg tharg12 = {0};
  double x1 = tharg->i1, x2 = tharg->i2;
  double y1 = MINIMUMVALUE, y2 = MINIMUMVALUE;
  do {
  do {
  if (((3*x1 - y1*y1 + y2*y1) > -APPZERO &&
  (3*x1 - y1*y1 + y2*y1) < APPZERO) &&
  ((x2 - y2*y1) > -APPZERO &&
  (x2 - y2*y1) < APPZERO)) {
  printf(“one solution of NLPS3 is y1 = %f, y2 = %f∖n”, y1, y2);
  tharg12.i1 = y1;
  tharg12.i2 = y2;
  hThread13 = CreateThread(NULL, 0, Branch1Thread3,
                (LPVOID)&tharg12, 0, NULL);
  WaitForSingleObject(hThread13, INFINITE);
  CloseHandle(hThread13);
  }
  y2 += GRANULARITY;
  }while (y2 <= MAXIMUMVALUE);
  y1 += GRANULARITY;
  y2 = MINIMUMVALUE;
  } while (y1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch2Thread3(LPVOID pParam)
{HANDLE hThread25 = NULL;
  PThreadArg tharg = (PThreadArg)pParam;
  ThreadArg tharg23 = {0};
  double x1 = tharg->i1, x2 = tharg->i2;
  double y1 = MINIMUMVALUE, y2 = MINIMUMVALUE;
  do {
  do {
  if (((3*x1 - y1*y1 + x2) > -APPZERO &&
  (3*x1 - y1*y1 + x2) < APPZERO) &&
  ((x2 - y2*y1) > -APPZERO &&
  (x2 - y2*y1) < APPZERO)) {
  printf(“one solution of NLPS5 is y1 = %f, y2 = %f∖n”, y1, y2);
  tharg23.i1 = y1;
  tharg23.i2 = y2;
  hThread25 = CreateThread(NULL, 0, Branch2Thread5,
                 (LPVOID)&tharg23, 0, NULL);
  WaitForSingleObject(hThread25, INFINITE);
  CloseHandle(hThread25);
  }
  y2 += GRANULARITY;
  }while (y2 <= MAXIMUMVALUE);
  y1 += GRANULARITY;
  y2 = MINIMUMVALUE;
  } while (y1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch2Thread2(LPVOID pParam)
{HANDLE hThread24 = NULL;
  PThreadArg tharg = (PThreadArg)pParam;
  ThreadArg tharg22 = {0};
  double x1 = tharg->i1, x2 = tharg->i2;
  double y1 = MINIMUMVALUE, y2 = MINIMUMVALUE;
  do {
  do {
  if (((3*x1 - 0.99*y1*y1 + y2*y1 - 0.01*y2*x1) >
  -APPZERO &&
  (3*x1 - 0.99*y1*y1 + y2*y1 - 0.01*y2*x1) <
  APPZERO) &&
  ((x2 - y2*y1 + 0.01*y2*x1) > -APPZERO &&
  (x2 - y2*y1 + 0.01*y2*x1) < APPZERO)) {
  printf(“one solution of NLPS4 is y1 = %f, y2 = %f∖n”, y1, y2);
  tharg22.i1 = x1;
  tharg22.i2 = x2;
  hThread24 = CreateThread(NULL, 0, Branch2Thread4,
                 (LPVOID)&tharg22, 0, NULL);
  WaitForSingleObject(hThread24, INFINITE);
  CloseHandle(hThread24);
  }
  y2 += GRANULARITY;
  }while (y2 <= MAXIMUMVALUE);
  y1 += GRANULARITY;
  y2 = MINIMUMVALUE;
  } while (y1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch2Thread1(LPVOID pParam)
{HANDLE hThread22 = NULL, hThread23 = NULL;
  PThreadArg tharg = (PThreadArg)pParam;
  ThreadArg tharg21 = {0};
  double m1 = tharg->i1, m2 = tharg->i2;
  double x1 = MINIMUMVALUE, x2 = MINIMUMVALUE;
  do {
  do {
  if (((m2*m2 - x1) > -APPZERO &&
  (m2*m2 - x1) < APPZERO) &&
  ((2*m1*m2 + x2) > -APPZERO &&
  (2*m1*m2 + x2) < APPZERO)) {
  printf(“one solution of NLPS2 is x1 = %f, x2 = %f∖n”, x1, x2);
  tharg21.i1 = x1;
  tharg21.i2 = x2;
  hThread22 = CreateThread(NULL, 0, Branch2Thread2,
                 (LPVOID)&tharg21, 0, NULL);
  hThread23 = CreateThread(NULL, 0, Branch2Thread3,
                (LPVOID)&tharg21, 0, NULL);
  WaitForSingleObject(hThread22, INFINITE);
  WaitForSingleObject(hThread23, INFINITE);
  CloseHandle(hThread22);
  CloseHandle(hThread23);
  }
  x2 += GRANULARITY;
  }while (x2 <= MAXIMUMVALUE);
x1 += GRANULARITY;
  x2 = MINIMUMVALUE;
  } while (x1 <= MAXIMUMVALUE);
return 0;
}
WINMULTITHREAD Branch1Thread1(LPVOID pParam)
{HANDLE hThread12 = NULL;
  PThreadArg tharg = (PThreadArg)pParam;
  ThreadArg tharg11 = {0};
  double m1 = tharg->i1, m2 = tharg->i2;
  double x1 = MINIMUMVALUE, x2 = MINIMUMVALUE;
  do {
  do {
  if (((2*m1*m2 + m2*m2 - x1 + x2) > -APPZERO &&
  (2*m1*m2 + m2*m2 - x1 + x2) < APPZERO) &&
  ((2*m1*m2 - m2*m2 + x1 + x2) > -APPZERO &&
  (2*m1*m2 - m2*m2 + x1 + x2) < APPZERO)) {
  printf(“one solution of NLPS1 is x1 = %f, x2 = %f∖n”, x1, x2);
  tharg11.i1 = x1;
  tharg11.i2 = x2;
  hThread12 = CreateThread(NULL, 0, Branch1Thread2,
                (LPVOID)&tharg11, 0, NULL);
  WaitForSingleObject(hThread12, INFINITE);
  CloseHandle(hThread12);
  }
  x2 += GRANULARITY;
  }while (x2 <= MAXIMUMVALUE);
  x1 += GRANULARITY;
  x2 = MINIMUMVALUE;
  } while (x1 <= MAXIMUMVALUE);
return 0;
}
int main()
{HANDLE hThread1 = NULL, hThread2 = NULL;
  LARGE_INTEGER litc, litStart, litEnd;
  ThreadArg iTharg = {0};
  printf(“Please enter the value of input m1 = ”);
  scanf(“%lf”, &iTharg.i1);
  printf(“Please enter the value of input m2 = ”);
  scanf(“%lf”, &iTharg.i2);
  QueryPerformanceFrequency(&litc);
  QueryPerformanceCounter(&litStart);
  hThread1 = CreateThread(NULL, 0, Branch1Thread1,
            (LPVOID)&iTharg, 0, NULL);
  hThread2 = CreateThread(NULL, 0, Branch2Thread1,
             (LPVOID)&iTharg, 0, NULL);
  WaitForSingleObject(hThread1, INFINITE);
  WaitForSingleObject(hThread2, INFINITE);
  QueryPerformanceCounter(&litEnd);
  printf(“Execution time is %fs∖n”, (double)
      (litEnd.QuadPart - litStart.QuadPart)/litc.QuadPart);
  return 0;
}