Ejemplo n.º 1
0
        template <bool align, bool first> SIMD_INLINE void BgrToYuv422p(const uint8_t * bgr, Storer<align> & y, Storer<align> & u, Storer<align> & v)
        {
            v128_u8 blue[2], green[2], red[2];
            LoadBgr<align>(bgr, blue[0], green[0], red[0]);
            Store<align, first>(y, BgrToY(blue[0], green[0], red[0]));
            LoadBgr<align>(bgr + 3 * A, blue[1], green[1], red[1]);
            Store<align, false>(y, BgrToY(blue[1], green[1], red[1]));

            v128_s16 blueAvg[2], greenAvg[2], redAvg[2];
            blueAvg[0] = Average(blue[0]);
            blueAvg[1] = Average(blue[1]);
            greenAvg[0] = Average(green[0]);
            greenAvg[1] = Average(green[1]);
            redAvg[0] = Average(red[0]);
            redAvg[1] = Average(red[1]);
            Store<align, first>(u, vec_pack(BgrToU(blueAvg[0], greenAvg[0], redAvg[0]), BgrToU(blueAvg[1], greenAvg[1], redAvg[1])));
            Store<align, first>(v, vec_pack(BgrToV(blueAvg[0], greenAvg[0], redAvg[0]), BgrToV(blueAvg[1], greenAvg[1], redAvg[1])));
        }
Ejemplo n.º 2
0
        template <bool align, bool first> SIMD_INLINE void BgrToYuv420p(const uint8_t * bgr0, size_t bgrStride,
            Storer<align> & y0, Storer<align> & y1, Storer<align> & u, Storer<align> & v)
        {
            const uint8_t * bgr1 = bgr0 + bgrStride;
            v128_u8 blue[2][2], green[2][2], red[2][2];
            LoadBgr<align>(bgr0, blue[0][0], green[0][0], red[0][0]);
            Store<align, first>(y0, BgrToY(blue[0][0], green[0][0], red[0][0]));
            LoadBgr<align>(bgr0 + 3 * A, blue[0][1], green[0][1], red[0][1]);
            Store<align, false>(y0, BgrToY(blue[0][1], green[0][1], red[0][1]));
            LoadBgr<align>(bgr1, blue[1][0], green[1][0], red[1][0]);
            Store<align, first>(y1, BgrToY(blue[1][0], green[1][0], red[1][0]));
            LoadBgr<align>(bgr1 + 3 * A, blue[1][1], green[1][1], red[1][1]);
            Store<align, false>(y1, BgrToY(blue[1][1], green[1][1], red[1][1]));

            v128_s16 blueAvg[2], greenAvg[2], redAvg[2];
            blueAvg[0] = Average(blue[0][0], blue[1][0]);
            blueAvg[1] = Average(blue[0][1], blue[1][1]);
            greenAvg[0] = Average(green[0][0], green[1][0]);
            greenAvg[1] = Average(green[0][1], green[1][1]);
            redAvg[0] = Average(red[0][0], red[1][0]);
            redAvg[1] = Average(red[0][1], red[1][1]);
            Store<align, first>(u, vec_pack(BgrToU(blueAvg[0], greenAvg[0], redAvg[0]), BgrToU(blueAvg[1], greenAvg[1], redAvg[1])));
            Store<align, first>(v, vec_pack(BgrToV(blueAvg[0], greenAvg[0], redAvg[0]), BgrToV(blueAvg[1], greenAvg[1], redAvg[1])));
        }
Ejemplo n.º 3
0
 SQuaternion Average( const CSymmetryType & oSym, const vector< SQuaternion > &vQuatList )
 {
   return  Average( oSym, vQuatList.begin(), vQuatList.end(),
                    Utilities::QuaternionToQuaternion() );
 }
Ejemplo n.º 4
0
 SQuaternion Average( const CSymmetryType & oSym, const vector< SVector3 > &vAngleList )
 {
   return Average( oSym, vAngleList.begin(), vAngleList.end(),
                   Utilities::AngleToQuaternion() );
 }
Ejemplo n.º 5
0
static int DecodeACComponent(WinZipJPEGDecompressor *self,int comp,unsigned int k,bool canbezero,
const WinZipJPEGBlock *current,const WinZipJPEGBlock *north,const WinZipJPEGBlock *west,
const WinZipJPEGQuantizationTable *quantization)
{
	if(!north) north=&ZeroBlock;
	if(!west) west=&ZeroBlock;

	int val1;
	if(IsFirstRowOrColumn(k)) val1=Abs(BDR(k,current,north,west,quantization));
	else val1=Average(k,north,west,quantization);

	int val2=Sum(k,current);

	if(canbezero)
	{
		// Decode zero/non-zero bit. (5.6.6.1)
		int zerocontext1=Min(Category(val1),2);
		int zerocontext2=Min(Category(val2),5);

		int nonzero=NextBitFromWinZipJPEGArithmeticDecoder(&self->decoder,
		&self->zerobins[comp][k-1][zerocontext1][zerocontext2]);

		// If this component is zero, there is no need to decode further parameters.
		if(!nonzero) return 0;
	}

	// This component is not zero. Proceed with decoding absolute value.
	int absvalue;

	// Decode pivot (abs>=2). (5.6.6.2)
	int pivotcontext1=Min(Category(val1),4);
	int pivotcontext2=Min(Category(val2),6);

	int pivot=NextBitFromWinZipJPEGArithmeticDecoder(&self->decoder,
	&self->pivotbins[comp][k-1][pivotcontext1][pivotcontext2]);

	if(!pivot)
	{
		// The absolute of this component is not >=2. It must therefore be 1,
		// and there is no need to decode the value.
		absvalue=1;
	}
	else
	{
		// The absolute of this component is >=2. Proceed with decoding
		// the absolute value. (5.6.6.3)
		int val3,n;
		if(IsFirstRow(k)) { val3=Column(k)-1; n=0; }
		else if(IsFirstColumn(k)) { val3=Row(k)-1; n=1; }
		else { val3=Category(k-4); n=2; }

		int magnitudecontext1=Min(Category(val1),8);
		int magnitudecontext2=Min(Category(val2),8);
		int remaindercontext=val3;

		// Decode absolute value.
		absvalue=DecodeBinarization(&self->decoder,
		self->acmagnitudebins[comp][n][magnitudecontext1][magnitudecontext2],
		self->acremainderbins[comp][n][remaindercontext],
		14,9)+2;
	}

	if(DecodeACSign(self,comp,k,absvalue,current,north,west,quantization)) return -absvalue;
	else return absvalue;
}
Ejemplo n.º 6
0
int main(int argc, char ** argv)
{
	if(argc < 3){
		std::cout << "Wrong number of arguments. Usage: F1Score <partitionA> <partitionB>" << std::endl;
		exit(0);
	}

	std::ifstream inputFileA;
	inputFileA.open(argv[1]);
	if(!inputFileA.is_open()) {
		std::cout << "PARTITION FILE A NOT FOUND" << std::endl;
		exit(1);
	}
	std::ifstream inputFileB;
	inputFileB.open(argv[2]);
	if(!inputFileB.is_open()){
		std::cout << "PARTITION FILE B NOT FOUND" << std::endl;
		exit(1);
	}
	
    std::cout << "Parsing Input Files"<< std::endl;
	partitionA = ParseSets(inputFileA);
	inputFileA.close();
	
	partitionB = ParseSets(inputFileB);
    inputFileB.close();

	std::map<unsigned int, std::set<unsigned int> > nodePartitionA;
	std::map<unsigned int, std::set<unsigned int> > nodePartitionB;

	std::cout << "Partition A size: " << partitionA->size() << std::endl;
	std::cout << "Partition B size: " << partitionB->size() << std::endl;
	double maxSetsF1Scores = 0.0f;
	double maxTagsF1Scores = 0.0f;

	std::cout << "Creating Indexes of Partition A" << std::endl;
	for( unsigned int i = 0; i < partitionA->size(); i++){
		std::set<unsigned int>* community = (*partitionA)[i];
		for( auto it = community->begin(); it != community->end(); it++ ){
			unsigned int node = *it;
			auto it2 = nodePartitionA.find(node);
            nodePartitionA[node].insert(i);
		}
	}

	std::cout << "Creating Indexes of Partition B" << std::endl;
	for( unsigned int i = 0; i < partitionB->size(); i++){
		std::set<unsigned int>* community = (*partitionB)[i];
		for( auto it = community->begin(); it != community->end(); it++ ){
			unsigned int node = *it;
			auto it2 = nodePartitionB.find(node);
            nodePartitionB[node].insert(i);
		}
	}

    double* f1ScorePartitionA = new double[partitionA->size()];
    double* f1ScorePartitionB = new double[partitionB->size()];
	double* precisionPartitionA = new double[partitionA->size()];
	double* precisionPartitionB = new double[partitionB->size()];
	double* recallPartitionA = new double[partitionA->size()];
	double* recallPartitionB = new double[partitionB->size()];

    /** Initializing arrays to 0 **/
    std::memset(f1ScorePartitionA,0,sizeof(double)*partitionA->size());
    std::memset(precisionPartitionA,0,sizeof(double)*partitionA->size());
    std::memset(recallPartitionA,0,sizeof(double)*partitionA->size());
    std::memset(f1ScorePartitionB,0,sizeof(double)*partitionB->size());
    std::memset(precisionPartitionB,0,sizeof(double)*partitionB->size());
    std::memset(recallPartitionB,0,sizeof(double)*partitionB->size());

	std::cout << "Computing F1Score of partition A" << std::endl;
	for( unsigned int i = 0; i < partitionA->size(); i++){
		std::set<unsigned int>* community = (*partitionA)[i];
		std::set<unsigned int> communities;

        // Selecting candidate communities to compare with.
		for( auto it = community->begin(); it != community->end(); it++ ) {
			auto it2 = nodePartitionB.find(*it);
			if(it2 != nodePartitionB.end()) {
				for( auto it3 = (*it2).second.begin(); it3 != (*it2).second.end(); it3++ ) {
					communities.insert(*it3);
				}
			}
		}

		for( auto it = communities.begin(); it != communities.end(); it++){
			std::set<unsigned int>* community2 = (*partitionB)[*it];
			double precision;
			double recall;
			double f1Score = F1Score(*community,*community2, &precision, &recall );
            f1ScorePartitionA[i] = f1Score > f1ScorePartitionA[i] ? f1Score : f1ScorePartitionA[i];
            precisionPartitionA[i] = precision > precisionPartitionA[i] ? precision : precisionPartitionA[i];
            recallPartitionA[i] = recall > recallPartitionA[i] ? recall : recallPartitionA[i];
		}
	}

	std::cout << "Computing F1Score of partition B" << std::endl;
	for( unsigned int i = 0; i < partitionB->size(); i++){
		std::set<unsigned int>* community = (*partitionB)[i];
		std::set<unsigned int> communities;

        // Selecting candidate communities to compare with.
		for( auto it = community->begin(); it != community->end(); it++ ) {
			auto it2 = nodePartitionA.find(*it);
			if(it2 != nodePartitionA.end()) {
				for( auto it3 = (*it2).second.begin(); it3 != (*it2).second.end(); it3++ ) {
					communities.insert(*it3);
				}
			}
		}

		for( auto it = communities.begin(); it != communities.end(); it++){
			std::set<unsigned int>* community2 = (*partitionA)[*it];
			double precision;
			double recall;
			double f1Score = F1Score(*community,*community2, &precision, &recall );
            f1ScorePartitionB[i] = f1Score > f1ScorePartitionB[i] ? f1Score : f1ScorePartitionB[i];
            precisionPartitionB[i] = precision > precisionPartitionB[i] ? precision : precisionPartitionB[i];
            recallPartitionB[i] = recall > recallPartitionB[i] ? recall : recallPartitionB[i];
		}
	}
	
    std::cout << "Average precision partition A: " << Average(precisionPartitionA, partitionA->size() ) << std::endl;
    std::cout << "Average recall partition A: " << Average(recallPartitionA, partitionA->size() ) << std::endl;

    std::cout << "Average precision partition B: " << Average(precisionPartitionB, partitionB->size() ) << std::endl;
    std::cout << "Average recall partition B: " << Average(recallPartitionB, partitionB->size() ) << std::endl;

    std::cout << "F1Score: " << (Average( f1ScorePartitionA, partitionA->size() ) + Average( f1ScorePartitionB, partitionB->size() )) / 2 << std::endl; 

    delete [] f1ScorePartitionA;
    delete [] f1ScorePartitionB;
    delete [] precisionPartitionA;
    delete [] precisionPartitionB;
    delete [] recallPartitionA;
    delete [] recallPartitionB;
	return 0;
}
Ejemplo n.º 7
0
double Vector::Average(double returnIfNull) {
  if (Length() == 0) return returnIfNull;

  return Average();
}
Ejemplo n.º 8
0
//-----------------------------------------------------------------------------
void TestCommandHandle::Execute()
{
  if (!engine) {
    Output() << "Engine not set for 'test' command";
    return;
  }

  if (fileName.empty()) {
    Output() << "FileName not set for 'test' command";
    return;
  }

  char     fen[16384];
  int      depth = 0;
  int      line = 0;
  int      maxSearchDepth = 0;
  int      maxSeldepth = 0;
  int      minSearchDepth = -1;
  int      minSeldepth = -1;
  int      passed = 0;
  int      positions = 0;
  int      seldepth = 0;
  int      tested = 0;
  int      totalDepth = 0;
  int      totalSeldepth = 0;
  uint64_t nodes = 0;
  uint64_t qnodes = 0;
  uint64_t time = 0;
  uint64_t totalNodes = 0;
  uint64_t totalQnodes = 0;
  uint64_t totalTime = 0;
  FILE*    fp = NULL;

  try {
    MoveFinder moveFinder;

    if (!(fp = fopen(fileName.c_str(), "r"))) {
      Output() << "Cannot open '" << fileName << "': " << strerror(errno);
      return;
    }

    engine->ClearStopFlags();
    engine->ResetStatsTotals();

    while (fgets(fen, sizeof(fen), fp)) {
      line++;

      char* f = fen;
      if (!*NextWord(f) || (*f == '#')) {
        continue;
      }

      positions++;
      if (skipCount && (positions <= skipCount)) {
        continue;
      }

      Output() << "--- Test " << (++tested) << " at line " << line << ' ' << f;
      NormalizeString(f);
      const char* next = engine->SetPosition(f);
      if (!next || !moveFinder.LoadFEN(f)) {
        break;
      }
      f += (next - f);

      // consume 'am' and 'bm' parameters
      std::set<std::string> avoid;
      std::set<std::string> best;
      while (f && *NextWord(f)) {
        // null terminate this parameter (parameters end with ; or end of line)
        char* end = strchr(f, ';');
        if (end) {
          *end = 0;
        }

        if (!strncmp(f, "am ", 3)) {
          f += 3;
          while (*NextWord(f)) {
            std::string coord = moveFinder.ToCoordinates(f);
            if (coord.size()) {
              avoid.insert(coord);
            }
            else {
              break;
            }
          }
        }
        else if (!strncmp(f, "bm ", 3)) {
          f += 3;
          while (*NextWord(f)) {
            std::string coord = moveFinder.ToCoordinates(f);
            if (coord.size()) {
              best.insert(coord);
            }
            else {
              break;
            }
          }
        }

        // move 'f' to beginning of next parameter
        if (end) {
          f = (end + 1);
          continue;
        }
        break;
      }

      if (avoid.empty() && best.empty()) {
        Output() << "error at line " << line
                 << ", no best or avoid moves specified";
        break;
      }

      if (!noClear) {
        engine->ClearSearchData();
      }
      if (printBoard) {
        engine->PrintBoard();
      }

      const std::string bestmove = engine->Go(maxDepth, 0, maxTime);
      Output(Output::NoPrefix) << "bestmove " << bestmove;

      engine->GetStats(&depth, &seldepth, &nodes, &qnodes, &time);
      if (bestmove.empty() ||
          (best.size() && !best.count(bestmove)) ||
          (avoid.size() && avoid.count(bestmove)))
      {
        Output() << "--- FAILED! line " << line << " ("
                 << Percent(passed, tested) << "%) " << f;
      }
      else {
        passed++;
        Output() << "--- Passed. line " << line << " ("
                 << Percent(passed, tested) << "%) " << f;
      }

      if (depth > maxSearchDepth) {
        maxSearchDepth = depth;
      }
      if ((minSearchDepth < 0) || (depth < minSearchDepth)) {
        minSearchDepth = depth;
      }
      if (seldepth > maxSeldepth) {
        maxSeldepth = seldepth;
      }
      if ((minSeldepth < 0) || (seldepth < minSeldepth)) {
        minSeldepth = seldepth;
      }
      totalDepth += depth;
      totalNodes += nodes;
      totalQnodes += qnodes;
      totalSeldepth += seldepth;
      totalTime += time;

      if (engine->StopRequested() || (maxCount && (tested >= maxCount))) {
        break;
      }
    }

    Output() << "--- Completed " << tested << " test positions";
    Output() << "--- Passed    " << passed << " passed ("
             << Percent(passed, tested) << "%)";
    Output() << "--- Time      " << totalTime << " ("
             << Average(totalTime, static_cast<uint64_t>(tested)) << " avg)";
    Output() << "--- Nodes     " << totalNodes << ", "
             << Rate((totalNodes / 1000), totalTime) << " KNodes/sec";
    Output() << "--- QNodes    " << totalQnodes << " ("
             << Percent(totalQnodes, totalNodes) << "%)";
    Output() << "--- Depth     " << minSearchDepth << " min, "
             << static_cast<int>(Average(totalDepth, tested)) << " avg, "
             << maxSearchDepth << " max";
    Output() << "--- SelDepth  " << minSeldepth << " min, "
             << static_cast<int>(Average(totalSeldepth, tested)) << " avg, "
             << maxSeldepth << " max";

    engine->ShowStatsTotals();
  }
  catch (const std::exception& e) {
    Output() << "ERROR: " << e.what();
  }
  catch (...) {
    Output() << "Unknown error!";
  }

  if (fp) {
    fclose(fp);
    fp = NULL;
  }
}
Ejemplo n.º 9
0
bool AverageRMSD(IT iFirst, IT iLast, VAL &vAve, VAL &vRMSD)
{
  return Average(iFirst, iLast, vAve) &&
         RMSD(iFirst, iLast, vAve, vRMSD);
}
Ejemplo n.º 10
0
 /**
  * Computes and returns the skew. If there are no valid pixels then NULL8 is
  * returned. Recognize that because of the binning which occurs, in order to
  * generate the histogram, the skew may not be precise but will be very close.
  *
  * @return The skew.
  */
 double Histogram::Skew() const {
   if (ValidPixels() < 1) return Isis::NULL8;
   double sdev = StandardDeviation();
   if (sdev == 0.0) return 0.0;
   return 3.0 * (Average() - Median()) / sdev;
 }
Ejemplo n.º 11
0
void
rules_test (tcb * thisdir, segment * pseg, seglen len, quadrant * pquad,
            u_short this_ip_id, Bool pkt_already_seen, double recovery_time)
{
  double DeltaT2, RTO, Mean_RTT, RTT_min;
  char type_of_segment =
    real_rules_test (thisdir, pseg, len, pquad, this_ip_id, pkt_already_seen,
                     &recovery_time);
  tcb *otherdir;
  int dir, num_acked;
#ifdef LOG_OOO
  extern FILE *fp_dup_ooo_log;
#endif

  if (pkt_already_seen)
    {
      pseg->type_of_segment = type_of_segment;
      num_acked = (pseg->prev != NULL) ? pseg->prev->acked : 0;
    }
  else
    {
      pseg->prev->type_of_segment = type_of_segment;
      num_acked = (pseg->prev->prev != NULL) ? pseg->prev->prev->acked : 0;
    }
  /* LM added */

  dir = (&(thisdir->ptp->c2s)) == thisdir;
  otherdir = (dir == C2S) ? &(thisdir->ptp->s2c) : &(thisdir->ptp->c2s);

  DeltaT2 =
    time2double (current_time) - time2double (pquad->seglist_tail->time);

  Mean_RTT =
    Average (thisdir->rtt_sum,
             thisdir->rtt_count) + Average (otherdir->rtt_sum,
                                            otherdir->rtt_count);
  RTO =
    Mean_RTT +
    4 *
    (Stdev
     (thisdir->rtt_sum + otherdir->rtt_sum,
      thisdir->rtt_sum2 + otherdir->rtt_sum2,
      thisdir->rtt_count + otherdir->rtt_count));

  RTT_min = (double) (thisdir->rtt_min + otherdir->rtt_min);

#ifdef LOG_OOO
  if (type_of_segment != 0)
    {
      wfprintf (fp_dup_ooo_log, "T: %f ",
               (elapsed (first_packet, current_time) / 1000.0));
      if (dir == C2S)
        {
          wfprintf (fp_dup_ooo_log, "%s %s ",
                   HostName (thisdir->ptp->addr_pair.a_address),
                   ServiceName (thisdir->ptp->addr_pair.a_port));
          wfprintf (fp_dup_ooo_log, "%s %s ",
                   HostName (thisdir->ptp->addr_pair.b_address),
                   ServiceName (thisdir->ptp->addr_pair.b_port));
        }
      else
        {
          wfprintf (fp_dup_ooo_log, "%s %s ",
                   HostName (thisdir->ptp->addr_pair.b_address),
                   ServiceName (thisdir->ptp->addr_pair.b_port));
          wfprintf (fp_dup_ooo_log, "%s %s ",
                   HostName (thisdir->ptp->addr_pair.a_address),
                   ServiceName (thisdir->ptp->addr_pair.a_port));
        }

      wfprintf (fp_dup_ooo_log,
               "%lu %lu %d %d %u %d %u %d %lf %lf %lu %lf %lf %lf %d",
               thisdir->data_pkts,
               thisdir->data_bytes,
               (type_of_segment & 15),
               thisdir->fsack_req && otherdir->fsack_req,
               thisdir->mss,
               (dir == C2S),
               (internal_dst),
               thisdir->initialwin_bytes,
               recovery_time / 1000.0,
               DeltaT2 / 1000.0,
               len, RTO / 1000.0, RTT_min / 1000.0, Mean_RTT / 1000.0,
               num_acked);
      wfprintf (fp_dup_ooo_log, " %f %f %f %f\n", thisdir->srtt / 1000.0,
               thisdir->rttvar / 1000.0, otherdir->srtt / 1000.0,
               otherdir->rttvar / 1000.0);
    }

#endif

  if (internal_src && !internal_dst)
    {
      add_histo (tcp_anomalies_out, aggregateType (type_of_segment));
    }
  else if (!internal_src && internal_dst)
    {
      add_histo (tcp_anomalies_in, aggregateType (type_of_segment));
    }
#ifndef LOG_UNKNOWN
  else if (internal_src && internal_dst)
#else
  else
#endif
    {
      add_histo (tcp_anomalies_loc, aggregateType (type_of_segment));
    }
  if (dir == C2S)
    {
      add_histo (tcp_anomalies_c2s, aggregateType (type_of_segment));
    }
  else
    {
      add_histo (tcp_anomalies_s2c, aggregateType (type_of_segment));
    }

/* just keep the main classification  and discard bit larger than
   BATCH_CLASSIFICATION*/
  switch (type_of_segment & (BATCH_CLASSIFICATION - 1))
    {
    case IN_SEQUENCE:
      /* just ignore them */
      break;
    case RETRANSMISSION_RTO:
      thisdir->rtx_RTO++;
      break;
    case RETRANSMISSION_FR:
      thisdir->rtx_FR++;
      break;
    case REORDERING:
      thisdir->reordering++;
      break;
    case NETWORK_DUPLICATE:
      thisdir->net_dup++;
      break;
    case FLOW_CONTROL:
      thisdir->flow_control++;
      break;
    case UNNECESSARY_RETRANSMISSION_FR:
      thisdir->unnecessary_rtx_FR++;
      break;
    case UNNECESSARY_RETRANSMISSION_RTO:
      thisdir->unnecessary_rtx_RTO++;
      break;
    default:
      thisdir->unknown++;
    }
}
Ejemplo n.º 12
0
 /* LM start - Rule number one
  ** R1.a IP_id_new not equal to IP_id_old
  ** R1.b this_seg_time-prev_seg_time >
  ** R1.c number of acks > 3 (or max number permitted)
  ** DeltaT1: Time between current segment and the last segment before a ooo
  ** DeltaT2: Time between current segment and the received segment with the maximum sequence number
  */
char
real_rules_test (tcb * thisdir, segment * pseg, seglen len, quadrant * pquad,
                 u_short this_ip_id, Bool pkt_already_seen,
                 double *recovery_time)
{
  double RTO, RTT, Mean_RTT;
  int Rule1a, Rule1b, Rule1d;
  int Rule2b, Rule2c;
  int RuleProbing;
  tcb *otherdir;
  char prev_tos;
  int validRTT;

  int dir = (&(thisdir->ptp->c2s) == thisdir);

  otherdir = (dir == C2S) ? &(thisdir->ptp->s2c) : &(thisdir->ptp->c2s);
  Mean_RTT =
    Average (thisdir->rtt_sum,
             thisdir->rtt_count) + Average (otherdir->rtt_sum,
                                            otherdir->rtt_count);
  RTO =
    Mean_RTT +
    4 *
    (Stdev
     (thisdir->rtt_sum + otherdir->rtt_sum,
      thisdir->rtt_sum2 + otherdir->rtt_sum2,
      thisdir->rtt_count + otherdir->rtt_count));
  RTT = (double) (thisdir->rtt_min + otherdir->rtt_min);
  validRTT = (thisdir->rtt_count != 0 && otherdir->rtt_count != 0);

  if (RTO < RTO_MIN)
    RTO = RTO_MIN;
  if (RTT < RTT_MIN)
    RTT = RTT_MIN;

  if (!pkt_already_seen)        /* if pkt_already_seen then *recovery_time is passed otherwise it is set below */
    *recovery_time =
      (pseg->prev->prev !=
       NULL) ? time2double (current_time) -
      time2double (pseg->prev->prev->time) : -1.0;
  /* take the previous packet classification */

  if (pseg->prev != NULL)
    {
      if (pkt_already_seen)
        prev_tos = pseg->prev->type_of_segment;
      else
        prev_tos =
          (pseg->prev->prev !=
           NULL) ? pseg->prev->prev->type_of_segment : IN_SEQUENCE;
    }
  else
    prev_tos = IN_SEQUENCE;

  if (!validRTT)
    {
      RTT = INITIAL_RTT_MIN;
      RTO = INITIAL_RTO;
      /* if *recovery_time is -1 then this is the first packet and use next segment as recovery time */
      if (*recovery_time == -1.0)
        *recovery_time =
          time2double (current_time) - time2double (pseg->time);
    }

  Rule1a = (pseg->ip_id != this_ip_id);
  Rule1b = (*recovery_time > RTO);
  Rule1d = (*recovery_time < Mean_RTT);
  if (pkt_already_seen)
    Rule2b = (pseg->prev != NULL) ? (pseg->prev->acked > 3
                                     && *recovery_time < RTO) : 0;
  else
    Rule2b = (pseg->prev->prev != NULL) ? (pseg->prev->prev->acked > 3
                                           && *recovery_time < RTO) : 0;

  Rule2c = (time2double (current_time) - time2double (pseg->time) < RTT);

  RuleProbing = ((len == 1) && (otherdir->win_curr == 0)
                 && (thisdir->syn_count != 0) && (otherdir->syn_count != 0));

  if (RuleProbing)
    return FLOW_CONTROL;
  if (Rule1d && prev_tos != IN_SEQUENCE)
    return (prev_tos | BATCH_CLASSIFICATION);   /* Old Classification with the first bit is 1 */


  if (!pseg->acked)
    {
      if (pkt_already_seen)
        {
          if (!Rule1a)
            return CLASSIFICATION (NETWORK_DUPLICATE);
          if (Rule1a && (Rule1b || Rule2b))
            return CLASSIFICATION (Rule2b ? RETRANSMISSION_FR :
                                   RETRANSMISSION_RTO);
          if (Rule1d)
            return
              CLASSIFICATION (DUPLICATE_WITH_RC_LESS_THAN_RTT_NOT_3DUP_ACK);
          if (!Rule1b)
            return
              CLASSIFICATION
              (DUPLICATE_WITH_RC_LESS_THAN_RTO_AND_GREATER_THAN_RTT_NOT_3DUP_ACK);
          return CLASSIFICATION (UNKNOWN);
        }

      if (Rule1b || Rule2b)
        return CLASSIFICATION (Rule2b ? RETRANSMISSION_FR :
                               RETRANSMISSION_RTO);
      if (Rule2c)
        return CLASSIFICATION (REORDERING);
      if (Rule1d)
        return CLASSIFICATION (OOO_WITH_RC_LESS_THAN_RTT_NOT_3DUP_ACK);
      if (!Rule1b)
        return
          CLASSIFICATION
          (OOO_WITH_RC_LESS_THAN_RTO_AND_GREATER_THAN_RTT_NOT_3DUP_ACK);
      return CLASSIFICATION (UNKNOWN);

    }

  if (!Rule1a)
    return CLASSIFICATION (NETWORK_DUPLICATE);
  if ((Rule1b || Rule2b))
    return CLASSIFICATION (Rule2b ? UNNECESSARY_RETRANSMISSION_FR :
                           UNNECESSARY_RETRANSMISSION_RTO);
  if (Rule1d)
    return
      CLASSIFICATION
      (UNNECESSARY_RETRANSMISSION_WITH_RC_LESS_THAN_RTT_NOT_3DUP_ACK);
  if (!Rule1b)
    return
      CLASSIFICATION
      (UNNECESSARY_RETRANSMISSION_WITH_RC_LESS_THAN_RTO_AND_GREATER_THAN_RTT_NOT_3DUP_ACK);
  return CLASSIFICATION (UNKNOWN);
}
Ejemplo n.º 13
0
// Returns the standard deviation
double BasicStats::SD()
{
  double average = Average();
  return sqrt((squaredsum - (stream_size*average*average))/(stream_size-1));
}
Ejemplo n.º 14
0
 void getAverage()
 {
     float avg = Average();
     std::cout << "This is the average: " << avg << std::endl;
 }
Ejemplo n.º 15
0
float SimpleFilter::WindowFilter(float* list, int windowSize) {
	float av = Average(MedianFilter(list, windowSize), 3);
	return av;
}
// ----------------------------------------------------------------------------------
// CTCStateTiltListenData::CalculateTilt
// ----------------------------------------------------------------------------------
//
TBool CTCStateTiltListenData::CalculateTilt()
    {
    FUNC_LOG;
    
    TBool flush( EFalse );
    if( IsSet( EAccelerometerData ) && IsSet( EMagnetometerData ) )
        {
        TTiltCompensationOutput output;
        
        Average ( iArrayAcc, iInput.iAccelerationVector.iX, iInput.iAccelerationVector.iY, iInput.iAccelerationVector.iZ );
        Average ( iArrayMag, iInput.iMagneticVector.iX, iInput.iMagneticVector.iY, iInput.iMagneticVector.iZ );

        INFO_1( "Tilt compensation average MagX: %d", iInput.iMagneticVector.iX );
        INFO_1( "Tilt compensation average MagY: %d", iInput.iMagneticVector.iY );
        INFO_1( "Tilt compensation average MagZ: %d", iInput.iMagneticVector.iZ );
        INFO_1( "Tilt compensation average AccX: %d", iInput.iAccelerationVector.iX );
        INFO_1( "Tilt compensation average AccY: %d", iInput.iAccelerationVector.iY );
        INFO_1( "Tilt compensation average AccZ: %d", iInput.iAccelerationVector.iZ );
        INFO_1( "Tilt compensation iSizeOfAccArray: %d", iSizeOfAccArray );
        INFO_1( "Tilt compensation iSizeOfMagArray: %d", iSizeOfMagArray );
        INFO_1( "Tilt compensation iPreviousTheta: %d", iPreviousTheta );
        INFO_2( "Tilt compensation params: k[%f], m[%f]", iParamsArray[0], iParamsArray[1] );
        INFO_2( "Tilt compensation params: tresholdAng1[%f], tresholdAng2[%f]",
                iParamsArray[2], iParamsArray[3] );
        
        TInt err = iCompensationFunc( iInput, output, iPreviousTheta, iParamsArray );
                    
        iPreviousTheta = output.iTheta;

        ERROR( err, "Tilt compensation failed" );
        if( err == KErrNone )
            {
            INFO_1( "Tilt compensation succesfull. Tilt angle: %d", output.iTheta );
            
            // Write data into data buffer
            TUint8* buffer = iTransactionHandler.DataBuffer();
            if( buffer && ( iWriteCount < iTransactionHandler.DataCount() ) )
                {
                // Move pointer if needed
                buffer += sizeof( TSensrvMagneticNorthData ) * iWriteCount;
                TSensrvMagneticNorthData* tiltData
                  = reinterpret_cast<TSensrvMagneticNorthData*>( buffer );
                iTime.HomeTime();
                tiltData->iTimeStamp = iTime;
                tiltData->iAngleFromMagneticNorth = output.iTheta;
                if( ++iWriteCount == iTransactionHandler.DataCount() ||
                    IsSet( EForceBufferFull ) )
                    {
                    flush = ETrue;
                    }
                    
                // Reset state but not write count
                ResetState( EFalse );
                }
            else
                {
                ERROR_GEN( "Tilt data buffer empty" );
                }
            }
        }
        
    return flush;
    }
Ejemplo n.º 17
0
		template <> SIMD_INLINE uint8_t OperationBinary8u<SimdOperationBinary8uAverage>(const uint8_t & a, const uint8_t & b)
		{
			return Average(a, b);
		}
Ejemplo n.º 18
0
static void CompressACComponent(JPEGCompressor *self,int comp,unsigned int k,bool canbezero,
const JPEGBlock *current,const JPEGBlock *north,const JPEGBlock *west,
const JPEGQuantizationTable *quantization)
{
	int value=current->c[k];

	if(!north) north=&ZeroBlock;
	if(!west) west=&ZeroBlock;

	int val1;
	if(IsFirstRowOrColumn(k)) val1=Abs(BDR(k,current,north,west,quantization));
	else val1=Average(k,north,west,quantization);

	int val2=Sum(k,current);

	if(canbezero)
	{
		// Compress zero/non-zero bit.
		int zerocontext1=Min(Category(val1),2);
		int zerocontext2=Min(Category(val2),5);

		WriteDynamicBit(&self->encoder,value!=0,
		&self->zerobins[comp][k-1][zerocontext1][zerocontext2],
		self->zeroshift);

		// If this component is zero, there is no need to compress further parameters.
		if(value==0) return;
	}

	// This component is not zero. Proceed with compressing absolute value.
	int absvalue=Abs(value);

	// Compress pivot (abs>=2).
	int pivotcontext1=Min(Category(val1),4);
	int pivotcontext2=Min(Category(val2),6);

	WriteDynamicBit(&self->encoder,absvalue>1,
	&self->pivotbins[comp][k-1][pivotcontext1][pivotcontext2],
	self->pivotshift);

	if(absvalue>1)
	{
		// The absolute of this component is >=2. Proceed with compressing
		// the absolute value.
		int val3,n;
		if(IsFirstRow(k)) { val3=Column(k)-1; n=0; }
		else if(IsFirstColumn(k)) { val3=Row(k)-1; n=1; }
		else { val3=Category(k-4); n=2; }

		int magnitudecontext1=Min(Category(val1),8);
		int magnitudecontext2=Min(Category(val2),8);
		int remaindercontext=val3;

		// Compress absolute value.
		WriteUniversalCode(&self->encoder,absvalue-2,
		self->acmagnitudebins[comp][n][magnitudecontext1][magnitudecontext2],
		self->acmagnitudeshift,
		self->acremainderbins[comp][n][remaindercontext],
		self->acremaindershift);
	}

	CompressACSign(self,comp,k,absvalue,current,north,west,quantization);
}
Ejemplo n.º 19
0
void
PrintTrace(
    tcp_pair *ptp)
{
    double etime;
    u_long etime_secs;
    u_long etime_usecs;
    double etime_data1;
    double etime_data2;
    tcb *pab = &ptp->a2b;
    tcb *pba = &ptp->b2a;
    char *host1 = pab->host_letter;
    char *host2 = pba->host_letter;
    char bufl[40],bufr[40];
   
    /* counters to use for seq. space wrap around calculations
     */
    u_llong stream_length_pab=0, stream_length_pba=0;
    u_long pab_last, pba_last;

   /* Reset the counter for each connection */
   sv_print_count = 1; /* The first field (conn_#) gets printed in trace.c */
   

    /* calculate elapsed time */
    etime = elapsed(ptp->first_time,ptp->last_time);
    etime_secs = etime / 1000000.0;
    etime_usecs = 1000000 * (etime/1000000.0 - (double)etime_secs);

    /* Check if comma-separated-values or tab-separated-values
     * has been requested.
     */ 
   if(csv || tsv || (sv != NULL)) {
       fprintf(stdout,"%s%s%s%s%s%s%s%s",
	       ptp->a_hostname, sp, ptp->b_hostname, sp,
	       ptp->a_portname, sp, ptp->b_portname, sp);
       sv_print_count += 4;
       /* Print the start and end times. In other words,
	* print the time of the first and the last packet
	*/ 
       fprintf(stdout,"%ld.%ld %s %ld.%ld %s",
	       (long)ptp->first_time.tv_sec, (long)ptp->first_time.tv_usec, sp,
	       (long)ptp->last_time.tv_sec, (long)ptp->last_time.tv_usec, sp);
       sv_print_count += 2;      
    }
    else {
       fprintf(stdout,"\thost %-4s      %s\n",
	       (snprintf(bufl,sizeof(bufl),"%s:", host1),bufl), ptp->a_endpoint);
       fprintf(stdout,"\thost %-4s      %s\n",
	       (snprintf(bufl,sizeof(bufl),"%s:", host2),bufl), ptp->b_endpoint);
       fprintf(stdout,"\tcomplete conn: %s",
	       ConnReset(ptp)?"RESET":(
				       ConnComplete(ptp)?"yes":"no"));
       if (ConnComplete(ptp))
	 fprintf(stdout,"\n");
       else
	 fprintf(stdout,"\t(SYNs: %u)  (FINs: %u)\n",
		 SynCount(ptp), FinCount(ptp));
       
       fprintf(stdout,"\tfirst packet:  %s\n", ts2ascii(&ptp->first_time));
       fprintf(stdout,"\tlast packet:   %s\n", ts2ascii(&ptp->last_time));
       
       fprintf(stdout,"\telapsed time:  %s\n", elapsed2str(etime));
       
       fprintf(stdout,"\ttotal packets: %" FS_ULL "\n", ptp->packets);
       
       fprintf(stdout,"\tfilename:      %s\n", ptp->filename);
       
       fprintf(stdout,"   %s->%s:			      %s->%s:\n",
	       host1,host2,host2,host1);
    }
   
    StatLineI("total packets","", pab->packets, pba->packets);
    if (pab->reset_count || pba->reset_count || csv || tsv || (sv != NULL))
	StatLineI("resets sent","", pab->reset_count, pba->reset_count);
    StatLineI("ack pkts sent","", pab->ack_pkts, pba->ack_pkts);
    StatLineI("pure acks sent","", pab->pureack_pkts, pba->pureack_pkts);
    StatLineI("sack pkts sent","", pab->num_sacks, pba->num_sacks);
    StatLineI("dsack pkts sent","", pab->num_dsacks, pba->num_dsacks);
    StatLineI("max sack blks/ack","", pab->max_sack_blocks, pba->max_sack_blocks);
    StatLineI("unique bytes sent","",
	      pab->unique_bytes, pba->unique_bytes);
    StatLineI("actual data pkts","", pab->data_pkts, pba->data_pkts);
    StatLineI("actual data bytes","", pab->data_bytes, pba->data_bytes);
    StatLineI("rexmt data pkts","", pab->rexmit_pkts, pba->rexmit_pkts);
    StatLineI("rexmt data bytes","",
	      pab->rexmit_bytes, pba->rexmit_bytes);
    StatLineI("zwnd probe pkts","", 
		  pab->num_zwnd_probes, pba->num_zwnd_probes);
    StatLineI("zwnd probe bytes","",
	      pab->zwnd_probe_bytes, pba->zwnd_probe_bytes);
    StatLineI("outoforder pkts","",
	      pab->out_order_pkts, pba->out_order_pkts);
    StatLineI("pushed data pkts","", pab->data_pkts_push, pba->data_pkts_push);
    StatLineP("SYN/FIN pkts sent","","%s",
	      (snprintf(bufl,sizeof(bufl),"%d/%d",
		       pab->syn_count, pab->fin_count),bufl),
	      (snprintf(bufr,sizeof(bufr),"%d/%d",
		       pba->syn_count, pba->fin_count),bufr));
    if (pab->f1323_ws || pba->f1323_ws || pab->f1323_ts || pba->f1323_ts || csv || tsv || (sv != NULL)) {
	StatLineP("req 1323 ws/ts","","%s",
		  (snprintf(bufl,sizeof(bufl),"%c/%c",
		      pab->f1323_ws?'Y':'N',pab->f1323_ts?'Y':'N'),bufl),
		  (snprintf(bufr,sizeof(bufr),"%c/%c",
		      pba->f1323_ws?'Y':'N',pba->f1323_ts?'Y':'N'),bufr));
    }
    if (pab->f1323_ws || pba->f1323_ws || csv || tsv || (sv != NULL)) {
	StatLineI("adv wind scale","",
		  (u_long)pab->window_scale, (u_long)pba->window_scale);
    }
    if (pab->fsack_req || pba->fsack_req || csv || tsv || (sv != NULL)) {
	StatLineP("req sack","","%s",
		  pab->fsack_req?"Y":"N",
		  pba->fsack_req?"Y":"N");
	StatLineI("sacks sent","",
		  pab->sacks_sent,
		  pba->sacks_sent);
    }
    StatLineI("urgent data pkts", "pkts",
	      pab->urg_data_pkts,
	      pba->urg_data_pkts);
    StatLineI("urgent data bytes", "bytes",
	      pab->urg_data_bytes,
	      pba->urg_data_bytes);
    StatLineI("mss requested","bytes", pab->mss, pba->mss);
    StatLineI("max segm size","bytes",
	      pab->max_seg_size,
	      pba->max_seg_size);
    StatLineI("min segm size","bytes",
	      pab->min_seg_size,
	      pba->min_seg_size);
    StatLineI("avg segm size","bytes",
	      (int)((double)pab->data_bytes / ((double)pab->data_pkts+.001)),
	      (int)((double)pba->data_bytes / ((double)pba->data_pkts+.001)));
    StatLineI("max win adv","bytes", pab->win_max, pba->win_max);
    StatLineI("min win adv","bytes", pab->win_min, pba->win_min);
    StatLineI("zero win adv","times",
	      pab->win_zero_ct, pba->win_zero_ct);
    // Average window advertisement is calculated only for window scaled pkts
    // if we have seen this connection using window scaling.
    // Otherwise, it is just the regular way of dividing the sum of 
    // all window advertisements by the total number of packets.
     
    if (pab->window_stats_updated_for_scaling &&
	pba->window_stats_updated_for_scaling)
	  StatLineI("avg win adv","bytes",
		    pab->win_scaled_pkts==0?0:
		    (pab->win_tot/pab->win_scaled_pkts),
		    pba->win_scaled_pkts==0?0:
		    (pba->win_tot/pba->win_scaled_pkts));
    else
	  StatLineI("avg win adv","bytes",
		    pab->packets==0?0:pab->win_tot/pab->packets,
		    pba->packets==0?0:pba->win_tot/pba->packets);
    if (print_owin) {
	StatLineI("max owin","bytes", pab->owin_max, pba->owin_max);
	StatLineI("min non-zero owin","bytes", pab->owin_min, pba->owin_min);
	StatLineI("avg owin","bytes",
		  pab->owin_count==0?0:pab->owin_tot/pab->owin_count,
		  pba->owin_count==0?0:pba->owin_tot/pba->owin_count);
	if (etime == 0.0) {
		StatLineP("wavg owin", "", "%s", "NA", "NA");	
	}
	else {
		StatLineI("wavg owin","bytes", 
			  (u_llong)(pab->owin_wavg/((double)etime/1000000)), 
		  	  (u_llong)(pba->owin_wavg/((double)etime/1000000)));
   	} 
    }
    StatLineI("initial window","bytes",
	      pab->initialwin_bytes, pba->initialwin_bytes);
    StatLineI("initial window","pkts",
	      pab->initialwin_segs, pba->initialwin_segs);

    /* compare to theoretical length of the stream (not just what
       we saw) using the SYN and FIN
     * Seq. Space wrap around calculations:
     * Calculate stream length using last_seq_num seen, first_seq_num
     * seen and wrap_count.
     * first_seq_num = syn
     * If reset_set, last_seq_num = latest_seq
     *          else last_seq_num = fin
     */
    
    pab_last = (pab->reset_count>0)?pab->latest_seq:pab->fin;
    
    pba_last = (pba->reset_count>0)?pba->latest_seq:pba->fin;
    
    /* calculating stream length for direction pab */
    if ((pab->syn_count > 0) && (pab->fin_count > 0)) {
	if (pab->seq_wrap_count > 0) {
	    if (pab_last > pab->syn) {
		stream_length_pab = pab_last + (MAX_32 * pab->seq_wrap_count) - pab->syn - 1;
	    }
	    else {
		stream_length_pab = pab_last + (MAX_32 * (pab->seq_wrap_count+1)) - pab->syn - 1;
	    }
	}
	else {
	    if (pab_last > pab->syn) {
		stream_length_pab = pab_last - pab->syn - 1;
	    }
	    else {
		stream_length_pab = MAX_32 + pab_last - pab->syn - 1;
	    }
	}
    }

    /* calculating stream length for direction pba */
    if ((pba->syn_count > 0) && (pba->fin_count > 0)) {
	if (pba->seq_wrap_count > 0) {
	    if (pba_last > pba->syn) {
		stream_length_pba = pba_last + (MAX_32 * pba->seq_wrap_count) - pba->syn - 1;
	    }
	    else {
		stream_length_pba = pba_last + (MAX_32 * (pba->seq_wrap_count+1)) - pba->syn - 1;
	    }
	}
	else {
	    if (pba_last > pba->syn) {
		stream_length_pba = pba_last - pba->syn - 1;
	    }
	    else {
		stream_length_pba = MAX_32 + pba_last - pba->syn - 1;
	    }
	}
    }

    /* print out values */
    if ((pab->fin_count > 0) && (pab->syn_count > 0)) {
	char *format = "%8" FS_ULL;
	StatLineFieldL("ttl stream length", "bytes", format, stream_length_pab, 0);
    }
    else {
	StatLineField("ttl stream length", "", "%s", (u_long)"NA", 0);
    }
    if ((pba->fin_count > 0) && (pba->syn_count > 0)) {
	char *format = "%8" FS_ULL;
	StatLineFieldL("ttl stream length", "bytes", format, stream_length_pba, 1);
    }
    else {
	StatLineField("ttl stream length", "", "%s", (u_long)"NA", 1);
    }

    if ((pab->fin_count > 0) && (pab->syn_count > 0)) {
	char *format = "%8" FS_ULL;
	StatLineFieldL("missed data", "bytes", format, (stream_length_pab - pab->unique_bytes), 0);
    }
    else {
	StatLineField("missed data", "", "%s", (u_long)"NA", 0);
    }
    if ((pba->fin_count > 0) && (pba->syn_count > 0)) {
	char *format = "%8" FS_ULL;
	StatLineFieldL("missed data", "bytes", format, (stream_length_pba - pba->unique_bytes), 1);
    }
    else {
	StatLineField("missed data", "", "%s", (u_long)"NA", 1);
    }
    
    /* tell how much data was NOT captured in the files */
    StatLineI("truncated data","bytes",
	      pab->trunc_bytes, pba->trunc_bytes);
    StatLineI("truncated packets","pkts",
	      pab->trunc_segs, pba->trunc_segs);

    /* stats on just the data */
    etime_data1 = elapsed(pab->first_data_time,
			  pab->last_data_time); /* in usecs */
    etime_data2 = elapsed(pba->first_data_time,
			  pba->last_data_time); /* in usecs */
    /* fix from Rob Austein */
    StatLineF("data xmit time","secs","%7.3f",
	      etime_data1 / 1000000.0,
	      etime_data2 / 1000000.0);
    StatLineP("idletime max","ms","%s",
	      ZERO_TIME(&pab->last_time)?"NA":
	      (snprintf(bufl,sizeof(bufl),"%8.1f",(double)pab->idle_max/1000.0),bufl),
	      ZERO_TIME(&pba->last_time)?"NA":
	      (snprintf(bufr,sizeof(bufr),"%8.1f",(double)pba->idle_max/1000.0),bufr));

    if ((pab->num_hardware_dups != 0) || (pba->num_hardware_dups != 0)  || csv || tsv || (sv != NULL)) {
	StatLineI("hardware dups","segs",
		  pab->num_hardware_dups, pba->num_hardware_dups);

        if(!(csv || tsv || (sv != NULL)))       
	  fprintf(stdout,
		  "       ** WARNING: presence of hardware duplicates makes these figures suspect!\n");
    }

    /* do the throughput calcs */
    etime /= 1000000.0;  /* convert to seconds */
    if (etime == 0.0)
	StatLineP("throughput","","%s","NA","NA");
    else
	StatLineF("throughput","Bps","%8.0f",
		  (double) (pab->unique_bytes) / etime,
		  (double) (pba->unique_bytes) / etime);

    if (print_rtt) {
        if(!(csv || tsv || (sv != NULL)))
	  fprintf(stdout,"\n");
	StatLineI("RTT samples","", pab->rtt_count, pba->rtt_count);
	StatLineF("RTT min","ms","%8.1f",
		  (double)pab->rtt_min/1000.0,
		  (double)pba->rtt_min/1000.0);
	StatLineF("RTT max","ms","%8.1f",
		  (double)pab->rtt_max/1000.0,
		  (double)pba->rtt_max/1000.0);
	StatLineF("RTT avg","ms","%8.1f",
		  Average(pab->rtt_sum, pab->rtt_count) / 1000.0,
		  Average(pba->rtt_sum, pba->rtt_count) / 1000.0);
	StatLineF("RTT stdev","ms","%8.1f",
		  Stdev(pab->rtt_sum, pab->rtt_sum2, pab->rtt_count) / 1000.0,
		  Stdev(pba->rtt_sum, pba->rtt_sum2, pba->rtt_count) / 1000.0);
        if(!(csv || tsv || (sv != NULL)))
	  fprintf(stdout,"\n");
	StatLineF("RTT from 3WHS","ms","%8.1f",
		  (double)pab->rtt_3WHS/1000.0,
		  (double)pba->rtt_3WHS/1000.0);
        if(!(csv || tsv || (sv != NULL)))
	  fprintf(stdout,"\n");
	StatLineI("RTT full_sz smpls","", 
		  pab->rtt_full_count, pba->rtt_full_count);
	StatLineF("RTT full_sz min","ms","%8.1f",
		  (double)pab->rtt_full_min/1000.0,
		  (double)pba->rtt_full_min/1000.0);
	StatLineF("RTT full_sz max","ms","%8.1f",
		  (double)pab->rtt_full_max/1000.0,
		  (double)pba->rtt_full_max/1000.0);
	StatLineF("RTT full_sz avg","ms","%8.1f",
		  Average(pab->rtt_full_sum, pab->rtt_full_count) / 1000.0,
		  Average(pba->rtt_full_sum, pba->rtt_full_count) / 1000.0);
	StatLineF("RTT full_sz stdev","ms","%8.1f",
		  Stdev(pab->rtt_full_sum, pab->rtt_full_sum2, pab->rtt_full_count) / 1000.0,
		  Stdev(pba->rtt_full_sum, pba->rtt_full_sum2, pba->rtt_full_count) / 1000.0);
        if(!(csv || tsv || (sv != NULL)))
	  fprintf(stdout,"\n");
	StatLineI("post-loss acks","",
		  pab->rtt_nosample, pba->rtt_nosample);
	if (pab->rtt_amback || pba->rtt_amback || csv || tsv || (sv != NULL)) {
	   if(!(csv || tsv || (sv != NULL)))
	     fprintf(stdout, "\
\t  For the following 5 RTT statistics, only ACKs for\n\
\t  multiply-transmitted segments (ambiguous ACKs) were\n\
\t  considered.  Times are taken from the last instance\n\
\t  of a segment.\n\
");
	    StatLineI("ambiguous acks","",
		      pab->rtt_amback, pba->rtt_amback);
	    StatLineF("RTT min (last)","ms","%8.1f",
		      (double)pab->rtt_min_last/1000.0,
		      (double)pba->rtt_min_last/1000.0);
	    StatLineF("RTT max (last)","ms","%8.1f",
		      (double)pab->rtt_max_last/1000.0,
		      (double)pba->rtt_max_last/1000.0);
	    StatLineF("RTT avg (last)","ms","%8.1f",
		      Average(pab->rtt_sum_last, pab->rtt_count_last) / 1000.0,
		      Average(pba->rtt_sum_last, pba->rtt_count_last) / 1000.0);
	    StatLineF("RTT sdv (last)","ms","%8.1f",
		      Stdev(pab->rtt_sum_last, pab->rtt_sum2_last, pab->rtt_count_last) / 1000.0,
		      Stdev(pba->rtt_sum_last, pba->rtt_sum2_last, pba->rtt_count_last) / 1000.0);

	}
	StatLineI("segs cum acked","",
		  pab->rtt_cumack, pba->rtt_cumack);
	StatLineI("duplicate acks","",
		  pab->rtt_dupack, pba->rtt_dupack);
	StatLineI("triple dupacks","",
		  pab->rtt_triple_dupack, pba->rtt_triple_dupack);
	if (debug)
	    StatLineI("unknown acks:","",
		      pab->rtt_unkack, pba->rtt_unkack);
	StatLineI("max # retrans","",
		  pab->retr_max, pba->retr_max);
	StatLineF("min retr time","ms","%8.1f",
		  (double)((double)pab->retr_min_tm/1000.0),
		  (double)((double)pba->retr_min_tm/1000.0));
	StatLineF("max retr time","ms","%8.1f",
		  (double)((double)pab->retr_max_tm/1000.0),
		  (double)((double)pba->retr_max_tm/1000.0));
	StatLineF("avg retr time","ms","%8.1f",
		  Average(pab->retr_tm_sum, pab->retr_tm_count) / 1000.0,
		  Average(pba->retr_tm_sum, pba->retr_tm_count) / 1000.0);
	StatLineF("sdv retr time","ms","%8.1f",
		  Stdev(pab->retr_tm_sum, pab->retr_tm_sum2,
			pab->retr_tm_count) / 1000.0,
		  Stdev(pba->retr_tm_sum, pba->retr_tm_sum2,
			pba->retr_tm_count) / 1000.0);
    }
   
   if(csv || tsv || (sv != NULL)) {
      printf("\n");
      /* Error checking: print an error message if the count of printed fields
       * doesn't correspond to the actual fields expected.
       */
      if(sv_print_count != sv_expected_count) {
	fprintf(stderr, "output.c: Count of printed fields does not correspond to count of header fields for long output with comma/tab/<SP>-separated values.\n");
	fprintf(stderr,"sv_print_count=%u, sv_expected_count=%u\n",
		sv_print_count, sv_expected_count);
	exit(-1);
      }
   }
}
Ejemplo n.º 20
0
/**   main proccess user arguments, runs version trails and 
*     provides analytical information about performance and 
*     code correctness.
*
*/
int main(int argc, char **argv)
{
	int i;
	int threads;
	int trials;

	//get NSUB, threads and trails from argument
	if(argc != 5){
		printf("Invalid number of arguments.\n");
		printf("Usage: ./fem1d [SUB_SIZE] [NL] [NUM_THREADS] [TRIALS]\n");
		exit(EXIT_FAILURE);
	} 
	else if((NSUB = atoi(argv[1])) == 0) {
		printf("Invalid subdivison size.\n");
		printf("Usage: ./fem1d [SUB_SIZE] [NL] [NUM_THREADS] [TRIALS]\n");
		exit(EXIT_FAILURE);
    } else if ((NL = atoi(argv[2])) == 0){
        printf("Invalid number of threads.\n");
        printf("Usage: ./fem1d [SUB_SIZE] [NL] [NUM_THREADS] [TRIALS]\n");
        exit(EXIT_FAILURE);
	} else if ((threads = atoi(argv[3])) == 0){
		printf("Invalid number of threads.\n");
		printf("Usage: ./fem1d [SUB_SIZE] [NL] [NUM_THREADS] [TRIALS]\n");
		exit(EXIT_FAILURE);
	} else if ((trials = atoi(argv[4])) == 0){
		printf("Invalid number of trails.\n");
		printf("Usage: ./fem1d [SUB_SIZE] [NL] [NUM_THREADS] [TRIALS]\n");
		exit(EXIT_FAILURE);
	}

  printf("NSUB = %ld, NL = %ld, threads = %d, trails = %d\n",
    NSUB,NL,threads,trials);


	//set number of threads
	omp_set_num_threads(threads);

	//wipe solutions files
	fp_sol = fopen("old_sol.txt","w");
	fclose(fp_sol);
	fp_sol = fopen("new_sol.txt","w");
	fclose(fp_sol);

	//time spent on execution for each trail
	double time_spent[trials];

  int ver = 0;
  double old_time[trials];
  double new_time[trials];
  int oc = 0;
  int nc = 0;

  //toggle between versions and perform trials
  for(i=0;i<(trials*2);i++){
      if(ver == 0){
        printf("Running old version: trail %d...\n",oc+1);
        old_time[oc]= run(0);
        printf("Succesfully complete: Time taken: %fsec\n",old_time[oc]);
        oc++;
        ver++;
      } else if (ver == 1){
        printf("Running new version trail %d...\n",nc+1);
        new_time[nc]= run(1);
        printf("Succesfully complete: Time taken: %fsec\n",new_time[nc]);
        nc++;
        ver = ver - 1;
      }
  }

//print results
 printf("********************************** RESULTS ************************************\n");
  double o_time = Average(old_time);
  double n_time = Average(new_time);
  printf("NSUB = %ld, NL = %ld, threads = %d, trails = %d\n",NSUB,NL,threads,trials);
  printf("New version Average Time: %fsec\n",n_time);
  printf("Old version Average Time: %fsec\n",o_time);
  printf("Speed up: %fsec\n", (o_time - n_time));


/*

  //RUN OLD VERSION TRAILS
	printf("**************************** RUNNING OLD VERSION ******************************\n");
	for(i=0;i<trials;i++){
		printf("Running old version, trail %d...\n",i+1);
		time_spent[i] = run(0);
		printf("Old version, trail %d succesfully complete.\n",i+1);
		printf("Time taken: %fsec\n",time_spent[i]);
	}
	//store old time for later display
	double old_time = Average(time_spent);
	printf("**************************** RUNNING NEW VERSION ******************************\n");

	//RUN NEW VERSION TRAILS
	for(i=0;i<trials;i++){
		printf("Running new version, trail %d...\n",i+1);
		time_spent[i] = run(1);
		printf("New version, trail %d succesfully complete.\n", i+1); 
		printf("Time taken: %fsec\n",time_spent[i]);
	}

	printf("********************************** RESULTS ************************************\n");

	double new_time = Average(time_spent);
	printf("New version Average Time: %fsec\n",new_time);
	printf("Old version Average Time: %fsec\n",old_time);
	printf("Speed up: %fsec\n", (old_time - new_time));

  */

	//CHECK FOR CORRCTNESS
	if(check()==0){
		printf("CORRECT: Outputs are identical.\n");
	} else {
		printf("INCORRECT: Outputs are not identical.\n");
	}

	return 0;
}
Ejemplo n.º 21
0
int main()
{
	/* Kamus Lokal */
		List MyList, List2, List3;
		int i;
		infotype isi;
		address P, Prec;
		
	/* Program */
	CreateList (&MyList);
	printf ("Jml Elemen List adalah : %d \n", NbElmt(MyList));
/* Menambah List di awal */
	i = 1;
	while (i <= 5)
	{
		InsVFirst (&MyList, i*5);
		i++;
	}
	printf ("Hasil InsVFirst 5 x adalah : "); PrintInfo (MyList);
	printf ("Node Maksimal = %d ",Max (MyList));
	printf ("Node Minimal = %d ",Min (MyList));
	printf ("Rata-rata = %d \n",Average (MyList));
/* Mencari suatu elemen di list */	

	P = Search(MyList, 15);
printf ("Search yang berhasil (15) : P = %d, Ketemu = %d \n",P,FSearch(MyList,P));
	DelP (&MyList, 15);

/* Insert di Last */
	printf ("Insert di akhir nilai 723 : ");
	InsVLast (&MyList, 723); 
	PrintInfo (MyList);

/* Insert diantara 2 elemen */
	printf ("Insert sebelum elemen 10  : ");
	Prec = SearchPrec (MyList, 10);
	P = Alokasi (2712);
	if (P != Nil)
	{   InsertAfter (&MyList, P, Prec);	}
	PrintInfo (MyList);
	
/* Menghapus elemen List */	
	printf ("\tHasil Delete dari elemen List :\n");
	printf ("Jumlah elemen list = %d \n", NbElmt(MyList));
	DelVFirst (&MyList, &isi);		
	printf ("DelVFirst adalah %d\t", isi);
	
	DelVLast (&MyList, &isi);		
	printf ("DelVLast adalah %d\t", isi);

/* Menghapus elemen di tengah-tengah */
	Prec = SearchPrec (MyList, 10);	/* Node yang akan dihapus */
	if (Prec != Nil)
	{
	    DelAfter (&MyList, &P, Prec);		
	    isi = Info(P);
	    DeAlokasi (P);
	    printf ("DelAfter adalah %d\n", isi);
	}    
	printf ("Hasil setelah delete : ");
        PrintInfo (MyList);
	
	printf ("Insert sebelum elemen 5 : ");
	Prec = SearchPrec (MyList, 5);
	P = Alokasi (-987);
	if (P != Nil)
	{   InsertAfter (&MyList, P, Prec);	}
	PrintInfo (MyList);

/* Invers List */
	printf ("\tHasil Invers dari List yang ada : \n");
	printf ("Versi 1 : ");
	List2 = FInversList (MyList);	
	PrintInfo (List2);
	
	printf ("Versi 2 : ");
	InversList (&MyList);
        PrintInfo (MyList);

/* Copy List */
	printf ("\tHasil Copy dari List yang ada : \n");
	printf("Versi 1 : ");
	CopyList (MyList, &List2);
	PrintInfo (List2);	

	printf ("Versi 2 : ");
	List3 = FCopyList (MyList);
	PrintInfo (List3);	
	
	printf ("Versi 3 : ");
	CpAlokList (MyList, &List2);
	PrintInfo (List2);	

/* Konkat */ 
	printf("\tHasil Konkat Invers dan List asli : \n");
	List2 = FInversList (MyList);	
	Konkat (List2, List3, &MyList);
	printf("Versi 1 : ");
	PrintInfo (MyList);	

	Konkat1 (&List2, &List3, &MyList);
	printf("Versi 2 : ");
	PrintInfo (MyList);	

/* Pecah List */
	PecahList (&List2, &List3, MyList);
	printf ("\tHasil membagi dua list adalah : \n");
	printf ("L1 = "); PrintInfo (List2);
	printf ("L2 = "); PrintInfo (List3);
/* Finishing */	
	P = First(MyList);
	DeAlokasi (P); 
	P = First(List2);
	DeAlokasi (P); 
	P = First(List3);
	DeAlokasi (P); 
	return 0;
}	
Ejemplo n.º 22
0
int main(int argc, char const **argv)
{
    int TRIALS;
    bool error = false;

    //get NSUB, threads, tasks and trails from argument
    if(argc != 6) {
        error = true;
    } else if((NSUB = atoi(argv[1])) == 0) {
        printf("Invalid subdivison size.\n");
        error = true;
    } else if ((NL = atoi(argv[2])) == 0) {
        printf("Invalid base function degree.\n");
        error = true;
    } else if ((THREADS = atoi(argv[3])) == 0) {
        printf("Invalid number of threads.\n");
        error = true;
    } else if ((TASKS = atoi(argv[4])) == 0) {
        printf("Invalid number of tasks.\n");
        error = true;
    } else if ((TRIALS = atoi(argv[5])) == 0) {
        printf("Invalid number of trails.\n");
        error = true;
    }

    if(error) {
        printf("Usage: ./fem [SUB_SIZE] [NL] [NUM_THREADS] [NUM_TASKS] [TRIALS]\n");
        exit(EXIT_FAILURE);
    }

    printf("NSUB = %ld, NL = %ld, threads = %d,tasks = %d, trails = %d\n",
           NSUB,NL,THREADS,TASKS,TRIALS);

    //wipe solutions, output & times files
    fp_sol = fopen("old_sol.txt","w");
    fclose(fp_sol);
    fp_sol = fopen("new_sol.txt","w");
    fclose(fp_sol);
    fp_out = fopen("old_out.txt","w");
    fclose(fp_sol);
    fp_out = fopen("new_out.txt","w");
    fclose(fp_sol);
    fp_time = fopen("times.txt","w");
    fclose(fp_time);

    //time spent on execution for each trail
    double time_spent[TRIALS];

    int ver = 0;
    int oc = 0;
    int nc = 0;

    char cmdNew[200];
    char cmdOld[200];
    sprintf(cmdNew, "mpirun -np %d --hostfile my_hosts new %ld %ld %d",TASKS,NSUB,NL,THREADS);
    sprintf(cmdOld, "./old %ld %ld",NSUB,NL);

    //toggle between versions and perform TRIALS
    for(int i=0; i<(TRIALS*2); i++) {
        if(ver == 0) {
            printf("Running old version: trail %d...\n",oc+1);
            system(cmdOld);
            printf("Succesfully complete.\n");
            oc++;
            ver++;
        } else if (ver == 1) {
            printf("Running new version trail %d...\n",nc+1);
            if(system(cmdNew)==0) {
                printf("Succesfully complete.\n");
            } else {
                printf("Failed to complete: MPI funnel not provided.\n");
                exit(EXIT_FAILURE);
            }
            nc++;
            ver = ver - 1;
        }
    }


    double old_time[TRIALS];
    double new_time[TRIALS];
    bool old = true;
    FILE *fp_time = fopen("times.txt","r");
    char *line = NULL;
    size_t len = 0;
    int b=0;
    while(getline(&line,&len,fp_time)!=-1) {
        if(old) {
            sscanf(line,"%lf",&old_time[b]);
        } else {
            sscanf(line,"%lf",&new_time[b]);
            b++;
        }
        old = !old;
    }


    //print results
    printf("********************************** RESULTS ************************************\n");
    double o_time = Average(old_time);
    double n_time = Average(new_time);
    printf("NSUB = %ld, NL = %ld, threads = %d,tasks = %d, trails = %d\n",
           NSUB,NL,THREADS,TASKS,TRIALS);
    printf("New version Average Time: %fsec\n",n_time);
    printf("Old version Average Time: %fsec\n",o_time);
    printf("Speed up: %fsec\n", (o_time - n_time));

    //CHECK FOR CORRCTNESS
    if(check()==0) {
        printf("CORRECT: Outputs are identical.\n");
    } else {
        printf("INCORRECT: Outputs are not identical.\n");
    }

    return 0;
}
Ejemplo n.º 23
0
/**
 * \brief Computes the parameter space metric for a coherent pulsar search.
 * \author Creighton, T. D., Jolien Creighton
 * \date 2000 - 2003
 * \ingroup StackMetric_h
 *
 * This function computes the metric \f$g_{\alpha\beta}(\mathbf{\lambda})\f$, as
 * discussed in \ref StackMetric_h, under the assumption
 * that the search consists of scanning the Fourier power spectrum
 * constructed from a single time interval \f$\Delta t\f$.  The indecies
 * \f$\alpha\f$ and \f$\beta\f$ are assumed to run from 0 to \f$n\f$, where \f$n\f$ is
 * the total number of shape parameters.
 * The argument \c metric is normally a vector of length
 * \f$(n+1)(n+2)/2\f$ storing all non-redundant coefficients of
 * \f$g_{\alpha\beta}\f$.  The indexing scheme is as follows: Let us assume
 * that \f$\alpha\geq\beta\f$.  Then
 * \f$g_{\alpha\beta} = g_{\beta\alpha} = \f$metric->data[\f$\beta + \alpha(\alpha+1)/2]\f$.
 * If <tt>params->errors</tt> is nonzero, then \a *metric must be double
 * this length, and LALCoherentMetric() will store metric
 * components and their estimated uncertainty in alternate slots; i.e.
 * the metric component
 * \f$g_{\alpha\beta}=\f$metric->data[\f$2\beta+\alpha(\alpha+1)]\f$,
 * and the uncertainty
 * \f$s_{\alpha\beta}=\f$metric->data[\f$1+2\beta+\alpha(\alpha+1)]\f$.
 *
 * The argument \a lambda is another vector, of length \f$n+1\f$,
 * storing the components of \f$\mathbf{\lambda}=(\lambda^0,\ldots,\lambda^n)\f$
 * for the parameter space point at which the metric is being evaluated.
 * The argument \a *params stores the remaining parameters for
 * computing the metric, as given in the Structures section of StackMetric.h.
 *
 * ### Algorithm ###
 *
 * This routine simply computes the function given in \eqref{eq_gab_phi}
 * of \ref StackMetric_h.  Most of the work is done by the
 * function \a params->dtCanon(), which computes the value and
 * parameter derivatives of the canonical time coordinate
 * \f$\tau[t;\vec{\lambda}]\f$.  Since the phase function is simply
 * \f$\phi[t;\mathbf{\lambda}]=2\pi\lambda^0 \tau[t;\vec\lambda]\f$, where
 * \f$\lambda^0=f_0\f$, the metric components are simply:
 * \f{eqnarray}{
 * g_{00}(\mathbf{\lambda}) & = &
 * 4\pi^2\bigg\langle\!(\tau[t;\vec\lambda])^2\bigg\rangle -
 * 4\pi^2\bigg\langle\!\tau[t;\vec\lambda]\bigg\rangle^2 \; , \\
 * g_{i0}(\mathbf{\lambda}) \;\; = \;\;
 * g_{0i}(\mathbf{\lambda}) & = &
 * 4\pi^2 f_0\bigg\langle\!
 * \tau[t;\vec\lambda]
 * \frac{\partial\tau[t;\vec\lambda]}{\partial\lambda^i}
 * \bigg\rangle
 * -
 * 4\pi^2 f_0\bigg\langle\!
 * \tau[t;\vec\lambda]
 * \bigg\rangle
 * \bigg\langle
 * \frac{\partial\tau[t;\vec\lambda]}{\partial\lambda^i}
 * \bigg\rangle \; ,\\
 * g_{ij}(\mathbf{\lambda}) & = &
 * 4\pi^2 f_0^2\bigg\langle
 * \frac{\partial\tau[t;\vec\lambda]}{\partial\lambda^i}
 * \frac{\partial\tau[t;\vec\lambda]}{\partial\lambda^j}
 * \bigg\rangle
 * -
 * 4\pi^2 f_0^2\bigg\langle
 * \frac{\partial\tau[t;\vec\lambda]}{\partial\lambda^i}
 * \bigg\rangle
 * \bigg\langle
 * \frac{\partial\tau[t;\vec\lambda]}{\partial\lambda^j}
 * \bigg\rangle \; ,
 * \f}
 * where the indecies \f$i\f$ and \f$j\f$ run from 1 to \f$n\f$.
 *
 * In the rigorous definition of the metric, the angle brackets denote an
 * average over the \em canonical time, not the detector time, so we have:
 * \f{eqnarray}{
 * \bigg\langle\ldots\bigg\rangle
 * & = & \frac{1}{\tau(t_\mathrm{start}+\Delta t)-\tau(t_\mathrm{start})}
 * \int_{\tau(t_\mathrm{start})}^{\tau(t_\mathrm{start}+\Delta t)}
 * \ldots\,d\tau\\
 * & = & \frac{1}{\tau(t_\mathrm{start}+\Delta t)-\tau(t_\mathrm{start})}
 * \int_{t_\mathrm{start}}^{t_\mathrm{start}+\Delta t}
 * \ldots\frac{\partial\tau}{\partial t}\,dt\\
 * & \approx & \frac{1}{\Delta t}
 * \int_{t_\mathrm{start}}^{t_\mathrm{start}+\Delta t}
 * \ldots\,dt \; ,
 * \f}
 * where the approximation is good to order \f$\epsilon\f$ equal to the
 * maximum difference between 1 and \f$\partial\tau/\partial t\f$.  For an
 * Earth-motion barycentred time coordinate, for instance, \f$\epsilon\f$ is
 * of order \f$10^{-4}\f$ and the approximation is quite good.  However, the
 * current implementation of the metric algorithm uses the second, exact
 * formula.  If speed considerations become important, this is one
 * obvious area for simplification.
 *
 * At present, the time averaging is performed by evaluating \f$\tau\f$ and
 * its derivatives at equally-spaced points over \f$\Delta t\f$ and applying
 * a trapezoidal method; i.e.
 * \f[
 * \frac{1}{T}\int_0^T F(t)\,dt \approx \frac{1}{N}\left(\frac{1}{2}F_0
 * + F_1 + F_2 + \ldots + F_{N-1} + \frac{1}{2}F_N \right) \; ,
 * \f]
 * where \f$F_k=F(kT/N)\f$ are the \f$N+1\f$ sample points of the integrand.  The
 * number of points is a compiled-in constant.  The error is on the order
 * of \f$F''T^2/N^2\f$, where \f$F''\f$ is the second derivative of \f$F(t)\f$ at
 * some point in the interval; we liberally estimate the error to be:
 * \f[
 * \sigma = \max_{k\in\{1,\ldots,N-1\}}
 * \left\{F_{k-1} - 2F_k + F_{k+1}\right\} \; .
 * \f]
 * Other more sophisticated integration techniques may be considered in
 * future.  To save on recomputing costs, the derivatives of \f$\tau\f$ at
 * all times are stored in a large vector sequence.
 */
void
LALCoherentMetric( LALStatus        *stat,
		   REAL8Vector      *metric,
		   REAL8Vector      *lambda,
		   MetricParamStruc *params )
{
  UINT4 s = 0;      /* The number of parameters. */
  UINT4 i, j, k, l; /* Indecies. */
  REAL8 dt;         /* The sampling interval, in s. */
  REAL8 f0;         /* The frequency scale, lambda->data[0]. */
  REAL8 *data;      /* Multipurpose pointer to vector data. */
  REAL8Vector *a=NULL;  /* Data for the first time average. */
  REAL8Vector *b=NULL;  /* Data for the second time average. */
  REAL8Vector *c=NULL;  /* Data for the third time average. */
  REAL8Vector d;        /* Temporary variable. */
  REAL8Vector *variables=NULL;    /* Input to time function. */
  REAL8VectorSequence *dSeq=NULL; /* Phase derivatives. */
  CreateVectorSequenceIn in; /* Input structure. */
  PulsarTimesParamStruc *constants; /* Timing constants. */

  INITSTATUS(stat);
  ATTATCHSTATUSPTR(stat);

  /* Make sure parameter structures and their fields exist. */
  ASSERT(metric,stat,STACKMETRICH_ENUL,STACKMETRICH_MSGENUL);
  ASSERT(metric->data,stat,STACKMETRICH_ENUL,STACKMETRICH_MSGENUL);
  ASSERT(lambda,stat,STACKMETRICH_ENUL,STACKMETRICH_MSGENUL);
  ASSERT(lambda->data,stat,STACKMETRICH_ENUL,STACKMETRICH_MSGENUL);
  ASSERT(params,stat,STACKMETRICH_ENUL,STACKMETRICH_MSGENUL);
  ASSERT(params->dtCanon,stat,STACKMETRICH_ENUL,STACKMETRICH_MSGENUL);

  /* Make sure parameters are valid. */
  s=lambda->length;
  ASSERT(s,stat,STACKMETRICH_EBAD,STACKMETRICH_MSGEBAD);
  if(params->errors)
  {
    ASSERT(metric->length==s*(s+1),stat,STACKMETRICH_EBAD,
	   STACKMETRICH_MSGEBAD);
  }
  else
  {
    ASSERT(metric->length==(s*(s+1))>>1,stat,STACKMETRICH_EBAD,
	   STACKMETRICH_MSGEBAD);
  }
  ASSERT(params->n==1,stat,STACKMETRICH_EBAD,
	 STACKMETRICH_MSGEBAD);

  /* Set vector sequence creation structure, and compute sampling
     rate. */
  in.vectorLength=s+1;
  in.length=COHERENTMETRICC_NPTS;
  dt=params->deltaT/(COHERENTMETRICC_NPTS-1.0);

  /* Create temporary storage. */
  TRY(LALDCreateVector(stat->statusPtr,&a,COHERENTMETRICC_NPTS),stat);
  LALDCreateVector(stat->statusPtr,&b,COHERENTMETRICC_NPTS);
  BEGINFAIL(stat)
    TRY(LALDDestroyVector(stat->statusPtr,&a),stat);
  ENDFAIL(stat);
  LALDCreateVector(stat->statusPtr,&c,COHERENTMETRICC_NPTS);
  BEGINFAIL(stat) {
    TRY(LALDDestroyVector(stat->statusPtr,&a),stat);
    TRY(LALDDestroyVector(stat->statusPtr,&b),stat);
  } ENDFAIL(stat);
  LALDCreateVectorSequence(stat->statusPtr,&dSeq,&in);
  BEGINFAIL(stat) {
    TRY(LALDDestroyVector(stat->statusPtr,&a),stat);
    TRY(LALDDestroyVector(stat->statusPtr,&b),stat);
    TRY(LALDDestroyVector(stat->statusPtr,&c),stat);
  } ENDFAIL(stat);
  LALDCreateVector(stat->statusPtr,&variables,s);
  BEGINFAIL(stat) {
    TRY(LALDDestroyVector(stat->statusPtr,&a),stat);
    TRY(LALDDestroyVector(stat->statusPtr,&b),stat);
    TRY(LALDDestroyVector(stat->statusPtr,&c),stat);
    TRY(LALDDestroyVectorSequence(stat->statusPtr,&dSeq),stat);
  } ENDFAIL(stat);

  /* Set up passing structure for the canonical time function. */
  memcpy(variables->data,lambda->data,s*sizeof(REAL8));
  *(variables->data)=params->start;
  f0=lambda->data[0];
  constants=params->constants;
  d.length=s+1;
  d.data=dSeq->data;
  l=COHERENTMETRICC_NPTS;

  /* Compute canonical time and its derivatives. */
  while(l--){
    (params->dtCanon)(stat->statusPtr,&d,variables,constants);
    BEGINFAIL(stat) {
      TRY(LALDDestroyVector(stat->statusPtr,&a),stat);
      TRY(LALDDestroyVector(stat->statusPtr,&b),stat);
      TRY(LALDDestroyVector(stat->statusPtr,&c),stat);
      TRY(LALDDestroyVectorSequence(stat->statusPtr,&dSeq),stat);
      TRY(LALDDestroyVector(stat->statusPtr,&variables),stat);
    } ENDFAIL(stat);
    *(variables->data)+=dt;
    d.data+=s+1;
  }

  /* Compute the overall correction factor to convert the canonical
     time interval into the detector time interval. */
#ifndef APPROXIMATE
  dt=params->deltaT/(dSeq->data[(s+1)*(COHERENTMETRICC_NPTS-1)]
		     - dSeq->data[0]);
#else
  dt=1.0;
#endif

  /* Compute metric components.  First generate the g00 component. */
  /* Fill integrand arrays. */
  data=dSeq->data+1;
  l=COHERENTMETRICC_NPTS;
  k=0;
  while(l--){
#ifndef APPROXIMATE
    a->data[l]=*data*data[-1]*data[-1];
    b->data[l]=c->data[l]=*data*data[-1];
#else
    a->data[l]=data[-1]*data[-1];
    b->data[l]=c->data[l]=data[-1];
#endif
    data+=s+1;
  }
  /* Integrate to get the metric component. */
  if(params->errors){
    REAL8 aErr=0,bErr=0,cErr=0;
    REAL8 aAvg=Average(a,&aErr);
    REAL8 bAvg=Average(b,&bErr);
    REAL8 cAvg=Average(c,&cErr);
    metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*(aAvg-dt*bAvg*cAvg);
    metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*
      (aErr + dt*bErr*fabs(cAvg) + dt*cErr*fabs(bAvg));
  }else
    metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*
      (Average(a,0)-dt*Average(b,0)*Average(c,0));

  for(i=1;i<s;i++){
    /* Now generate the gi0 components. */
    /* Fill integrand arrays. */
    data=dSeq->data+1;
    l=COHERENTMETRICC_NPTS;
    while(l--){
#ifndef APPROXIMATE
      a->data[l]=*data*data[-1]*f0*data[i];
      b->data[l]=*data*data[-1];
      c->data[l]=*data*f0*data[i];
#else
      a->data[l]=data[-1]*f0*data[i];
      b->data[l]=data[-1];
      c->data[l]=f0*data[i];
#endif
      data+=s+1;
    }
    /* Integrate to get the metric component. */
    if(params->errors){
      REAL8 aErr=0,bErr=0,cErr=0;
      REAL8 aAvg=Average(a,&aErr);
      REAL8 bAvg=Average(b,&bErr);
      REAL8 cAvg=Average(c,&cErr);
      metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*(aAvg-dt*bAvg*cAvg);
      metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*
	(aErr + dt*bErr*fabs(cAvg) + dt*cErr*fabs(bAvg));
    }else
      metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*
	(Average(a,0)-dt*Average(b,0)*Average(c,0));

    for(j=1;j<=i;j++){
      /* Now generate the gij components. */
      /* Fill integrand arrays. */
      data=dSeq->data+1;
      l=COHERENTMETRICC_NPTS;
      while(l--){
#ifndef APPROXIMATE
	a->data[l]=*data*f0*f0*data[i]*data[j];
	b->data[l]=*data*f0*data[i];
	c->data[l]=*data*f0*data[j];
#else
	a->data[l]=f0*f0*data[i]*data[j];
	b->data[l]=f0*data[i];
	c->data[l]=f0*data[j];
#endif
	data+=s+1;
      }
      /* Integrate to get the metric component. */
      if(params->errors){
	REAL8 aErr=0,bErr=0,cErr=0;
	REAL8 aAvg=Average(a,&aErr);
	REAL8 bAvg=Average(b,&bErr);
	REAL8 cAvg=Average(c,&cErr);
	metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*(aAvg-dt*bAvg*cAvg);
	metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*
	  (aErr + dt*bErr*fabs(cAvg) + dt*cErr*fabs(bAvg));
      }else
	metric->data[k++]=LAL_TWOPI*LAL_TWOPI*dt*
	  (Average(a,0)-dt*Average(b,0)*Average(c,0));
    }
  }

  /* Destroy temporary storage, and exit. */
  TRY(LALDDestroyVector(stat->statusPtr,&a),stat);
  TRY(LALDDestroyVector(stat->statusPtr,&b),stat);
  TRY(LALDDestroyVector(stat->statusPtr,&c),stat);
  TRY(LALDDestroyVectorSequence(stat->statusPtr,&dSeq),stat);
  TRY(LALDDestroyVector(stat->statusPtr,&variables),stat);
  DETATCHSTATUSPTR(stat);
  RETURN(stat);
}
void VideoFluids::trackVelocity(Matrix& Zn1,Matrix& Zn,Matrix& U,Matrix& V)
{
	Matrix Zx(height,width),Zy(height,width),ZZx(height,width),ZZy(height,width),Zt(height,width),ZZt(height,width),ZZtx(height,width),ZZty(height,width);
	Matrix Au1(height,width),Au2(height,width),Av1(height,width),Av2(height,width);
	Matrix Z2x(height,width),Z2y(height,width),Z2(height,width);
	Matrix Cu(height,width),Cv(height,width);
	Matrix tmp(height,width),tmp1(height,width);
	Matrix U_old(height,width),V_old(height,width),Ux(height,width),Uy(height,width),Vx(height,width),Vy(height,width),Uax(height,width),Uay(height,width),Vax(height,width),Vay(height,width),Uxy(height,width),Vxy(height,width);
	Matrix Coe(height,width);

	Zt = Zn;
	Zt -= Zn1;
	DotMul(Zn,Zt,ZZt);
	Zn.output("Zn.txt");
	Zn1.output("Zn1.txt");
	Zt.output("Zt.txt");
	Partial(ZZt,ZZtx,AXIS_X);
	Partial(ZZt,ZZty,AXIS_Y);
	Partial(Zn,Zx,AXIS_X);
	Partial(Zn,Zy,AXIS_Y);
	DotMul(Zn,Zx,ZZx);
	DotMul(Zn,Zy,ZZy);
	DotMul(Zx,Zx,Au1);
	Partial(ZZx,tmp,AXIS_X);
	Au1-=tmp;
	DotMul(Zn,Zn,tmp);
	Au1+=tmp;
	Au1+=2*alpha*alpha;
	DotMul(Zx,Zy,Au2);
	Partial(ZZy,tmp,AXIS_X);
	Au2-=tmp;
	DotMul(Zx,Zy,Av1);
	Partial(ZZx,tmp,AXIS_Y);
	Av1-=tmp;
	DotMul(Zy,Zy,Av2);
	Partial(ZZy,tmp,AXIS_Y);
	Av2-=tmp;
	DotMul(Zn,Zn,tmp);
	Av2+=tmp;
	Av2+=2*alpha*alpha;
	DotMul(Zn,Zn,Z2);
	Partial(Z2,Z2x,AXIS_X);
	Partial(Z2,Z2y,AXIS_Y);
	for (int i = 0;i<height;i++)
		for (int j = 0;j<width;j++)
			Coe[i][j] = 1.0/(Au1[i][j]*Av2[i][j]-Au2[i][j]*Av1[i][j]);

	U = 0.0;
	V = 0.0;
	for (int iter_time = 0;iter_time<iterationTime;iter_time++)
	{
		V_old = V;
		U_old = U;
		Partial(U,Ux,AXIS_X);
		Partial(U,Uy,AXIS_Y);
		Partial(V,Vx,AXIS_X);
		Partial(V,Vy,AXIS_Y);
		Partial(Vx,Vxy,AXIS_Y);
		Partial(Ux,Uxy,AXIS_Y);
		Average(U,Uax,AXIS_X);
		Average(U,Uay,AXIS_Y);
		Average(V,Vax,AXIS_X);
		Average(V,Vay,AXIS_Y);
		DotMul(Z2x,Ux,Cu);
		DotMul(ZZy,Vx,tmp);
		Cu += tmp;
		tmp = ZZx*-1;
		tmp+=Z2x;
		DotMul(tmp,Vy,tmp1);
		Cu+=tmp1;
		tmp = Z2;
		tmp+=alpha*alpha;
		DotMul(tmp,Uax,tmp1);
		Cu+=tmp1;
		tmp1=Uay;
		tmp1*=alpha*alpha;
		Cu+=tmp1;
		DotMul(Z2,Vxy,tmp1);
		Cu+=tmp1;
		DotMul(Zx,Zt,tmp);
		Cu-=tmp;
		Cu+=ZZtx;


		DotMul(Z2y,Vy,Cv);
		DotMul(ZZx,Uy,tmp);
		Cv += tmp;
		tmp = ZZy;
		tmp*=-1;
		tmp+=Z2y;
		DotMul(tmp,Ux,tmp1);
		Cv+=tmp1;
		tmp = Z2;
		tmp+=alpha*alpha;
		DotMul(tmp,Vay,tmp1);
		Cv+=tmp1;
		tmp1=Vax;
		tmp1*=alpha*alpha;
		Cv+=tmp1;
		DotMul(Z2,Uxy,tmp1);
		Cv+=tmp1;
		DotMul(Zy,Zt,tmp);
		Cv-=tmp;
		Cv+=ZZty;
		for (int i = 0;i<height;i++)
			for (int j = 0;j<width;j++)
			{
				U[i][j] = Coe[i][j]*(Av2[i][j]*Cu[i][j]-Au2[i][j]*Cv[i][j]);
				V[i][j] = Coe[i][j]*(-Av1[i][j]*Cu[i][j]+Au1[i][j]*Cv[i][j]);
			}	
		for (int i = 0;i<height;i++)
		{
			U[i][0] = U[i][1];
			U[i][width-1] = U[i][width-2];
			V[i][0] = V[i][1];
			V[i][width-1] =V[i][width-2];
		}
		for (int i = 0;i<width;i++)
		{
			U[0][i] = U[1][i];
			U[height-1][i] = U[height-2][i];
			V[0][i] = V[1][i];
			V[height-1][i] =V[height-2][i];
		}
		FILE* fp;
// 		Au1.output("Au1.txt");
// 		Au2.output("Au2.txt");
// 		Av1.output("Av1.txt");
// 		Av2.output("Av2.txt");
// 		Cu.output("Cu.txt");
// 		Cv.output("Cv.txt");
		float d1 = Difference(U,U_old);
		float d2 = Difference(V,V_old);
// 		U.output("U.txt");
// 		U_old.output("U_old.txt");
// 		V.output("V.txt");
		cout<<d1<<' '<<d2<<endl;
		if (d1<iterationTorlerance && d2<iterationTorlerance)
			break;
	}
	U.output("U.txt");
	
		cv::Mat showV(height,width,CV_8UC3);
		float lowv=10000000,lowu=10000000,highu=-10000000,highv=-1000000;
		for(int j=0;j<height;j++){
			for(int k=0;k<width;k++){
				if(U[j][k]>highu)
					highu=U[j][k];
				if(U[j][k]<lowu)
					lowu=U[j][k];
				if(V[j][k]>highv)
					highv=V[j][k];
				if(V[j][k]<lowv)
					lowv=V[j][k];
			}
		}
		for(int j=0;j<height;j++){
			for(int k=0;k<width;k++){
				//printf("%d %d\n",j,k);
				//if(sfs_list[i][j][k]<low)
				//	showH.at<uchar>(j,k)=0;
				//else
				float u=(U[j][k]-lowu)/(highu-lowu);
				float v=(V[j][k]-lowv)/(highv-lowv);
				if(u>0.5)
					showV.at<cv::Vec3b>(j,k)[2]=255;
				else
					showV.at<cv::Vec3b>(j,k)[2]=255*u;
				if(v>0.5){
					showV.at<cv::Vec3b>(j,k)[0]=255;
					showV.at<cv::Vec3b>(j,k)[1]=255*(1-v);
				}
				else{
					showV.at<cv::Vec3b>(j,k)[1]=255;
					showV.at<cv::Vec3b>(j,k)[0]=255*v;
				}
			}
		}
		cv::imwrite("testV.bmp",showV);
		printf("show you");
		

}