/***************************************************************************
Copyright 1998 MBARI                                                    
****************************************************************************
Summary  : Buffer class member functions		                           
Filename : Buffer.C                                                    
Author   : Michael B. Matthews                                          
Project  : iView                                                 
Version  : 1.0                                                  
Created  : 17.3.98                                             
Modified : 25.3.98                                                             
Archived :                                                              
****************************************************************************/

#define __PROTOTYPE_5_0			// logMsg variable arg list

#include <vxWorks.h>            	      
#include <sysLib.h>   	         	      
#include <stdioLib.h>           	     
#include <stdlib.h>  	         	      
#include <math.h>              		
#include <semLib.h>            		         
#include <logLib.h>            		         
#include <wdLib.h>             		    
#include <systime.h>           		   
#include <strLib.h>			             
#include <stdlib.h>			
#include <fppLib.h>             	   
#include <errno.h>        	
#include <tickLib.h>        	
#include <intLib.h>        	

extern "C" 
{
#include <trig.h>       		// MBARI trig declarations            
#include <mbariTypes.h>       		// MBARI type declarations            
#include <mbariConst.h>       		// MBARI type declarations            
#include <sensorDcon.h>			// MBARI sensor data concentrator 
#include <vmeIbc.h>			// MBARI VME IBC definitions           
#include <sensorsDm.h>			//                                    
#include <datamgr.h>           		// MBARI data manager declarations     
#include <dm_errno.h>          		// MBARI data manager error     
#include "usrTime.h"
#include "tiburon.h"			
#include "rovPriority.h"	
};

#include "Misc.h"		// misc functions
#include "Buffer.h"



/*****************************************************************************
Function : IO_Buffer::IO_Buffer                                           
Purpose  : Allocates buffer memory and initializes index	              
Inputs   : n - size of buffer                                              
Outputs  : None		                                                      
*****************************************************************************/

IO_Buffer::IO_Buffer(Int n, Flt32 a)
{
  index = -1;
  size = n;
  u = new Flt32[n];
  Fill(a);
}



/*****************************************************************************
Function : IO_Buffer::Fill                                                 
Purpose  : Fill buffer with same value                                     
Inputs   :                		                                      
Outputs  : 		                                                      
*****************************************************************************/

Void IO_Buffer::Fill(Flt32 value)
{
  Int i;
  for (i = 0; i < size; i++)
    u[i] = value;
}
 


/*****************************************************************************
Function : IO_Buffer::Update                                               
Purpose  : Adds new element to buffer and increments index	              
Inputs   : x - new input value                                             
Outputs  : 		                                                      
*****************************************************************************/

Void IO_Buffer::Update(Flt32 x)
{
  index++;
  index = (index + size) % size;
  u[index] = x; 
}



/*****************************************************************************
Function : IO_Buffer::Max_Difference                                       
Purpose  : Finds the maximum difference of values in array g               
Inputs   :                		                                      
Outputs  : 		                                                      
*****************************************************************************/

Flt32 IO_Buffer::Max_Difference()
{
  Flt32 max, min;
  Int i;

  max = u[0]; min = u[0];
  for (i = 0; i < size; i++){
    if (u[i] < min) min = u[i];
    if (u[i] > max) max = u[i];
  }
  return(max - min);
}



/*****************************************************************************
Function : IO_Buffer_Max                                                   
Purpose  : Finds the maximum in buffer                                     
Inputs   :                		                                      
Outputs  : 		                                                      
*****************************************************************************/

Flt32 IO_Buffer::Max()
{
  Reg Flt32 max;
  Reg Int i;

  max = u[0];
  for (i = 0; i < size; i++){
    if (u[i] > max) max = u[i];
  }
  return(max);
}



/*****************************************************************************
Function : IO_Buffer::Min                                                  
Purpose  : Finds the minimum in buffer                                     
Inputs   :                		                                      
Outputs  : 		                                                      
*****************************************************************************/

Flt32 IO_Buffer::Min()
{
  Reg Flt32 min;
  Reg Int i;

  min = u[0];
  for (i = 0; i < size; i++){
    if (u[i] < min) min = u[i];
  }
  return(min);
}



/*****************************************************************************
Function : IO_Buffer::Average                                              
Purpose  : Finds the minimum in buffer                                     
Inputs   :                		                                      
Outputs  : 		                                                      
*****************************************************************************/

Flt32 IO_Buffer::Average(Int n)
{
  Reg Flt32 a = 0;
  Reg Int i;

  for (i = 0; i < n; i++)
    a += u[i];

  a = a/size;

  return a;
}