# include <cstdlib>
# include <iostream>
# include <iomanip>
# include <ctime>

# include "mpi.h"

int main ( int argc, char *argv[] );
int search ( int a, int b, int c, int id, int p );
int f ( int i );

# include "mpi.h"

//****************************************************************************80

int main ( int argc, char *argv[] )

//****************************************************************************80
//
//  Purpose:
//
//    MAIN is the main program for SEARCH_MPI.
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license.
//
//  Modified:
//
//    03 November 2012
//
//  Author:
//
//    John Burkardt
//
{
  int a;
  int b;
  int c;
  int fj;
  int i4_huge = 2147483647;
  int id;
  int j;
  int p;
  double wtime;
//
//  Initialize MPI.
//
  MPI::Init ( argc, argv );
//
//  Get this processor's ID.
//
  id = MPI::COMM_WORLD.Get_rank ( );
//
//  Get the number of processors.
//
  p = MPI::COMM_WORLD.Get_size ( );

  a = 1;
  b = i4_huge;
  c = 45;

  if ( id == 0 )
  {
    printf ( "\n" );
    printf ( "SEARCH_MPI:\n" );
    printf ( "  C++/MPI version\n" );
    printf ( "  Search the integers from A to B\n" );
    printf ( "  for a value J such that F(J) = C.\n" );
    printf ( "\n" );
    printf ( "  A           = %d\n", a );
    printf ( "  B           = %d\n", b );
    printf ( "  C           = %d\n", c );
  }

  wtime = MPI::Wtime ( );

  j = search ( a, b, c, id, p );

  wtime = MPI::Wtime ( ) - wtime;

  if ( j != -1 )
  {
    printf ( "\n" );
    printf ( "  Process %d found     J = %d\n", id, j );
    printf ( "  Verify F(J) = %d\n", f ( j ) );
  }

  if ( id == 0 )
  {
    printf ( "  Elapsed wallclock time is %g\n", wtime );
  }
//
//  Terminate MPI.
//
  MPI::Finalize ( );
//
//  Terminate.
//
  if ( id == 0 )
  {
    printf ( "\n" );
    printf ( "SEARCH_MPI:\n" );
    printf ( "  Normal end of execution.\n" );
  }

  return 0;
}
//****************************************************************************80

int search ( int a, int b, int c, int id, int p )

//****************************************************************************80
//
//  Purpose:
//
//    SEARCH searches integers in [A,B] for a J so that F(J) = C.
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license.
//
//  Modified:
//
//    02 November 2012
//
//  Author:
//
//    John Burkardt
//
//  Parameters:
//
//    Input, int A, B, the search range.
//
//    Input, int C, the desired function value.
//
//    Input, int ID, the process ID.
//
//    Input, int P, the number of processes.
//
//    Output, int SEARCH, the computed solution, or -1
//    if no solution was found.
//
{
  int fi;
  int i;
  int j;

  j = -1;
//
//  i = i + p can take us "over top" so that i becomes negative!
//  So we have to be more careful here!
//
  for ( i = a + id; 0 < i && i <= b; i = i + p )
  {
    fi = f ( i );

    if ( fi == c )
    {
      j = i;
      break;
    }
  }

  return j;
}
//****************************************************************************80

int f ( int i )

//*****************************************************************************80
//
//  Purpose:
//
//    F is the function we are analyzing.
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license.
//
//  Modified:
//
//    22 October 2012
//
//  Author:
//
//    John Burkardt
//
//  Parameters:
//
//    Input, int I, the argument.
//
//    Input, int F, the value.
//
{
  int i4_huge = 2147483647;
  int j;
  int k;
  int value;

  value = i;

  for ( j = 1; j <= 5; j++ )
  {
    k = value / 127773;

    value = 16807 * ( value - k * 127773 ) - k * 2836;

    if ( value <= 0 )
    {
      value = value + i4_huge;
    }
  }

  return value;
}