void
AppleUSBUHCI::UIMRootHubStatusChange(void)
{
    UInt8								bitmap, bit;
    unsigned int						i, index, move;
    IOUSBHubPortStatus					portStatus;
    
    USBLog(7, "AppleUSBUHCI[%p]::UIMRootHubStatusChange (_controllerAvailable: %d)", this, _controllerAvailable);

	if (_controllerAvailable && !_wakingFromHibernation)
	{
		// For UHCI, we first need to see if we have a pending resume
		RHCheckStatus();
		
		// Assume a byte can hold all port bits.
		assert(kUHCI_NUM_PORTS < 8);

		/*
		 * Encode the status change bitmap.  The format of the bitmap:
		 * bit0 = hub status changed
		 * bit1 = port 1 status changed
		 * bit2 = port 2 status changed
		 * ...
		 * See USB 1.0 spec section 11.8.3 for more info.
		 */

		bitmap = 0;
		bit = 0x2;
		for (i=1; i <= kUHCI_NUM_PORTS; i++) 
		{
			GetRootHubPortStatus(&portStatus, i);
			if (portStatus.changeFlags != 0) 
			{
				UInt64			elapsedTime;
				uint64_t		currentTime;
				
				USBLog(5, "AppleUSBUHCI[%p]::UIMRootHubStatusChange  Port %d hub flags:", this, i);
				RHDumpHubPortStatus(&portStatus);

				bitmap |= bit;
				
				// If this port has seen a recovery attempt (see below) already, check to see what the current time is and if it's > than 2 seconds since the port recovery, then 'forget" about it
				currentTime = mach_absolute_time();
				SUB_ABSOLUTETIME(&currentTime, &_portRecoveryTime[i-1] );
				absolutetime_to_nanoseconds(*(AbsoluteTime *)&currentTime, &elapsedTime);
				elapsedTime /= 1000000000;									// Convert to seconds from nanoseconds
				
				if ( _previousPortRecoveryAttempted[i-1] && (elapsedTime >= kUHCITimeoutForPortRecovery) )
				{
					USBLog(2, "AppleUSBUHCI[%p]::UIMRootHubStatusChange  Forgetting about our portRecovery state since the last change occurred %qd seconds ago", this, elapsedTime);
					_previousPortRecoveryAttempted[i-1] = false;
				}
				
				//  If this port has a PED (port enable change) AND the current status is PortPower and Port Connection (which indicates that a condition
				//  on the bus caused the controller to disable the port) then we need to see if we should attempt to re-enable the port w/out calling the
				//  hub driver.  We will do this ONLY if the previous root hub status change for this port did NOT attempt this recovery -- we only try once
				
				if ( !_previousPortRecoveryAttempted[i-1] )
				{
					USBLog(7, "AppleUSBUHCI[%p]::UIMRootHubStatusChange  Port %d had a change: 0x%x", this, i, portStatus.changeFlags);
					if ( !(portStatus.statusFlags & kHubPortEnabled)				// if we are not presently enabled
						&& (portStatus.changeFlags & kHubPortEnabled)				// and we were previously enabled
						&& (portStatus.statusFlags & kHubPortConnection)			// and we are presently connected
						&& !(portStatus.changeFlags & kHubPortConnection)			// and the connection has not recently changed (i.e. quick disconnect-connect)
						&& (portStatus.statusFlags & kHubPortPower) )				// and the power is on
					{
						// Indicate that we are attempting a recovery
						_previousPortRecoveryAttempted[i-1] = true;
						currentTime = mach_absolute_time();
						_portRecoveryTime[i-1] = *(AbsoluteTime*)&currentTime;
						
						USBLog(1, "AppleUSBUHCI[%p]::UIMRootHubStatusChange  Port %d attempting to enable a disabled port to work around a fickle UHCI controller", this, i);
						USBTrace( kUSBTUHCI, kTPUHCIRootHubStatusChange, (uintptr_t)this, portStatus.statusFlags, portStatus.changeFlags, i );
						
						RHEnablePort(i, true);
						
						// Clear the bitmap
						bitmap &= ~bit;
					}
				}
				else
				{
					// If this is just the notification that the port has been enabled, then don't reset our previousPortRecoveryAttempt
					if ( (portStatus.changeFlags & kHubPortEnabled) and (portStatus.statusFlags & kHubPortConnection) and (portStatus.statusFlags & kHubPortPower) and (portStatus.statusFlags & kHubPortEnabled) )
					{
						USBLog(2, "AppleUSBUHCI[%p]::UIMRootHubStatusChange  Port %d had a change but it's just the port enabled notification", this, i);
					}
					else
					{
						USBLog(2, "AppleUSBUHCI[%p]::UIMRootHubStatusChange  Port %d had a change but last time we attempted a recovery, so not attempting again", this, i);
						_previousPortRecoveryAttempted[i-1] = false;
					}
				}
			}
			
			bit <<= 1;

			// Don't clear status bits until explicitly told to.

		}
		if (bitmap)
		{
			USBLog(5, "AppleUSBUHCI[%p]::UIMRootHubStatusChange  RH status bitmap = %x",  this, bitmap);
		}
		_rootHubStatusChangedBitmap = bitmap;
	}
    
    // Bitmap is only one byte, so it doesn't need swapping.
}
Example #2
0
bool korting::inDate(const std::string &startdate, const std::string &enddate){
    int start[3];
    int end[3];
    
    start[0] = fromStringtoDate(startdate)[0];
    start[1] = fromStringtoDate(startdate)[1];
    start[2] = fromStringtoDate(startdate)[2];
    
    
    end[0] = fromStringtoDate(enddate)[0];
    end[1] = fromStringtoDate(enddate)[1];
    end[2] = fromStringtoDate(enddate)[2];
    
    if(((end[2] >= startDate[2]) and (startDate[2] >= start[2])) or
       ((end[2] >= endDate[2]) and (endDate[2] >= start[2])) or
       ((end[2] >= endDate[2]) and (startDate[2] >= start[2])) or
       ((endDate[2] >= end[2]) and (start[2] >= startDate[2]))){
        if(((end[1] >= startDate[1]) and (startDate[1] >= start[1])) or
           ((end[1] >= endDate[1]) and (endDate[1] >= start[1])) or
           ((end[1] >= endDate[1]) and (startDate[1] >= start[1])) or
           ((endDate[1] >= end[1]) and (start[1] >= startDate[1]))){
            if(((end[0] >= startDate[0]) and (startDate[0] >= start[0])) or
               ((end[0] >= endDate[0]) and (endDate[0] >= start[0])) or
               ((end[0] >= endDate[0]) and (startDate[0] >= start[0])) or
               ((endDate[0] >= end[0]) and (start[0] >= startDate[0]))){
                return true;
            }
        }
    }

    return false;
}
Example #3
0
int Interpret(int, char* [])
{
  MockDb db = {};
  MockDb::_serializer_context_t printer = {};

  const auto f = test::TabFoo{};
  const auto t = test::TabBar{};
  select(t.alpha.as(t.beta));

  serialize(insert_into(t).columns(t.beta, t.gamma), printer).str();
  {
    auto i = insert_into(t).columns(t.gamma, t.beta);
    i.values.add(t.gamma = true, t.beta = "cheesecake");
    serialize(i, printer).str();
    i.values.add(t.gamma = false, t.beta = sqlpp::tvin("coffee"));
    i.values.add(t.gamma = false, t.beta = sqlpp::tvin(std::string()));
    serialize(i, printer).str();
    i.values.add(t.gamma = sqlpp::default_value, t.beta = sqlpp::null);
    serialize(i, printer).str();
  }

  serialize(t.alpha = sqlpp::null, printer).str();
  serialize(t.alpha = sqlpp::default_value, printer).str();
  serialize(t.alpha, printer).str();
  serialize(-t.alpha, printer).str();
  serialize(+t.alpha, printer).str();
  serialize(-(t.alpha + 7), printer).str();
  serialize(t.alpha = 0, printer).str();
  serialize(t.alpha = sqlpp::tvin(0), printer).str();
  serialize(t.alpha == 0, printer).str();
  serialize(t.alpha == sqlpp::tvin(0), printer).str();
  serialize(t.alpha != 0, printer).str();
  serialize(t.gamma != sqlpp::tvin(false), printer).str();
  serialize(t.alpha == 7, printer).str();
  serialize(t.delta = sqlpp::tvin(0), printer).str();
  serialize(t.beta + "kaesekuchen", printer).str();

  serialize(sqlpp::select(), printer).str();
  serialize(sqlpp::select().flags(sqlpp::distinct), printer).str();
  serialize(select(t.alpha, t.beta).flags(sqlpp::distinct), printer).str();
  serialize(select(t.alpha, t.beta), printer).str();
  serialize(select(t.alpha, t.beta).from(t), printer).str();
  serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3), printer).str();
  serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma), printer).str();
  serialize(select(t.alpha, t.beta).from(t).where(t.alpha == 3).group_by(t.gamma).having(t.beta.like("%kuchen")),
            printer).str();
  serialize(select(t.alpha, t.beta)
                .from(t)
                .where(t.alpha == 3)
                .group_by(t.gamma)
                .having(t.beta.like("%kuchen"))
                .order_by(t.beta.asc()),
            printer).str();
  serialize(select(t.alpha, t.beta)
                .from(t)
                .where(t.alpha == 3)
                .group_by(t.gamma)
                .having(t.beta.like("%kuchen"))
                .order_by(t.beta.asc())
                .limit(17)
                .offset(3),
            printer).str();

  serialize(parameter(sqlpp::bigint(), t.alpha), printer).str();
  serialize(parameter(t.alpha), printer).str();
  serialize(t.alpha == parameter(t.alpha), printer).str();
  serialize(t.alpha == parameter(t.alpha) and (t.beta + "gimmick").like(parameter(t.beta)), printer).str();

  serialize(insert_into(t), printer).str();
  serialize(insert_into(f).default_values(), printer).str();
  serialize(insert_into(t).set(t.gamma = true), printer).str();
  // serialize(insert_into(t).set(t.gamma = sqlpp::tvin(false)), printer).str(); cannot test this since gamma cannot be
  // null and a static assert is thrown

  serialize(update(t), printer).str();
  serialize(update(t).set(t.gamma = true), printer).str();
  serialize(update(t).set(t.gamma = true).where(t.beta.in("kaesekuchen", "cheesecake")), printer).str();
  serialize(update(t).set(t.gamma = true).where(t.beta.in()), printer).str();

  serialize(remove_from(t), printer).str();
  serialize(remove_from(t).using_(t), printer).str();
  serialize(remove_from(t).where(t.alpha == sqlpp::tvin(0)), printer).str();
  serialize(remove_from(t).using_(t).where(t.alpha == sqlpp::tvin(0)), printer).str();

  // functions
  serialize(sqlpp::value(7), printer).str();
  serialize(sqlpp::verbatim<sqlpp::integral>("irgendwas integrales"), printer).str();
  serialize(sqlpp::value_list(std::vector<int>({1, 2, 3, 4, 5, 6, 8})), printer).str();
  serialize(exists(select(t.alpha).from(t)), printer).str();
  serialize(any(select(t.alpha).from(t)), printer).str();
  serialize(some(select(t.alpha).from(t)), printer).str();
  serialize(count(t.alpha), printer).str();
  serialize(min(t.alpha), printer).str();
  serialize(max(t.alpha), printer).str();
  serialize(avg(t.alpha), printer).str();
  serialize(sum(t.alpha), printer).str();
  serialize(sqlpp::verbatim_table("whatever"), printer).str();

  // alias
  serialize(t.as(t.alpha), printer).str();
  serialize(t.as(t.alpha).beta, printer).str();

  // select alias
  serialize(select(t.alpha).from(t).where(t.beta > "kaesekuchen").as(t.gamma), printer).str();

  serialize(t.alpha.is_null(), printer).str();

  // join
  serialize(t.inner_join(t.as(t.alpha)).on(t.beta == t.as(t.alpha).beta), printer).str();
  {
    auto inner = t.inner_join(t.as(t.alpha)).on(t.beta == t.as(t.alpha).beta);
    serialize(select(t.alpha).from(inner), printer).str();
  }

  // multi_column
  serialize(multi_column(t.alpha, (t.beta + "cake").as(t.gamma)).as(t.alpha), printer).str();
  serialize(multi_column(all_of(t)).as(t), printer).str();
  serialize(all_of(t).as(t), printer).str();

  // dynamic select
  {
    auto s = dynamic_select(db).dynamic_flags().dynamic_columns().from(t);
    s.selected_columns.add(t.beta);
    s.selected_columns.add(t.gamma);
    serialize(s, printer).str();
  }
  {
    auto s = dynamic_select(db).dynamic_flags().dynamic_columns().from(t);
    s.select_flags.add(sqlpp::distinct);
    s.selected_columns.add(t.beta);
    s.selected_columns.add(t.gamma);
    serialize(s, printer).str();
  }
  {
    // Behold, dynamically constructed queries might compile but be illegal SQL
    auto s = dynamic_select(db).dynamic_flags(sqlpp::distinct).dynamic_columns(t.alpha);
    s.select_flags.add(sqlpp::all);
    s.selected_columns.add(without_table_check(t.beta));
    s.selected_columns.add(without_table_check(t.gamma));
    serialize(s, printer).str();
  }

  // distinct aggregate
  serialize(count(sqlpp::distinct, t.alpha % 7), printer).str();
  serialize(avg(sqlpp::distinct, t.alpha - 7), printer).str();
  serialize(sum(sqlpp::distinct, t.alpha + 7), printer).str();

  serialize(select(all_of(t)).from(t).unconditionally(), printer).str();

  for (const auto& row : db(select(all_of(t)).from(t).unconditionally()))
  {
    serialize(row.alpha, printer);
    serialize(row.beta, printer);
    serialize(row.gamma, printer);
  }

  get_sql_name(t);
  get_sql_name(t.alpha);

  flatten(t.alpha == 7, db);

  auto x = boolean_expression(db, t.alpha == 7);
  x = sqlpp::boolean_expression<MockDb>(t.beta.like("%cheesecake"));
  x = x and boolean_expression(db, t.gamma);
  std::cerr << "----------------------------" << std::endl;
  printer.reset();
  std::cerr << serialize(x, printer).str() << std::endl;

  printer.reset();
  std::cerr << serialize(select(all_of(t)).from(t).where(t.alpha.in(select(f.epsilon).from(f).unconditionally())),
                         printer).str() << std::endl;

  printer.reset();
  std::cerr << serialize(select(all_of(t)).from(t).where(t.alpha.in()), printer).str() << std::endl;

  printer.reset();
  std::cerr << serialize(select(all_of(t)).from(t).where(t.alpha.not_in()), printer).str() << std::endl;

  auto schema = db.attach("lorem");
  auto s = schema_qualified_table(schema, t).as(sqlpp::alias::x);

  printer.reset();
  std::cerr << serialize(select(all_of(s)).from(s).unconditionally(), printer).str() << std::endl;

  printer.reset();
  std::cerr << serialize(sqlpp::case_when(true).then(t.alpha).else_(t.alpha + 1).as(t.beta), printer).str()
            << std::endl;

  return 0;
}
void RecursiveFilter::getAnisotropicFilterCoefficients(const double* tau, const int& arr)
{
	double sigma = (lengthScale*lengthScale)/2;
	double b[5][5];
	
	// Extend the arrLength for the Cholesky decomp?
	int arrLength = arr;
	double* htau = new double[arrLength];
	for (int i=0; i< arrLength-1; i++) {
		htau[i] = (tau[i+1] + tau[i])/2;
		std::cout << htau[i] << std::endl;
	}
	double** K1 = new double*[arrLength];
	double** K2 = new double*[arrLength];
	double** K3 = new double*[arrLength];
	double** K4 = new double*[arrLength];
	double** D = new double*[arrLength];
	double** sqv = new double*[arrLength];
	for (int i=0; i<arrLength;i++) {
		K1[i] = new double[arrLength];
		K2[i] = new double[arrLength];
		K3[i] = new double[arrLength];
		K4[i] = new double[arrLength];
		D[i] = new double[arrLength];
		sqv[i] = new double[arrLength];
	}
	double* p= new double[arrLength];
	abeta = new double[arrLength];
	
	for (int a = 1; a <5; a++) {
		aalpha[a] = new double[arrLength];
	}
	
	double coeff[5];
	
	// b coefficients
	b[1][1] = 1;
	b[1][2] = 1./12.;
	b[1][3] = 1./90.;
	b[1][4] = 1./560.;
	b[2][2] = 1.;
	b[2][3] = 1./6.;
	b[2][4] = 7./240.;
	b[3][3] = 1.;
	b[3][4] = 1./4.;
	b[4][4] = 1;
	
    // Compute polynomial coefficients
	coeff[1] = b[1][1]*sigma;
	coeff[2] = b[1][2]*sigma + b[2][2]*(pow(sigma,2))/factorial(2);
	coeff[3] = b[1][3]*sigma + b[2][3]*(pow(sigma,2))/factorial(2)
	+ b[3][3]*(pow(sigma,3))/factorial(3);
	coeff[4] = b[1][4]*sigma + b[2][4]*(pow(sigma,2))/factorial(2)
	+ b[3][4]*(pow(sigma,3))/factorial(3) + b[4][4]*(pow(sigma,4))/factorial(4);
	
	// Set up K
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			K1[i][j] = 0.;
			sqv[i][j] = 0.;
		}
		
		/*if (i > 0) K1[i][i-1] = -(sigma*(tau[i-1]+tau[i])/2)/sqrt(sigma*tau[i]*sigma*tau[i-1]);
		if ((i > 0) and (i<(arrLength-1)))
			K1[i][i] = ((sigma*(tau[i-1]+tau[i])/2) + (sigma*(tau[i+1]+tau[i])/2))/(sigma*tau[i]);
		if (i<(arrLength-1)) K1[i][i+1] = -(sigma*(tau[i+1]+tau[i])/2)/sqrt(sigma*tau[i]*sigma*tau[i+1]);
		sqv[i][i] = sqrt(tau[i]); */
		
		if (i > 1) {
			K1[i][i-1] = -(sigma*(tau[i]-tau[i-1]))/sqrt(sigma*(htau[i]-htau[i-1])*sigma*(htau[i-1]-htau[i-2]));
		} else if (i == 1) {
			K1[i][i-1] = -(sigma*(tau[i]-tau[i-1]))/sqrt(sigma*(htau[i]-htau[i-1])*sigma*(htau[i-1]+htau[i-1]));
		}
		if ((i > 0) and (i<(arrLength-1)))
			K1[i][i] = (sigma*(tau[i]-tau[i-1]) + sigma*(tau[i+1]-tau[i]))/(sigma*(htau[i]-htau[i-1]));
		if (i<(arrLength-2)) {
			K1[i][i+1] = -(sigma*(tau[i+1]-tau[i]))/sqrt(sigma*(htau[i]-htau[i-1])*sigma*(htau[i+1]-htau[i]));
		} else {
			K1[i][i+1] = -(sigma*(tau[i]-tau[i-1]))/sqrt(sigma*(htau[i]-htau[i-1])*sigma*(htau[i]-htau[i-1]));
		}
		if (i == 0) {
			sqv[i][i] = sqrt(htau[i]*2);
		} else if (i == (arrLength-1)) {
			sqv[i][i] = sqrt(htau[i-1]*2);
		} else {
			sqv[i][i] = sqrt(htau[i]-htau[i-1]);
		}
	}
	K1[0][0] = 2.;
	K1[0][1] = K1[1][0];
	K1[arrLength-1][arrLength-1] = 2;
	K1[arrLength-1][arrLength-2] = K1[arrLength-2][arrLength-1];
	sqv[arrLength-1][arrLength-1] = sqv[arrLength-2][arrLength-2];
	// Square it
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			K2[i][j] = 0;
		}
	}
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			for (int r=0; r< arrLength; r++) {
				K2[i][j] += K1[i][r]*K1[r][j];
			}
		}
	}
	
	// Cube it
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			K3[i][j] = 0;

		}
	}
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			for (int r=0; r< arrLength; r++) {
				K3[i][j] += K1[i][r]*K2[r][j];
			}
		}
	}
	
	// 4th it
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			K4[i][j] = 0;
		}
	}
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			for (int r=0; r< arrLength; r++) {
				K4[i][j] += K1[i][r]*K3[r][j];
			}
		}
	}
	
	// 4th it
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			K4[i][j] = 0;
		}
	}
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			for (int r=0; r< arrLength; r++) {
				K4[i][j] += K1[i][r]*K3[r][j];
			}
		}
	}
	
	// Now calculate D
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			D[i][j] = coeff[1]*K1[i][j] + coeff[2]*K2[i][j] + coeff[3]*K3[i][j] + coeff[4]*K4[i][j];
			//std::cout << D[i][j] << " ";
		}
		//std::cout << std::endl;
	}
	
	// Get the filter coefficients
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			if (K1[i][j] != 0)
				std::cout << K1[i][j] << "\t";
		}
		std::cout << std::endl;
	}	
	
	// Cholesky decomp
	for (int i=0;i<arrLength;i++) {
		for (int j=i;j<arrLength;j++) {
			double sum=D[i][j];
			for (int k=i-1;k>=0;k--) {
				sum -= D[i][k]*D[j][k];
			}
			if (i == j) {
				if (sum <= 0.0) { 
					std::cout << "cholesky failed at i,j sum\n";
					break;
				} else {
					p[i] = sqrt(sum);
				}
			} else {
				D[j][i]=sum/p[i];
				if (p[i] == 0.) { 
					std::cout << "Problem! " << i << "\t" << j << "\n";
				}
			}
		}
	}
	
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			if (D[i][j] != 0)
				std::cout << D[i][j] << "\t";
		}
		std::cout << std::endl;
	}	
	
	
	/* Multiply by sqv (reuse K1)
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			K1[i][j] = 0.;
		}
	}
	
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			for (int r=0; r< arrLength; r++) {
				K1[i][j] += D[i][r]*sqv[r][j];
			}
		}
	}
	
	// Multiply by 1/sqv (reuse K1)
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			D[i][j] = 0.;
			if (i == 0) {
				sqv[i][i] = 1/sqrt(htau[i]*2);
			} else if (i == (arrLength-1)) {
				sqv[i][i] = 1/sqrt(htau[i-1]*2);
			} else {
				sqv[i][i] = 1/sqrt(htau[i]-htau[i-1]);
			}
		}
	}
	sqv[arrLength-1][arrLength-1] = sqv[arrLength-2][arrLength-2];
	
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			for (int r=0; r< arrLength; r++) {
				D[i][j] += sqv[i][r]*K1[r][j];
			}
		}
	} */
	
	
	for (int i=0; i<arrLength; i++) {
		for (int j=0; j<arrLength; j++) {
			if (D[i][j] != 0)
			std::cout << D[i][j] << "\t";
		}
		std::cout << std::endl;
	}
	abeta[0]= 1/p[0];
	aalpha[1][0]=0;
	aalpha[2][0]=0;
	aalpha[3][0]=0;
	aalpha[4][0]=0;
	std::cout << "0\t" << abeta[0]<< "\t" << aalpha[1][0] << "\t" << aalpha[2][0] << "\t" 
	<< aalpha[3][0] << "\t" << aalpha[4][0]  << "\t(" << abeta[0] + aalpha[1][0] + aalpha[2][0] + aalpha[3][0] + aalpha[4][0] << ")\n";
		
	abeta[1]= 1/p[1];
	aalpha[1][1]=-abeta[1]*D[1][0];
	aalpha[2][1]=0;
	aalpha[3][1]=0;
	aalpha[4][1]=0;
	std::cout << "1\t" << abeta[1]<< "\t" << aalpha[1][1] << "\t" << aalpha[2][1] << "\t" 
	<< aalpha[3][1] << "\t" << aalpha[4][1]  << "\t(" << abeta[1] + aalpha[1][1] + aalpha[2][1] + aalpha[3][1] + aalpha[4][1] << ")\n";
	
	abeta[2]= 1/p[2];	
	aalpha[1][2]=-abeta[2]*D[2][1];
	aalpha[2][2]=-abeta[2]*D[2][0];
	aalpha[3][2]=0;
	aalpha[4][2]=0;
	std::cout << "2\t" << abeta[2]<< "\t" << aalpha[1][2] << "\t" << aalpha[2][2] << "\t" 
	<< aalpha[3][2] << "\t" << aalpha[4][2]  << "\t(" << abeta[2] + aalpha[1][2] + aalpha[2][2] + aalpha[3][2] + aalpha[4][2] << ")\n";
	
	abeta[3]= 1/p[3];
	aalpha[1][3]=-abeta[2]*D[3][2];
	aalpha[2][3]=-abeta[2]*D[3][1];
	aalpha[3][3]=-abeta[2]*D[3][0];
	aalpha[4][3]=0;
	std::cout << "3\t" << abeta[3]<< "\t" << aalpha[1][3] << "\t" << aalpha[2][3] << "\t" 
	<< aalpha[3][3] << "\t" << aalpha[4][3]  << "\t(" << abeta[3] + aalpha[1][3] + aalpha[2][3] + aalpha[3][3] + aalpha[4][3] << ")\n";

	for (int i=4;i<arrLength;i++) {
		abeta[i] = 1/p[i];
		aalpha[1][i]=-abeta[i]*D[i][i-1];
		aalpha[2][i]=-abeta[i]*D[i][i-2];
		aalpha[3][i]=-abeta[i]*D[i][i-3];
		aalpha[4][i]=-abeta[i]*D[i][i-4];
		double sum = abeta[i] + aalpha[1][i] + aalpha[2][i] + aalpha[3][i] + aalpha[4][i];
		std::cout << i<< "\t" << abeta[i]<< "\t" << aalpha[1][i] << "\t" << aalpha[2][i] << "\t" 
		<< aalpha[3][i] << "\t" << aalpha[4][i]  << "\t(" << sum << ")\n";
	}
	
	// Boundary conditions
	double L[5][5];
	double U[5][5];
	double LT[5][5];
	double UT[5][5];
	double LI[5][5];
	double col[5];
	double colinv[5];
	
	for (int i=1;i<=order;i++) {
		for (int j=1;j<=order;j++) {
			L[i][j]=0.;
			U[i][j]=0.;
		}
	}
	
	for (int i=1;i<=order;i++) {
		for (int j=0;j<=order;j++) {
			int index = i+j;
			if (index <= order) {
				L[i+j][i] = -aalpha[i+j][arr-1];
				U[i][i+j] = aalpha[order-j][arr-1];
			}
		}
		L[i][i] = 1.;
	}
	
	// Invert L
	for (int j=1;j<=order;j++) {
		for (int i=1;i<=order;i++) { col[i] = 0.0; }
		col[j] = 1;
		colinv[0] = col[0];
		for (int i=1;i<=order;i++) {
			colinv[i] = col[i];
			for (int k=i-1;k>=1;k--) {
				colinv[i] -= L[i][k]*colinv[k];
			}
		}
		for (int i=1;i<=order;i++) {
			LI[i][j] = colinv[i];
		}
	}
	
	// Transpose L & T
	for (int i=1;i<=order;i++) {
		for (int j=1;j<=order;j++) {
			LT[i][j] = L[j][i];
			UT[i][j] = U[j][i];
		}
	}
	
	// Get Sn matrix
	double tmp[5][5];
	double tmp2[5][5];
	for (int i=1;i<=order;i++) {
		for (int j=1;j<=order;j++) {
			tmp[i][j] = 0.;
			for (int k=1;k<=order;k++) {
				tmp[i][j] += UT[i][k]*LI[k][j];
			}
		}
	}
	for (int i=1;i<=order;i++) {
		for (int j=1;j<=order;j++) {
			tmp2[i][j] = 0.;
			for (int k=1;k<=order;k++) {
				tmp2[i][j] += tmp[i][k]*U[k][j];
			}
		}
	}
	
	for (int i=1;i<=order;i++) {
		for (int j=1;j<=order;j++) {
			Sn[i-1][j-1] = (LT[i][j] - tmp2[i][j])/beta;
		}
	}
	
	for (int i=0; i<arrLength;i++) {
		delete[] K1[i];
		delete[] K2[i];
		delete[] K3[i];
		delete[] K4[i]; 
		delete[] D[i];
		delete[] sqv[i];
	}
	delete[] tau;
	delete[] K1;
	delete[] K2;
	delete[] K3;
	delete[] K4; 
	delete[] D;
	delete[] sqv;
	delete[] p;
	
}
Example #5
0
bool EnergyWindowTest::test(Array<double> &trial_coords, double trial_energy,
    Array<double> & old_coords, double old_energy, double temperature, 
    MC * mc)
{
    return ((trial_energy >= _min_energy) and (trial_energy <= _max_energy));
}
Example #6
0
void
TranzportClient::readData()
{
    memcpy(previousbuf, currentbuf, 8);
    ssize_t val;
    static timeT loop_start_time=0;
    static timeT loop_end_time=0;

    while ((val=read(m_descriptor,currentbuf,8)) == 8) {
        uint32_t new_buttons = current_buttons ^ previous_buttons;
        if (status == 0x1) {
            RG_DEBUG << "TranzportClient: device just came online";

            while (not commands.empty()) {
                commands.pop();
            }
            device_online = true;

            m_rgDocument = m_rgGUIApp->getDocument();
            m_composition = &m_rgGUIApp->getDocument()->getComposition();
            stateUpdate();
        }

        if (status == 0xff) {
            RG_DEBUG << "TranzportClient: device just went offline";

            device_online = false;
            return;
        }

        if (new_buttons & TrackSolo  and
            current_buttons & TrackSolo) {
            if (current_buttons & Shift) {
                bool soloflag = m_composition->isSolo();
                emit solo(not soloflag);
            }
        }

        if (new_buttons & Add  and
            current_buttons & Add) {
            if (current_buttons & Shift) {
            } else {
                AddMarkerCommand* cmd = new AddMarkerCommand(m_composition,
                                                             m_composition->getPosition(),
                                                             "tranzport",
                                                             "");
                CommandHistory::getInstance()->addCommand(cmd);
            }
        }

        if (new_buttons & Prev  and
            current_buttons & Prev) {
            RG_DEBUG << "TranzportClient:: received marker previous";

            if (current_buttons & Shift) {
            } else {
                timeT currentTime = m_composition->getPosition();
                Composition::markercontainer& mc = m_composition->getMarkers();
                timeT closestPrevious = -1;

                for (Composition::markerconstiterator it = mc.begin();
                     it != mc.end();
                     ++it) {
                    timeT markerTime = (*it)->getTime();
                    if (markerTime < currentTime  and
                        markerTime > closestPrevious) {
                        closestPrevious = markerTime;
                    }
                }

                if (closestPrevious >= 0) {
                    RG_DEBUG << "Tranzport:: setting position: " << closestPrevious;

                    emit setPosition(closestPrevious);
                }
            }
        }

        if (new_buttons & Next  and
            current_buttons & Next)
        {
            RG_DEBUG << "TranzportClient:: received marker next";

            if (current_buttons & Shift) {
            } else {
                timeT currentTime = m_composition->getPosition();
                Composition::markercontainer& mc = m_composition->getMarkers();
                timeT closestNext = std::numeric_limits<long>::max();
                
                for (Composition::markerconstiterator it = mc.begin();
                     it != mc.end();
                     ++it) {
                    timeT markerTime = (*it)->getTime();
                    if (markerTime > currentTime and
                        markerTime < closestNext) {
                        closestNext = markerTime;
                    }
                }

                if (closestNext < std::numeric_limits<long>::max()) {
                    RG_DEBUG << "Tranzport:: setting position: " << closestNext;

                    emit setPosition(closestNext);
                }
            }
        }

        if (new_buttons & Undo  and
            current_buttons & Undo) {
            if (current_buttons & Shift) {
                emit redo();
            } else {
                emit undo();
            }
        }

        if (new_buttons & Play  and
            current_buttons & Play) {
            if (current_buttons & Shift) {
            } else {
                emit play();
            }
        }

        if (new_buttons & Stop  and
            current_buttons & Stop) {
            if (current_buttons & Shift) {
            } else {
                emit stop();
            }
        }

        if (new_buttons & Record  and
            current_buttons & Record) {
            if (current_buttons & Shift) {
            } else {
                emit record();
            }
        }

        if (new_buttons & Loop  and
            current_buttons & Loop) {
            if (current_buttons & Shift) {
            } else {
                loop_start_time = m_composition->getPosition();
                loop_end_time = loop_start_time;
            }
        }

        if (new_buttons & Loop  and
            (not (current_buttons & Loop))) {
            if (current_buttons & Shift) {
            } else {
                if (loop_start_time == loop_end_time) {
                    m_rgDocument->setLoop(0,0);
                }

                loop_start_time = 0;
                loop_end_time = 0;
            }
        }

        if (new_buttons& Rewind  and
            current_buttons & Rewind) {
            if (current_buttons&Shift) {
                emit rewindToBeginning();
            } else {
                emit rewind();
            }
        }

        if (new_buttons & FastForward  and
            current_buttons & FastForward) {
            if (current_buttons & Shift) {
                emit fastForwardToEnd();
            } else {
                emit fastForward();
            }
        }

        if (new_buttons & TrackRec  and
            current_buttons & TrackRec) {
            if (current_buttons & Shift) {
            } else {
                emit trackRecord();
            }
        }

        if (new_buttons & TrackRight  and
            current_buttons & TrackRight) {
            if (current_buttons & Shift) {
            } else {
                emit trackDown();
            }
        }

        if (new_buttons & TrackLeft  and
            current_buttons & TrackLeft) {
            if (current_buttons& Shift) {
            } else {
                emit trackUp();
            }
        }

        if (new_buttons & TrackMute  and
            current_buttons & TrackMute) {
            if (current_buttons & Shift) {
            } else {
                emit trackMute();
            }
        }

        if (datawheel) {
            if (datawheel < 0x7F) {
                if (current_buttons & Loop) {
                    loop_end_time += datawheel *
                        m_composition->getDurationForMusicalTime(loop_end_time, 0,1,0,0);
                    m_rgDocument->setLoop(loop_start_time, loop_end_time);
                } else if(current_buttons & Shift) {
                    timeT here = m_composition->getPosition();
                    here += datawheel * m_composition->getDurationForMusicalTime(here,0,0,1,0);
                    if (here <= m_composition->getEndMarker()) {
                        emit setPosition(here);
                    }
                } else {
                    timeT here = m_composition->getPosition();
                    here += datawheel * m_composition->getDurationForMusicalTime(here,0,1,0,0);
                    if (here <= m_composition->getEndMarker()) {
                        emit setPosition(here);
                    }
                }
            } else {
#define DATAWHEEL_VALUE (1 + (0xFF - (datawheel)))
                if (current_buttons & Loop) {
                    loop_end_time -= (1 + (0xFF - datawheel)) *
                        m_rgGUIApp->getDocument()->getComposition().getDurationForMusicalTime(loop_end_time, 0,1,0,0);
                    m_rgDocument->setLoop(loop_start_time, loop_end_time);
                }

                if (current_buttons & Shift) {
                    timeT here = m_composition->getPosition();
                    here -= DATAWHEEL_VALUE *  m_composition->getDurationForMusicalTime(here,0,0,1,0);
                    if (here >= m_composition->getStartMarker()) {
                        emit setPosition(here);
                    }
                } else {
                    timeT here = m_composition->getPosition();
                    here -= DATAWHEEL_VALUE *  m_composition->getDurationForMusicalTime(here,0,1,0,0);
                    if (here >= m_composition->getStartMarker()) {
                        emit setPosition(here);
                    }
                }
#undef DATAWHEEL_VALUE
            }
        }

        memcpy(previousbuf, currentbuf, 8);
    }

    if (val == -1) {
        if (errno == EAGAIN) {
            return;
        } else {
            RG_DEBUG << "TranzportClient::readData: error " << strerror(errno);
        }
    } else {
        RG_DEBUG << "TranzportClient::readData: partial read of length " << val;
        RG_DEBUG << "TranzportClient::readData: this should not happen " << val;
    }
}
Example #7
0
OSErr
IsFlattenedResourceFile(
	ConstFSSpecPtr	inFile,
	Boolean*		outIsFlat)
{
	OSErr		err;
	CInfoPBRec	pb;
	
	if (not inFile)
	{
		// This can occur when we create a new project document (Cmd-N)
		*outIsFlat = false;
		return noErr;
	}

	pb.hFileInfo.ioNamePtr = (StringPtr)inFile->name;
	pb.hFileInfo.ioVRefNum = inFile->vRefNum;
	pb.hFileInfo.ioDirID = inFile->parID;
	pb.hFileInfo.ioFDirIndex = 0;

	err = PBGetCatInfoSync(&pb);
	if (err == noErr)
	{
		if (pb.hFileInfo.ioFlAttrib & kioFlAttribDirMask)
		{
			// This is a directory
			*outIsFlat = false;
			return paramErr;
		}
		else
		{
			UInt32	dfSize;
			UInt32	rfSize;
			SInt16	dfRefNum;
			SInt32	filePos;
			
			dfSize = pb.hFileInfo.ioFlLgLen;
			rfSize = pb.hFileInfo.ioFlRLgLen;
			
			if (rfSize > 0)
			{
				*outIsFlat = false;
			}
			else if (dfSize == 0)
			{
				// This file has no data or resource fork.
				*outIsFlat = false;
			}
			else
			{
				// Only the data fork is non-empty.
				// Now we need to determine if it contains resources or not.
				UInt32	firstFourWords[4];
				SInt32	byteCount;
				
				err = FSpOpenDF(inFile, fsRdPerm, &dfRefNum);
				if (err)	return err;
				
				err = GetFPos(dfRefNum, &filePos);
				
				byteCount = sizeof(firstFourWords);

				err = FSRead(dfRefNum, &byteCount, &firstFourWords);
				if (err == noErr)
				{
					// Test is based on resource file format as described in IM: More Mac Toolbox
					// <http://developer.apple.com/techpubs/mac/MoreToolbox/MoreToolbox-99.html#HEADING99-0>
					//
					// First four words of the file represent the resource header
					// Word1:  Offset from beginning of resource fork to resource data
					// Word2:  Offset from beginning of resource fork to resource map
					// Word3:  Length of resource data
					// Word4:  Length of resource map
					//
					// So...
					// (Word1 + Word3 + Word4) == (Word2 + Word4) == size of resource fork

					if ((byteCount == sizeof(firstFourWords)) and
						(EndianU32_BtoN(firstFourWords[0]) + EndianU32_BtoN(firstFourWords[2]) +
						 EndianU32_BtoN(firstFourWords[3]) == dfSize) and
						(EndianU32_BtoN(firstFourWords[1]) + EndianU32_BtoN(firstFourWords[3]) == dfSize))
					{
						*outIsFlat = true;
					}
				}
				
				err = SetFPos(dfRefNum, fsFromStart, filePos);

				err = FSClose(dfRefNum);
			}
		}
	}
	
	return err;
}
Example #8
0
double binsvd_pred::study(RsHash train, RsHash valid, QString train_neg_fn, QString valid_fn,
                        QList<float> p, bool verbose)
{
    if (verbose) printf("Start binsvd studying...\n");

    if (!p.empty())
    {
        fact_n = p[0];
        alfa = p[1];
        lambda = p[2];
    }
    double min_err = 100, last_err[4] = {100,100,100,100};
    int min_err_step = 1;

	// create and fill data structures
        QHash<int, QVector<int> > user_negatives = load_user_negatives(train_neg_fn, verbose);
        QHash<int, QVector<int> > user_positives = load_user_positives(train);
        create_factors(user_factors, train, fact_n, 1);
        create_factors(item_factors, train, fact_n, 0);

        int un = user_positives.count();
        // by steps
        for (int st = 1; st <= steps; st++)
        {
            if (verbose) printf("%d step: ", st);

            // by users
            QVector<int> users = user_positives.keys().toVector();
//#pragma omp parallel for
            for(int ui = 0; ui < un; ++ui)
            {
                int u = users[ui];
                QVector<int> u_pos = user_positives[u];
                QVector<int> u_neg = user_negatives[u];
                if (u_pos.count() != u_neg.count())
                    printf("bugs!\n");

                // by negative and positive items
                for(int r = -1; r <= 1; r += 2)
                {
                    QVector<int> items_list;
                    if (r == -1) items_list = u_neg;
                    else items_list = u_pos;
                    if (u_neg.count() != u_pos.count()) printf("bugs!\n");
                    if (u_neg.count() != u_pos.count()) printf("bugs!\n");

                    QVector<int>::const_iterator it2;
                    for(it2 = items_list.constBegin(); it2 != items_list.constEnd(); ++it2)
                    {
                        int i = *it2;

			QVector<float> i_factors;
//#pragma omp critical
                {
                        i_factors = item_factors[i];
        		}
                        QVector<float> u_factors = user_factors[u];

                        float pr = dot_product(u_factors, i_factors, fact_n);
                        float err = r - pr;

                        // update user factors
                        for(int fi = 0; fi < fact_n; fi++)
                        {
                            float user_f = u_factors.value(fi);
                            float item_f = i_factors.value(fi);
                            u_factors[fi] = user_f + alfa * (err * item_f - lambda * user_f);
                        }
                        user_factors[u] = u_factors;

                        // update item factors
                        for(int fi = 0; fi < fact_n; fi++)
                        {
                            float user_f = u_factors.value(fi);
                            float item_f = i_factors.value(fi);
                            i_factors[fi] = item_f + alfa * (err * user_f - lambda * item_f);
                        }
//#pragma omp critical
                	{
                        item_factors[i] = i_factors;
			}
                    }
                }
            }

            double err = estimate(predict(valid, false), valid_fn, "../../binsvd_pred", false);

            if (err < min_err)
            {
                min_err = err;
                min_err_step = st;
            }
            if (verbose) printf("error %2.3f, alfa=%2.5f, e_thr=%2.5f\n", err, alfa, e_thr);

            last_err[3] = last_err[2];
            last_err[2] = last_err[1];
            last_err[1] = last_err[0];
            last_err[0] = err;
            if (st > 30 and (last_err[0] - last_err[3] > 0.01) ) break;
            
            /*if (alfa >= 0.001 and last_err[1] - last_err[0] < e_thr and last_err[2] - last_err[1] < e_thr)
            {
        	alfa *= 0.66;
        	e_thr *= 0.66;
	    }
	    if (alfa <= 0.001) break;*/
        }

    if (verbose) printf("ok (min error %2.2f on %d step)\n", min_err, min_err_step);
    return min_err;
}
Example #9
0
void RgbEffects::RenderTree(int Branches)
{

    int x,y,i,i7,r,ColorIdx,Count,pixels_per_branch;
    int maxFrame,mod,branch,row,b,f_mod,m,frame;
    int number_garlands,f_mod_odd,s_odd_row,odd_even;
    float V,H;

    number_garlands=1;
    srand(1); // always have the same random numbers for each frame (state)
    wxImage::HSVValue hsv; //   we will define an hsv color model. The RGB colot model would have been "wxColour color;"
    pixels_per_branch=(int)(0.5+BufferHt/Branches);
    maxFrame=(Branches+1) *BufferWi;
    size_t colorcnt=GetColorCount();
    frame = (state/4)%maxFrame;

    i=0;

    for (y=0; y<BufferHt; y++) // For my 20x120 megatree, BufferHt=120
    {
        for (x=0; x<BufferWi; x++) // BufferWi=20 in the above example
        {
            mod=y%pixels_per_branch;
            if(mod==0) mod=pixels_per_branch;
            V=1-(1.0*mod/pixels_per_branch)*0.70;
            i++;

            ColorIdx=rand() % colorcnt; // Select random numbers from 0 up to number of colors the user has checked. 0-5 if 6 boxes checked
            ColorIdx=0;
            palette.GetHSV(ColorIdx, hsv); // Now go and get the hsv value for this ColorIdx
            hsv.value = V; // we have now set the color for the background tree

            //   $orig_rgbval=$rgb_val;
            branch = (int)((y-1)/pixels_per_branch);
            row = pixels_per_branch-mod; // now row=0 is bottom of branch, row=1 is one above bottom
            //  mod = which pixel we are in the branch
            //	mod=1,row=pixels_per_branch-1   top picrl in branch
            //	mod=2, second pixel down into branch
            //	mod=pixels_per_branch,row=0  last pixel in branch
            //
            //	row = 0, the $p is in the bottom row of tree
            //	row =1, the $p is in second row from bottom
            b = (int) ((state)/BufferWi)%Branches; // what branch we are on based on frame #
            //
            //	b = 0, we are on bottomow row of tree during frames 1 to BufferWi
            //	b = 1, we are on second row from bottom, frames = BufferWi+1 to 2*BufferWi
            //	b = 2, we are on third row from bottome, frames - 2*BufferWi+1 to 3*BufferWi
            f_mod = (state/4)%BufferWi;
            //   if(f_mod==0) f_mod=BufferWi;
            //	f_mod is  to BufferWi-1 on each row
            //	f_mod == 0, left strand of this row
            //	f_mod==BufferWi, right strand of this row
            //
            m=(x%6);
            if(m==0) m=6;  // use $m to indicate where we are in horizontal pattern
            // m=1, 1sr strand
            // m=2, 2nd strand
            // m=6, last strand in 6 strand pattern



            r=branch%5;
            H = r/4.0;

            odd_even=b%2;
            s_odd_row = BufferWi-x+1;
            f_mod_odd = BufferWi-f_mod+1;

            if(branch<=b && x<=frame && // for branches below or equal to current row
                    (((row==3 or (number_garlands==2 and row==6)) and (m==1 or m==6))
                     ||
                     ((row==2 or (number_garlands==2 and row==5)) and (m==2 or m==5))
                     ||
                     ((row==1 or (number_garlands==2 and row==4)) and (m==3 or m==4))
                    ))
                if((odd_even ==0 and x<=f_mod) || (odd_even ==1 and s_odd_row<=f_mod))
                {
                    hsv.hue = H;
                    hsv.saturation=1.0;
                    hsv.value=1.0;
                }
            //	if(branch>b)
//	{
//		return $rgb_val; // for branches below current, dont dont balnk anything out
//	}
//	else if(branch==b)
//	{
//		if(odd_even ==0 and x>f_mod)
//		{
//			$rgb_val=$orig_rgbval;// we are even row ,counting from bottom as zero
//		}
//		if(odd_even ==1 and s_odd_row>f_mod)
//		{
//			$rgb_val=$orig_rgbval;// we are even row ,counting from bottom as zero
//		}
//	}
            //if($branch>$b) $rgb_val=$orig_rgbval; // erase rows above our current row.


            // Yes, so now decide on what color it should be


            //  we left the Hue and Saturation alone, we are just modifiying the Brightness Value
            SetPixel(x,y,hsv); // Turn pixel on

        }
    }
}
Example #10
0
int SHD_SAFE_MAIN(int argc, char *argv[]){
    shd::set_thread_priority_safe();

    //variables to be set by po
    std::string args, ant, subdev, ref;
    size_t num_bins;
    double rate, freq, gain, bw, frame_rate;
    float ref_lvl, dyn_rng;

    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
        ("help", "help message")
        ("args", po::value<std::string>(&args)->default_value(""), "multi shd device address args")
        // hardware parameters
        ("rate", po::value<double>(&rate), "rate of incoming samples (sps)")
        ("freq", po::value<double>(&freq), "RF center frequency in Hz")
        ("gain", po::value<double>(&gain), "gain for the RF chain")
        ("ant", po::value<std::string>(&ant), "daughterboard antenna selection")
        ("subdev", po::value<std::string>(&subdev), "daughterboard subdevice specification")
        ("bw", po::value<double>(&bw), "daughterboard IF filter bandwidth in Hz")
        // display parameters
        ("num-bins", po::value<size_t>(&num_bins)->default_value(512), "the number of bins in the DFT")
        ("frame-rate", po::value<double>(&frame_rate)->default_value(5), "frame rate of the display (fps)")
        ("ref-lvl", po::value<float>(&ref_lvl)->default_value(0), "reference level for the display (dB)")
        ("dyn-rng", po::value<float>(&dyn_rng)->default_value(60), "dynamic range for the display (dB)")
        ("ref", po::value<std::string>(&ref)->default_value("internal"), "waveform type (internal, external, mimo)")
    ;
    po::variables_map vm;
    po::store(po::parse_command_line(argc, argv, desc), vm);
    po::notify(vm);

    //print the help message
    if (vm.count("help") or not vm.count("rate")){
        std::cout << boost::format("SHD RX ASCII Art DFT %s") % desc << std::endl;
        return ~0;
    }

    //create a smini device
    std::cout << std::endl;
    std::cout << boost::format("Creating the smini device with: %s...") % args << std::endl;
    shd::smini::multi_smini::sptr smini = shd::smini::multi_smini::make(args);

    //Lock mboard clocks
    smini->set_clock_source(ref);

     //always select the subdevice first, the channel mapping affects the other settings
    if (vm.count("subdev")) smini->set_rx_subdev_spec(subdev);

    std::cout << boost::format("Using Device: %s") % smini->get_pp_string() << std::endl;

    //set the sample rate
    if (not vm.count("rate")){
        std::cerr << "Please specify the sample rate with --rate" << std::endl;
        return ~0;
    }
    std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl;
    smini->set_rx_rate(rate);
    std::cout << boost::format("Actual RX Rate: %f Msps...") % (smini->get_rx_rate()/1e6) << std::endl << std::endl;

    //set the center frequency
    if (not vm.count("freq")){
        std::cerr << "Please specify the center frequency with --freq" << std::endl;
        return ~0;
    }
    std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq/1e6) << std::endl;
    smini->set_rx_freq(freq);
    std::cout << boost::format("Actual RX Freq: %f MHz...") % (smini->get_rx_freq()/1e6) << std::endl << std::endl;

    //set the rf gain
    if (vm.count("gain")){
        std::cout << boost::format("Setting RX Gain: %f dB...") % gain << std::endl;
        smini->set_rx_gain(gain);
        std::cout << boost::format("Actual RX Gain: %f dB...") % smini->get_rx_gain() << std::endl << std::endl;
    }

    //set the IF filter bandwidth
    if (vm.count("bw")){
        std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % bw << std::endl;
        smini->set_rx_bandwidth(bw);
        std::cout << boost::format("Actual RX Bandwidth: %f MHz...") % smini->get_rx_bandwidth() << std::endl << std::endl;
    }

    //set the antenna
    if (vm.count("ant")) smini->set_rx_antenna(ant);

    boost::this_thread::sleep(boost::posix_time::seconds(1)); //allow for some setup time

    //Check Ref and LO Lock detect
    std::vector<std::string> sensor_names;
    sensor_names = smini->get_rx_sensor_names(0);
    if (std::find(sensor_names.begin(), sensor_names.end(), "lo_locked") != sensor_names.end()) {
        shd::sensor_value_t lo_locked = smini->get_rx_sensor("lo_locked",0);
        std::cout << boost::format("Checking RX: %s ...") % lo_locked.to_pp_string() << std::endl;
        SHD_ASSERT_THROW(lo_locked.to_bool());
    }
    sensor_names = smini->get_mboard_sensor_names(0);
    if ((ref == "mimo") and (std::find(sensor_names.begin(), sensor_names.end(), "mimo_locked") != sensor_names.end())) {
        shd::sensor_value_t mimo_locked = smini->get_mboard_sensor("mimo_locked",0);
        std::cout << boost::format("Checking RX: %s ...") % mimo_locked.to_pp_string() << std::endl;
        SHD_ASSERT_THROW(mimo_locked.to_bool());
    }
    if ((ref == "external") and (std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end())) {
        shd::sensor_value_t ref_locked = smini->get_mboard_sensor("ref_locked",0);
        std::cout << boost::format("Checking RX: %s ...") % ref_locked.to_pp_string() << std::endl;
        SHD_ASSERT_THROW(ref_locked.to_bool());
    }

    //create a receive streamer
    shd::stream_args_t stream_args("fc32"); //complex floats
    shd::rx_streamer::sptr rx_stream = smini->get_rx_stream(stream_args);

    //allocate recv buffer and metatdata
    shd::rx_metadata_t md;
    std::vector<std::complex<float> > buff(num_bins);
    //------------------------------------------------------------------
    //-- Initialize
    //------------------------------------------------------------------
    initscr(); //curses init
    smini->issue_stream_cmd(shd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
    boost::system_time next_refresh = boost::get_system_time();

    //------------------------------------------------------------------
    //-- Main loop
    //------------------------------------------------------------------
    while (true){
        //read a buffer's worth of samples every iteration
        size_t num_rx_samps = rx_stream->recv(
            &buff.front(), buff.size(), md
        );
        if (num_rx_samps != buff.size()) continue;

        //check and update the display refresh condition
        if (boost::get_system_time() < next_refresh) continue;
        next_refresh = boost::get_system_time() + boost::posix_time::microseconds(long(1e6/frame_rate));

        //calculate the dft and create the ascii art frame
        acsii_art_dft::log_pwr_dft_type lpdft(
            acsii_art_dft::log_pwr_dft(&buff.front(), num_rx_samps)
        );
        std::string frame = acsii_art_dft::dft_to_plot(
            lpdft, COLS, LINES,
            smini->get_rx_rate(),
            smini->get_rx_freq(),
            dyn_rng, ref_lvl
        );

        //curses screen handling: clear and print frame
        clear();
        printw("%s", frame.c_str());

        //curses key handling: no timeout, any key to exit
        timeout(0);
        int ch = getch();
        if (ch != KEY_RESIZE and ch != ERR) break;
    }

    //------------------------------------------------------------------
    //-- Cleanup
    //------------------------------------------------------------------
    smini->issue_stream_cmd(shd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
    endwin(); //curses done

    //finished
    std::cout << std::endl << "Done!" << std::endl << std::endl;

    return 0;
}
Example #11
0
/**
 * @brief Read next token from input buffer.
 * @param input The buffer from which a token will be searched.
 * @param index The index from where next token will be scanned. This will be
 * 			updated in the process.
 * @return Return the scanned token.
 */
std::string get_next_token(std::string *input, unsigned int* index) {
	std::string token = "";
	/*
	 * token_delmiters: define a point until when whatever we have read in
	 * buffer is a token. Note that they will not be part of any token unless
	 * token is a comment or a string as enclosed in ''(single quotes) and ""
	 * (double quotes). Currently token delimiters are space and comma ' '
	 * and ',' .
	 *
	 * Note: No matter what we will always advance index such that it will point
	 * to next character in the stream ahead of
	 */
	/*
	 * token_separators: we buffer elements from input stream until one of
	 * them is encountered. Note that they themselves are tokens as well.
	 */
	char token_separators[] = { ',', '+', '.', '-', '*', '\\', '=', '(', ')',
			'<', '>', ';', ':', '!', '\0' };
	int number_of_token_separators = strlen(token_separators);
	//find tokens
	for (; *index < (*input).length(); (*index)++) {
		/*
		 * 1. detect strings enclosed in single quotes. Note that token obtained
		 *  in this case is inclusive of opening and closing quotes.
		 */
		if ((*input)[*index] == '\'') {
			token = token + (*input)[*index];
			(*index)++;

			while (((*input)[*index] != '\'') and (*index < (*input).length())) {
				token = token + (*input)[*index];
				(*index)++;
			}
			token = token + (*input)[*index];
			(*index)++;
			return token;
		}

		/*
		 * 2. detect strings enclosed in double quotes. Token is inclusive of
		 *  opening and closing double quotes.
		 */
		if ((*input)[*index] == '\"') {
			token = token + (*input)[*index];
			(*index)++;
			while ((*input)[*index] != '\"' and (*index < (*input).length())) {
				token = token + (*input)[*index];
				(*index)++;
			}
			token = token + (*input)[*index];
			(*index)++;
			return token;
		}
		/*
		 * 3.detect token which begin with '`' backtick character. These are
		 * legal tokens in mysql. we will consider inclusive of opening
		 * and end backticks
		 */
		if ((*input)[*index] == '`') {
			token = token + (*input)[*index];
			(*index)++;
			while ((*input)[*index] != '`' and (*index < (*input).length())) {
				token = token + (*input)[*index];
				(*index)++;
			}
			token = token + (*input)[*index];
			(*index)++;
			return token;
		}
		/*
		 * 4. find token separators. they are tokens as well. However special
		 * about them is that the moment they are encountered we return. So
		 * a token separator is 'alone' .
		 */
		for (int i = 0; i < number_of_token_separators; i++) {
			if ((*input)[*index] == token_separators[i]) {
				//if we already have something in token then we need to return.
				if (token.length() != 0) {
					return token;
				}

				token = token + (*input)[*index];
				(*index)++;
				return token;
			}
		}
		/*
		 * 5. default case. if none of above conditions were satisfied then
		 * this character is a part of token.
		 *
		 * Also note that we will eat spaces in beginning of a token not after it.
		 * so the moment we find a space after we have filled something in token
		 * we will return .
		 */
		if ((*input)[*index] != ' ') {
			token = token + (*input)[*index];
		}
		if ((*input)[*index + 1] == ' ' and token != "") {
			(*index)++;
			return token;
		}

		//6. Eat out spaces/delimiters.
		if ((*input)[*index] == ' ') {
			(*index)++;
			while (((*input)[*index] == ' ') and (*index < (*input).length())) {
				(*index)++;
			}
			/*
			 * stop when we have a token. but we were eating out spaces. However
			 * if we have not read anything then dont break. continue as we have
			 * still to find a valid token.
			 */
			if (token != "") {
				return token;
			} else {
				/*
				 * this character is not space, neither is it a separator but still
				 * has not been stored in token. however this char could be ' or "
				 * which require special treatment. so go up but ensure that
				 * the pointer is not incremented.
				 */
				(*index)--;
				continue;
			}
		}

	}
	return token;
}
Example #12
0
 bool treat_as_paired() const
 {
     return is_paired()
         and (not is_mapped() or not mp_is_mapped() or chr_name() == mp_chr_name());
 }
bool TeamInformation::amIClosestToBall()
{
    for (size_t i=0; i<m_received_packets.size(); i++)
    {
        if (not m_received_packets[i].empty())
        {
            if ((m_data->CurrentTime - m_received_packets[i].back().ReceivedTime < m_TIMEOUT) and (m_packet.TimeToBall > m_received_packets[i].back().TimeToBall))
                return false;
        }
    }
    return true;
}
Example #14
0
/***********************************************************************
 * Main function
 **********************************************************************/
int UHD_SAFE_MAIN(int argc, char *argv[]){
    uhd::set_thread_priority_safe();

    //variables to be set by po
    std::string args, wave_type, ant, subdev, ref, otw;
    size_t spb;
    double rate, freq, gain, wave_freq, bw;
    float ampl;

    //setup the program options
    po::options_description desc("Allowed options");
    desc.add_options()
        ("help", "help message")
        ("args", po::value<std::string>(&args)->default_value(""), "single uhd device address args")
        ("spb", po::value<size_t>(&spb)->default_value(0), "samples per buffer, 0 for default")
        ("rate", po::value<double>(&rate), "rate of outgoing samples")
        ("freq", po::value<double>(&freq), "RF center frequency in Hz")
        ("ampl", po::value<float>(&ampl)->default_value(float(0.3)), "amplitude of the waveform [0 to 0.7]")
        ("gain", po::value<double>(&gain), "gain for the RF chain")
        ("ant", po::value<std::string>(&ant), "daughterboard antenna selection")
        ("subdev", po::value<std::string>(&subdev), "daughterboard subdevice specification")
        ("bw", po::value<double>(&bw), "daughterboard IF filter bandwidth in Hz")
        ("wave-type", po::value<std::string>(&wave_type)->default_value("CONST"), "waveform type (CONST, SQUARE, RAMP, SINE)")
        ("wave-freq", po::value<double>(&wave_freq)->default_value(0), "waveform frequency in Hz")
        ("ref", po::value<std::string>(&ref)->default_value("internal"), "clock reference (internal, external, mimo)")
        ("otw", po::value<std::string>(&otw)->default_value("sc16"), "specify the over-the-wire sample mode")
    ;
    po::variables_map vm;
    po::store(po::parse_command_line(argc, argv, desc), vm);
    po::notify(vm);

    //print the help message
    if (vm.count("help")){
        std::cout << boost::format("UHD TX Waveforms %s") % desc << std::endl;
        return ~0;
    }

    //create a usrp device
    std::cout << std::endl;
    std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl;
    uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);

    //Lock mboard clocks
    usrp->set_clock_source(ref);

    //always select the subdevice first, the channel mapping affects the other settings
    if (vm.count("subdev")) usrp->set_tx_subdev_spec(subdev);

    std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;

    //set the sample rate
    if (not vm.count("rate")){
        std::cerr << "Please specify the sample rate with --rate" << std::endl;
        return ~0;
    }
    std::cout << boost::format("Setting TX Rate: %f Msps...") % (rate/1e6) << std::endl;
    usrp->set_tx_rate(rate);
    std::cout << boost::format("Actual TX Rate: %f Msps...") % (usrp->get_tx_rate()/1e6) << std::endl << std::endl;

    //set the center frequency
    if (not vm.count("freq")){
        std::cerr << "Please specify the center frequency with --freq" << std::endl;
        return ~0;
    }

    for(size_t chan = 0; chan < usrp->get_tx_num_channels(); chan++) {
        std::cout << boost::format("Setting TX Freq: %f MHz...") % (freq/1e6) << std::endl;
        usrp->set_tx_freq(freq, chan);
        std::cout << boost::format("Actual TX Freq: %f MHz...") % (usrp->get_tx_freq(chan)/1e6) << std::endl << std::endl;

        //set the rf gain
        if (vm.count("gain")){
            std::cout << boost::format("Setting TX Gain: %f dB...") % gain << std::endl;
            usrp->set_tx_gain(gain, chan);
            std::cout << boost::format("Actual TX Gain: %f dB...") % usrp->get_tx_gain(chan) << std::endl << std::endl;
        }

        //set the IF filter bandwidth
        if (vm.count("bw")){
            std::cout << boost::format("Setting TX Bandwidth: %f MHz...") % bw << std::endl;
            usrp->set_tx_bandwidth(bw, chan);
            std::cout << boost::format("Actual TX Bandwidth: %f MHz...") % usrp->get_tx_bandwidth(chan) << std::endl << std::endl;
        }

        //set the antenna
        if (vm.count("ant")) usrp->set_tx_antenna(ant, chan);
    }

    //for the const wave, set the wave freq for small samples per period
    if (wave_freq == 0 and wave_type == "CONST"){
        wave_freq = usrp->get_tx_rate()/2;
    }

    //error when the waveform is not possible to generate
    if (std::abs(wave_freq) > usrp->get_tx_rate()/2){
        throw std::runtime_error("wave freq out of Nyquist zone");
    }
    if (usrp->get_tx_rate()/std::abs(wave_freq) > wave_table_len/2){
        throw std::runtime_error("wave freq too small for table");
    }

    //pre-compute the waveform values
    const wave_table_class wave_table(wave_type, ampl);
    const size_t step = boost::math::iround(wave_freq/usrp->get_tx_rate() * wave_table_len);
    size_t index = 0;

    //create a transmit streamer
    //linearly map channels (index0 = channel0, index1 = channel1, ...)
    uhd::stream_args_t stream_args("fc32", otw);
    for (size_t chan = 0; chan < usrp->get_tx_num_channels(); chan++)
        stream_args.channels.push_back(chan); //linear mapping
    uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);

    //allocate a buffer which we re-use for each channel
    if (spb == 0) spb = tx_stream->get_max_num_samps()*10;
    std::vector<std::complex<float> > buff(spb);
    std::vector<std::complex<float> *> buffs(usrp->get_tx_num_channels(), &buff.front());

    //setup the metadata flags
    uhd::tx_metadata_t md;
    md.start_of_burst = true;
    md.end_of_burst   = false;
    md.has_time_spec  = true;
    md.time_spec = uhd::time_spec_t(0.1);

    std::cout << boost::format("Setting device timestamp to 0...") << std::endl;
    usrp->set_time_now(uhd::time_spec_t(0.0));

    //Check Ref and LO Lock detect
    std::vector<std::string> sensor_names;
    sensor_names = usrp->get_tx_sensor_names(0);
    if (std::find(sensor_names.begin(), sensor_names.end(), "lo_locked") != sensor_names.end()) {
        uhd::sensor_value_t lo_locked = usrp->get_tx_sensor("lo_locked",0);
        std::cout << boost::format("Checking TX: %s ...") % lo_locked.to_pp_string() << std::endl;
        UHD_ASSERT_THROW(lo_locked.to_bool());
    }
    sensor_names = usrp->get_mboard_sensor_names(0);
    if ((ref == "mimo") and (std::find(sensor_names.begin(), sensor_names.end(), "mimo_locked") != sensor_names.end())) {
        uhd::sensor_value_t mimo_locked = usrp->get_mboard_sensor("mimo_locked",0);
        std::cout << boost::format("Checking TX: %s ...") % mimo_locked.to_pp_string() << std::endl;
        UHD_ASSERT_THROW(mimo_locked.to_bool());
    }
    if ((ref == "external") and (std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end())) {
        uhd::sensor_value_t ref_locked = usrp->get_mboard_sensor("ref_locked",0);
        std::cout << boost::format("Checking TX: %s ...") % ref_locked.to_pp_string() << std::endl;
        UHD_ASSERT_THROW(ref_locked.to_bool());
    }

    std::signal(SIGINT, &sig_int_handler);
    std::cout << "Press Ctrl + C to stop streaming..." << std::endl;

    //send data until the signal handler gets called
    while(not stop_signal_called){
        //fill the buffer with the waveform
        for (size_t n = 0; n < buff.size(); n++){
            buff[n] = wave_table(index += step);
        }

        //send the entire contents of the buffer
        tx_stream->send(buffs, buff.size(), md);

        md.start_of_burst = false;
        md.has_time_spec = false;
    }

    //send a mini EOB packet
    md.end_of_burst = true;
    tx_stream->send("", 0, md);

    //finished
    std::cout << std::endl << "Done!" << std::endl << std::endl;
    return 0;
}
Example #15
0
bool Gate::is_gate(Gate* i1, Operand t){
    if ((t != Operand::AND) and (t != Operand::OR) and (t != Operand::NOT))
        return false;
    return true;
}
Example #16
0
bool BookRecord::equals(const BookRecord& other) const
{
  return ((equalsBasic(other)) and (editorID==other.editorID)
    and (unknownVMAD==other.unknownVMAD)
    and (memcmp(unknownOBND, other.unknownOBND, 12)==0)
    and (title==other.title)
    and (modelPath==other.modelPath) and (unknownMODT==other.unknownMODT)
    and (text==other.text) and (unknownCNAM==other.unknownCNAM)
    and (pickupSoundFormID==other.pickupSoundFormID)
    and (putdownSoundFormID==other.putdownSoundFormID)
    and (keywordArray==other.keywordArray)
    and (bookFlags==other.bookFlags) and (spellOrSkillID==other.spellOrSkillID)
    and (bookValue==other.bookValue) and (weight==other.weight)
    and (inventoryArtFormID==other.inventoryArtFormID));
}
Example #17
0
//Включаем выключаем кнопку удалить
void class_ref_firm::slot_enable_del()
{
    if (ui->tableView->selectionModel()->selectedIndexes().size() < 6)
    {
        ui->pushButton_del_firm->setEnabled(ui->tableView->selectionModel()->hasSelection());
        if (ui->tableView->selectionModel()->hasSelection())
        {
            ui->lineEdit_name->setText(ui->tableView->selectionModel()->selectedIndexes().at(1).data().toString());
            ui->lineEdit_inn->setText(ui->tableView->selectionModel()->selectedIndexes().at(2).data().toString());
            ui->lineEdit_kpp->setText(ui->tableView->selectionModel()->selectedIndexes().at(3).data().toString());
            if (ui->tableView->selectionModel()->selectedIndexes().at(4).data().toString() == "Да")
            {
                ui->checkBox_stroy->setChecked(true);
            }
            else
            {
                ui->checkBox_stroy->setChecked(false);
            }
        }
        else
        {
            ui->lineEdit_name->setText("");
            ui->lineEdit_inn->setText("");
            ui->lineEdit_kpp->setText("");
            ui->checkBox_stroy->setChecked(false);
        }
        if (ui->lineEdit_name->text() != "" and ui->lineEdit_kpp->text().length() == 9 and (ui->lineEdit_inn->text().length() == 12 or ui->lineEdit_inn->text().length() == 10) and ui->tableView->selectionModel()->hasSelection())
        {
            ui->pushButton_add_firm->setEnabled(true);
        }
        else
        {
            ui->pushButton_add_firm->setEnabled(false);
        }
        if (ui->pushButton_add_firm->isEnabled())
        {
            ui->pushButton_add_firm->setText("Изменить");
        }
        else
        {
            ui->pushButton_add_firm->setText("Добавить");
        }
    }
    else
    {
        ui->lineEdit_name->setText("");
        ui->lineEdit_inn->setText("");
        ui->lineEdit_kpp->setText("");
        ui->checkBox_stroy->setChecked(false);
        ui->pushButton_add_firm->setEnabled(false);
        ui->pushButton_del_firm->setEnabled(false);
    }
}
bool BodyPartAssociation::operator==(const BodyPartAssociation& other) const
{
  return ((Index==other.Index) and (MaleBodyPart==other.MaleBodyPart)
      and (FemaleBodyPart==other.FemaleBodyPart));
}
Example #19
0
int main (int argc, char const* argv[])
{
	SDL_Rect rect;
	int g, h, frame, subframe;
	bool arrastrar_mouse = false;
	int mouseX, mouseY, newX, newY;
	SDL_Event evento;
	Mario mario;
	Casa casa;
	string nombre_archivo;
	fstream archivo;
	
	srand(time(NULL));
	mario.Inicializar();
	casa.Inicializar();
    
	setup();
	DibujarFondo();
	DibujarMenu();
	DibujarObstaculos();
	
	frame = 0;
	estado_menu = -1;
	
	do {
		
		SDL_GetMouseState(&mouseX, &mouseY);
	
		while (SDL_PollEvent (&evento)) {
			switch (evento.type) {
				case SDL_QUIT:
					return 0;
					break;
				
				case SDL_KEYDOWN:
//					if (estado_menu == PLAY and not mario.usando_pila and not mario.esInicializado()) {
//						switch (evento.key.keysym.sym) {
//							case SDLK_UP:
//								if (mario.posY-1 >= 0 and mapa_virtual[mario.posY-1][mario.posX] == ESTADO_CAMINABLE) {
//									mario.MoverMario(ARRIBA, casa);
//								}
//								break; /* Cierre de tecla arriba */
//					
//							case SDLK_DOWN:
//								if (mario.posY+1 < PANTALLA_ALTO and mapa_virtual[mario.posY+1][mario.posX] == ESTADO_CAMINABLE) {
//									mario.MoverMario(ABAJO, casa);
//								}
//								break; /* Cierre de tecla abajo */
//					
//							case SDLK_LEFT:
//								if (mario.posX-1 >= 0 and mapa_virtual[mario.posY][mario.posX-1] == ESTADO_CAMINABLE) {
//									mario.MoverMario(IZQ, casa);
//								}
//								break; /* Cierre tecla izq */
//					
//							case SDLK_RIGHT:
//								if (mario.posX+1 < PANTALLA_ANCHO and mapa_virtual[mario.posY][mario.posX+1] == ESTADO_CAMINABLE) {
//									mario.MoverMario(DER, casa);
//								}
//				                break; /* Cierre tecla der */
//				                
//				            case SDLK_BACKSPACE:
//				            	if (not mario.pila_movimientos.empty()) {				            	
//									mario.usando_pila = true;
//				            	}
//				                break;				                
//						} /* Cierre del switch selector de tecla */
//					}
					if (estado_menu != PLAY) {
						switch (evento.key.keysym.sym) {
							case SDLK_0:
								DibujarFondo ();
								mario.Inicializar();
								casa.Inicializar();
								break;
							case SDLK_1: case SDLK_2: case SDLK_3:
								DibujarFondo ();
								DibujarMapaPrecargado(evento.key.keysym.sym - 48);
								mario.Inicializar();
								casa.Inicializar();
								break;
							case SDLK_g:
								GuardarMapa();								
								break;
							case SDLK_a:
								DibujarFondo ();
								AbrirMapa();
								mario.Inicializar();
								casa.Inicializar();								
								break;
						}
					}
                    break; /* Cierre de SDL_Keydown */
				
				case SDL_MOUSEBUTTONDOWN:
					switch(evento.button.button) {
						case SDL_BUTTON_WHEELUP:
							if (porcentaje_obstaculos < RANDOM_MAXIMO and estado_menu != PLAY) {
								porcentaje_obstaculos = porcentaje_obstaculos + 0.4;
								DibujarFondo ();
								DibujarObstaculos();
								mario.Inicializar();
								casa.Inicializar();
							}												
							break;				
						
						case SDL_BUTTON_WHEELDOWN:					
							if (porcentaje_obstaculos > RANDOM_MINIMO and estado_menu != PLAY) {
								porcentaje_obstaculos = porcentaje_obstaculos - 0.4;
								DibujarFondo ();
								DibujarObstaculos();
								mario.Inicializar();
								casa.Inicializar();
							}
							break;
						
						case SDL_BUTTON_LEFT:
							if (mouseX > PANTALLA_ANCHO * IMAGENES_DIMENSION + 2) {
								g = mouseY / IMAGENES_DIMENSION;							
								CambiarEstadoMenu (g);								
							}
							else {
								switch (estado_menu) {
									case COLOCAR_MARIO:
										h = mouseY / IMAGENES_DIMENSION;
										g = mouseX / IMAGENES_DIMENSION;
										if (mapa_virtual[h][g] == ESTADO_CAMINABLE) {
											mario.ColocarMario(h, g, casa);
										}
										break;
										
									case COLOCAR_CASA:
										h = mouseY / IMAGENES_DIMENSION;
										g = mouseX / IMAGENES_DIMENSION;
										if (mapa_virtual[h][g] == ESTADO_CAMINABLE) {
											casa.ColocarCasa(h, g);
											mario.ColocarMario(h, g, casa);
										}
										break;
										
									case COLOCAR_ARBOL:
										h = mouseY / IMAGENES_DIMENSION;
										g = mouseX / IMAGENES_DIMENSION;
										if (mapa_virtual[h][g] == ESTADO_CAMINABLE and
											(mario.posX != g or mario.posY != h) and
											(casa.posX != g or casa.posY != h) ) {
											ColocarArbol(h, g);
										}
										arrastrar_mouse = true;
										break;
										
									case COLOCAR_ARENA:
										h = mouseY / IMAGENES_DIMENSION;
										g = mouseX / IMAGENES_DIMENSION;
										if (mapa_virtual[h][g] == ESTADO_ANIMADO and
											(mario.posX != g or mario.posY != h) and
											(casa.posX != g or casa.posY != h) ) {
											ColocarArena(h, g);
										}
										arrastrar_mouse = true;
										break;
								}
							}
							break;
					}					
					break;
					
				case SDL_MOUSEMOTION:
					if (arrastrar_mouse and mouseX < PANTALLA_ANCHO * IMAGENES_DIMENSION) {
						switch (estado_menu) {
							case COLOCAR_ARBOL:
								h = mouseY / IMAGENES_DIMENSION;
								g = mouseX / IMAGENES_DIMENSION;
								if (mapa_virtual[h][g] == ESTADO_CAMINABLE and
									(mario.posX != g or mario.posY != h) and
									(casa.posX != g or casa.posY != h) ) {
									ColocarArbol(h, g);
								}
								break;
							case COLOCAR_ARENA:
								h = mouseY / IMAGENES_DIMENSION;
								g = mouseX / IMAGENES_DIMENSION;
								if (mapa_virtual[h][g] == ESTADO_ANIMADO and
									(mario.posX != g or mario.posY != h) and
									(casa.posX != g or casa.posY != h) ) {
									ColocarArena(h, g);
								}
								break;
						}
					}
					break;
					
				case SDL_MOUSEBUTTONUP:
					if (arrastrar_mouse) {
						arrastrar_mouse = false;
					}
					break;
			}
		}
		
		/* Movimiento con la lines de Bres. */
		if ((frame % 2) == 0 and estado_menu == PLAY and not casa.esInicializado()) {
			LineaBres(&mario, casa, &newX, &newY);
			if (mapa_virtual[newY][newX] == ESTADO_CAMINABLE) {				
				mario.MoverMario (casa, newX, newY);
			}
			else {				
				mario.MovimientoAleatorio(&newX, &newY);
				mario.MoverMario (casa, newX, newY);
			}
		}
		
		/* ANIMAR las cosas */
		if (estado_menu == PLAY) {		
			/* Animar arbustos */
			subframe = frame / 8;
			for (g = 0; g < PANTALLA_ALTO; g++) {
				for (h = 0; h < PANTALLA_ANCHO; h++) {
					if (mapa_virtual [g][h] == ESTADO_ANIMADO) {
						rect.x = h * IMAGENES_DIMENSION;
						rect.y = g * IMAGENES_DIMENSION;
					
						SDL_BlitSurface (images [IMG_SAND_1], NULL, screen, &rect);
						SDL_BlitSurface (images [IMG_GRASS_1 + subframe], NULL, screen, &rect);
					}
					if (mapa_virtual [g][h] == ESTADO_BANDERIN_1) {
						rect.x = h * IMAGENES_DIMENSION;
						rect.y = g * IMAGENES_DIMENSION;
					
						SDL_BlitSurface (images [IMG_COURSE_1_1 + frame/16], NULL, screen, &rect);
					}
					if (mapa_virtual [g][h] == ESTADO_BANDERIN_2) {
						rect.x = h * IMAGENES_DIMENSION;
						rect.y = g * IMAGENES_DIMENSION;
					
						SDL_BlitSurface (images [IMG_COURSE_2_1 + frame/16], NULL, screen, &rect);
					}
					if (mapa_virtual [g][h] == ESTADO_BANDERIN_3) {
						rect.x = h * IMAGENES_DIMENSION;
						rect.y = g * IMAGENES_DIMENSION;
					
						SDL_BlitSurface (images [IMG_COURSE_3_1 + frame/16], NULL, screen, &rect);
					}
					if (mapa_virtual [g][h] == ESTADO_BANDERIN_4) {
						rect.x = h * IMAGENES_DIMENSION;
						rect.y = g * IMAGENES_DIMENSION;
					
						SDL_BlitSurface (images [IMG_COURSE_4_1 + frame/16], NULL, screen, &rect);
					}
				}
			}
			
			/* Animar Mario */
			mario.AnimarMario(((frame % 8) / 4));
		}
		
		frame++;
		if (frame > 31) frame = 0;
			
		SDL_Flip (screen);
		SDL_Delay (32);
		
	} while (1);
	
	return 0;
}
Example #20
0
//
//****************************************************************************
//               TEST OF FULL_MERGE_FOUR
//****************************************************************************
void prueba6(void)
{   //------------------------------- begin------------------------------------
    struct xk
    {   unsigned tail : 3 ;
        unsigned num  :24 ;

        xk( unsigned N, unsigned T =0):tail(T),num(N){};
        bool operator < ( xk A) const
        {   return ( num < A.num);
        };
    };
    std::vector<xk> R[4],Rout;
    typedef typename std::vector<xk>::iterator iter_t ;
    typedef  std::less<xk> Compare ;
    Compare Comp ;

    //------------------------------------------------------------------------
    R[0] = {3,5,9,16,17,24,25,29};
    R[1] = {1,7,10,13,18,22,26,30 };
    R[2] = {2 ,6,11,15,20,21,28,32};
    R[3] = {4,8,12,14,19,23,27,31} ;

    for ( uint32_t i =0 ; i < 4 ; ++i)
    {   for ( uint32_t k =0 ; k < 10 ; ++k)
        {   R[i][k].tail = i ;
        };
    };
    Rout.resize ( 32,0);
    bs_util::range<iter_t>  RG[4]= { {R[0].begin(),R[0].end()} ,
                            {R[1].begin(),R[1].end()} ,
                            {R[2].begin(),R[2].end()} ,
                            {R[3].begin(),R[3].end()}  } ;

    bs_util::full_merge4 (&Rout[0],RG,4,Comp);

    if ( Rout.size() != 32) std::cout<<"Error in the size\n";
    for( uint32_t i = 0 ; i < Rout.size() ; ++i)
        BOOST_CHECK ( Rout[i].num == i+1) ;

    //------------------------------------------------------------------------
    R[0] = {2,3,5,6,6,10,13,20};
    R[1] = {1,2,4,5,6,10,17,19 };
    R[2] = {2,3,4,7,8,11,16,18};
    R[3] = {1,4,5,7,9,12,14,15} ;
    for ( uint32_t i =0 ; i < 4 ; ++i)
    {   for ( uint32_t k =0 ; k < R[i].size() ; ++k)
            R[i][k].tail = i ;
    };
    Rout.clear() ;
    Rout.resize ( 32,0);
    RG[0] = {R[0].begin(),R[0].end()} ;
    RG[1] = {R[1].begin(),R[1].end()} ;
    RG[2] =  {R[2].begin(),R[2].end()} ;
    RG[3] =  {R[3].begin(),R[3].end()}   ;

    bs_util::full_merge4 (&Rout[0],RG,4,Comp);

    for ( uint32_t i = 1 ; i < Rout.size() ; ++i)
    {
        BOOST_CHECK ( Rout[i-1].num <= Rout[i].num and
             (Rout[i-1].num != Rout[i].num or Rout[i-1].tail <= Rout[i].tail  ));
        //if ( Rout[i-1].num > Rout[i].num or
        //     (Rout[i-1].num == Rout[i].num and Rout[i-1].tail> Rout[i].tail  ))
        //    std::cout<<"Error in the sorting \n" ;
    };
};
Example #21
0
LFile*
PRDocument::CreateNewUnflattenedFile(
	ConstFSSpecPtr	inFileSpec)
{
	// Validate pointers.
	
	ValidateThis_();
	
	OSErr	err;
	FSSpec	unflattenedSpec;
	SInt16	foundVRefNum;
	SInt32	foundDirID;
	SInt16	srcRefNum;
	SInt16	destRefNum;
	
	err = ::FindFolder(inFileSpec->vRefNum, kTemporaryFolderType, kCreateFolder,
				&foundVRefNum, &foundDirID);
	// JWW - The volume might not be what we asked, especially if it's on OS X...
	// ...and on OS X, it looks like FindFolder returns an error, so don't throw
	if ((err != noErr) || (foundVRefNum != inFileSpec->vRefNum))
	{
		// ...and in that case, just use the document folder instead why not?
		foundVRefNum = inFileSpec->vRefNum;
		foundDirID = inFileSpec->parID;
	}

	LStr255	tempName;
	UInt32	ticks = ::TickCount();

	do {
		tempName = (SInt32) ticks++;
		tempName += inFileSpec->name;
		if (tempName.Length() > 31)
		{
			tempName[0] = 31;
		}
		
		err = ::FSMakeFSSpec(foundVRefNum, foundDirID, tempName, &unflattenedSpec);
		if ((err != noErr) and (err != fnfErr))
			Throw_(err);
	} while (err != fnfErr);


	// Delete any existing unflattened file
	if (mUnflattenedFile)
	{
		FSSpec	oldUnflattenedSpec;
		
		mUnflattenedFile->GetSpecifier(oldUnflattenedSpec);
		delete mUnflattenedFile;
		mUnflattenedFile = nil;
		
		// delete the unflattened file from disk (it's just a temporary file anyways)
		err = ::FSpDelete(&oldUnflattenedSpec);
		if (err == fLckdErr)
		{
			// Unlock it and try to delete it again
			err = ::FSpRstFLock(&oldUnflattenedSpec);
			if (err == noErr)
			{
				::FSpDelete(&oldUnflattenedSpec);
			}
		}
	}

	// Create the new unflattened file
	mUnflattenedFile = new LFile(unflattenedSpec);

	// Create the new file and create the resource map
	mUnflattenedFile->CreateNewFile(Type_CreatorCode, Type_MacOSDocument, smSystemScript);
	destRefNum = mUnflattenedFile->OpenResourceFork(fsRdWrPerm);

	LFile	flatFile(*inFileSpec);
	srcRefNum = flatFile.OpenDataFork(fsRdPerm);

	StPointerBlock	buffer(bigCopyBuffSize, false, false);
	if (not buffer.IsValid())
	{
		StPointerBlock	smallBuffer(minCopyBuffSize, true, false);
		buffer.Adopt(smallBuffer.Release());
	}

	err = ::CopyFork(srcRefNum, destRefNum, buffer, ::GetPtrSize(buffer));
	
	SInt32	resForkEOF;
	
	ThrowIfOSErr_(::GetEOF(destRefNum, &resForkEOF));

	// Close the resource fork (we'll leave the flat file's data fork open)
	mUnflattenedFile->CloseResourceFork();

	// The CopyFork routine may have killed the resource map in the case
	// where the data fork was empty.  This will recreate an empty resource map.
	if (resForkEOF == 0)
	{
		::FSpDelete(&unflattenedSpec);
		mUnflattenedFile->CreateNewFile(Type_CreatorCode, Type_MacOSDocument, smSystemScript);
	}
	
	// Copy the File Manager attributes over to the new file
	err = ::FSpCopyFileMgrAttributes(inFileSpec, &unflattenedSpec, true);

	return mUnflattenedFile;
}
Example #22
0
//****************************************************************************
//               TEST OF UNINITIALIZED_FULL_MERGE_FOUR
//****************************************************************************
void prueba8(void)
{   //------------------------------- begin------------------------------------
    struct xk
    {   unsigned tail : 3 ;
        unsigned num  :24 ;

        xk( unsigned N, unsigned T =0):tail(T),num(N){};
        bool operator < ( xk A) const
        {   return ( num < A.num);
        };
    };
    typedef typename std::vector<xk>::iterator iter_t ;
    typedef  std::less<xk> Compare ;

    std::vector<xk> R[4];
    char K[320];
    xk *PAux = reinterpret_cast <xk*> ( &K[0]);

    Compare Comp ;

    //------------------------------------------------------------------------
    R[0] = {3,5,9,16,17,24,25,29};
    R[1] = {1,7,10,13,18,22,26,30 };
    R[2] = {2 ,6,11,15,20,21,28,32};
    R[3] = {4,8,12,14,19,23,27,31} ;

    for ( uint32_t i =0 ; i < 4 ; ++i)
    {   for ( uint32_t k =0 ; k < 10 ; ++k)
        {   R[i][k].tail = i ;
        };
    };

    bs_util::range<iter_t>  RG[4]= { {R[0].begin(),R[0].end()} ,
                            {R[1].begin(),R[1].end()} ,
                            {R[2].begin(),R[2].end()} ,
                            {R[3].begin(),R[3].end()}  } ;

    bs_util::uninit_full_merge4 (PAux,RG,4,Comp);
    for( uint32_t i = 0 ; i < 32 ; ++i)
        BOOST_CHECK ( PAux[i].num == i+1) ;
    bs_util::destroy (PAux, PAux + 32 );

    //------------------------------------------------------------------------
    R[0] = {2,3,5,6,6,10,13,20};
    R[1] = {1,2,4,5,6,10,17,19 };
    R[2] = {2,3,4,7,8,11,16,18};
    R[3] = {1,4,5,7,9,12,14,15} ;
    for ( uint32_t i =0 ; i < 4 ; ++i)
    {   for ( uint32_t k =0 ; k < R[i].size() ; ++k)
            R[i][k].tail = i ;
    };

    RG[0] = {R[0].begin(),R[0].end()} ;
    RG[1] = {R[1].begin(),R[1].end()} ;
    RG[2] =  {R[2].begin(),R[2].end()} ;
    RG[3] =  {R[3].begin(),R[3].end()}   ;

    bs_util::uninit_full_merge4 (PAux,RG,4,Comp);

    for ( uint32_t i = 1 ; i < 32 ; ++i)
    {   //if ( PAux[i-1].num > PAux[i].num or
        //     (PAux[i-1].num == PAux[i].num and PAux[i-1].tail> PAux[i].tail  ))
        //    std::cout<<"Error in the sorting \n" ;
        BOOST_CHECK ( PAux[i-1].num <= PAux[i].num and
             (PAux[i-1].num != PAux[i].num or PAux[i-1].tail <= PAux[i].tail  ));
    };
    bs_util::destroy (PAux, PAux + 32 );
};
void
aeif_cond_alpha_multisynapse::update( Time const& origin, const long_t from, const long_t to )
{
  assert( to >= 0 && ( delay ) from < Scheduler::get_min_delay() );
  assert( from < to );
  assert( State_::V_M == 0 );

  for ( long_t lag = from; lag < to; ++lag ) // proceed by stepsize B_.step_
  {
    double t = 0.0; // internal time of the integration period

    if ( S_.r_ > 0 ) // decrease remaining refractory steps if non-zero
      --S_.r_;

    // numerical integration with adaptive step size control:
    // ------------------------------------------------------
    // The numerical integration of the model equations is performed by
    // a Dormand-Prince method (5th order Runge-Kutta method with
    // adaptive stepsize control) as desribed in William H. Press et
    // al., “Adaptive Stepsize Control for Runge-Kutta”, Chapter 17.2
    // in Numerical Recipes (3rd edition, 2007), 910-914.  The solver
    // itself performs only a single NUMERICAL integration step,
    // starting from t and of size B_.IntegrationStep_ (bounded by
    // step); the while-loop ensures integration over the whole
    // SIMULATION step (0, step] of size B_.step_ if more than one
    // integration step is needed due to a small integration stepsize;
    // note that (t+IntegrationStep > step) leads to integration over
    // (t, step] and afterwards setting t to step, but it does not
    // enforce setting IntegrationStep to step-t; this is of advantage
    // for a consistent and efficient integration across subsequent
    // simulation intervals.

    double_t& h = B_.IntegrationStep_; // numerical integration step
    double_t& tend = B_.step_;         // end of simulation step

    const double_t& MAXERR = P_.MAXERR; // maximum error
    const double_t& HMIN = P_.HMIN;     // minimal integration step

    double_t err;
    double_t t_return = 0.0;

    while ( t < B_.step_ ) // while not yet reached end of simulation step
    {
      bool done = false;

      do
      {

        if ( tend - t < h ) // stop integration at end of simulation step
          h = tend - t;

        t_return = t + h; // update t

        // k1 = f(told, y)
        aeif_cond_alpha_multisynapse_dynamics( S_.y_, S_.k1 );

        // k2 = f(told + h/5, y + h*k1 / 5)
        for ( size_t i = 0; i < S_.y_.size(); ++i )
          S_.yin[ i ] = S_.y_[ i ] + h * S_.k1[ i ] / 5.0;
        aeif_cond_alpha_multisynapse_dynamics( S_.yin, S_.k2 );

        // k3 = f(told + 3/10*h, y + 3/40*h*k1 + 9/40*h*k2)
        for ( size_t i = 0; i < S_.y_.size(); ++i )
          S_.yin[ i ] = S_.y_[ i ] + h * ( 3.0 / 40.0 * S_.k1[ i ] + 9.0 / 40.0 * S_.k2[ i ] );
        aeif_cond_alpha_multisynapse_dynamics( S_.yin, S_.k3 );

        // k4
        for ( size_t i = 0; i < S_.y_.size(); ++i )
          S_.yin[ i ] = S_.y_[ i ]
            + h * ( 44.0 / 45.0 * S_.k1[ i ] - 56.0 / 15.0 * S_.k2[ i ] + 32.0 / 9.0 * S_.k3[ i ] );
        aeif_cond_alpha_multisynapse_dynamics( S_.yin, S_.k4 );

        // k5
        for ( size_t i = 0; i < S_.y_.size(); ++i )
          S_.yin[ i ] = S_.y_[ i ]
            + h * ( 19372.0 / 6561.0 * S_.k1[ i ] - 25360.0 / 2187.0 * S_.k2[ i ]
                    + 64448.0 / 6561.0 * S_.k3[ i ]
                    - 212.0 / 729.0 * S_.k4[ i ] );
        aeif_cond_alpha_multisynapse_dynamics( S_.yin, S_.k5 );

        // k6
        for ( size_t i = 0; i < S_.y_.size(); ++i )
          S_.yin[ i ] = S_.y_[ i ]
            + h * ( 9017.0 / 3168.0 * S_.k1[ i ] - 355.0 / 33.0 * S_.k2[ i ]
                    + 46732.0 / 5247.0 * S_.k3[ i ]
                    + 49.0 / 176.0 * S_.k4[ i ]
                    - 5103.0 / 18656.0 * S_.k5[ i ] );
        aeif_cond_alpha_multisynapse_dynamics( S_.yin, S_.k6 );

        // 5th order
        for ( size_t i = 0; i < S_.y_.size(); ++i )
          S_.ynew[ i ] = S_.y_[ i ]
            + h * ( 35.0 / 384.0 * S_.k1[ i ] + 500.0 / 1113.0 * S_.k3[ i ]
                    + 125.0 / 192.0 * S_.k4[ i ]
                    - 2187.0 / 6784.0 * S_.k5[ i ]
                    + 11.0 / 84.0 * S_.k6[ i ] );
        aeif_cond_alpha_multisynapse_dynamics( S_.yin, S_.k7 );

        // 4th order
        for ( size_t i = 0; i < S_.y_.size(); ++i )
        {
          S_.yref[ i ] = S_.y_[ i ]
            + h * ( 5179.0 / 57600.0 * S_.k1[ i ] + 7571.0 / 16695.0 * S_.k3[ i ]
                    + 393.0 / 640.0 * S_.k4[ i ]
                    - 92097.0 / 339200.0 * S_.k5[ i ]
                    + 187.0 / 2100.0 * S_.k6[ i ]
                    + 1.0 / 40.0 * S_.k7[ i ] );
        }

        err = std::fabs( S_.ynew[ 0 ] - S_.yref[ 0 ] ) / MAXERR + 1.0e-200; // error estimate,
        // based on different orders for stepsize prediction. Small value added to prevent err==0

        // The following flag 'done' is needed to ensure that we accept the result
        // for h<=HMIN, irrespective of the error. (See below)

        done = ( h <= HMIN ); // Always exit loop if h was <=HMIN already

        // prediction of next integration stepsize. This step may result in a stepsize below HMIN.
        // If this happens, we must
        //   1. set the stepsize to HMIN
        //   2. compute the result and accept it irrespective of the error, because we cannot
        //      decrease the stepsize any further.
        //  the 'done' flag, computed above ensure that the loop is terminated after the
        //  result was computed.

        h *= 0.98 * std::pow( 1.0 / err, 1.0 / 5.0 );
        h = std::max( h, HMIN );

      } while ( ( err > 1.0 ) and ( not done ) ); // reject step if err > 1

      for ( size_t i = 0; i < S_.y_.size(); ++i )
        S_.y_[ i ] = S_.ynew[ i ]; // pass updated values

      t = t_return;

      // check for unreasonable values; we allow V_M to explode
      if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6 || S_.y_[ State_::W ] > 1e6 )
        throw NumericalInstability( get_name() );

      // spikes are handled inside the while-loop
      // due to spike-driven adaptation
      if ( S_.r_ > 0 )                               // if neuron is still in refractory period
        S_.y_[ State_::V_M ] = P_.V_reset_;          // clamp it to V_reset
      else if ( S_.y_[ State_::V_M ] >= P_.V_peak_ ) // V_m >= V_peak: spike
      {
        S_.y_[ State_::V_M ] = P_.V_reset_;
        S_.y_[ State_::W ] += P_.b;   // spike-driven adaptation
        S_.r_ = V_.RefractoryCounts_; // initialize refractory steps with refractory period

        set_spiketime( Time::step( origin.get_steps() + lag + 1 ) );
        SpikeEvent se;
        network()->send( *this, se, lag );
      }
    } // while

    for ( size_t i = 0; i < P_.num_of_receptors_; ++i )
    {
      S_.y_[ State_::DG_EXC + ( State_::NUMBER_OF_STATES_ELEMENTS_PER_RECEPTOR * i ) ] +=
        B_.spike_exc_[ i ].get_value( lag ) * V_.g0_ex_[ i ]; // add incoming spikes
      S_.y_[ State_::DG_INH + ( State_::NUMBER_OF_STATES_ELEMENTS_PER_RECEPTOR * i ) ] +=
        B_.spike_inh_[ i ].get_value( lag ) * V_.g0_in_[ i ];
    }
    // set new input current
    B_.I_stim_ = B_.currents_.get_value( lag );

    // log state data
    B_.logger_.record_data( origin.get_steps() + lag );

  } // for-loop
}
Example #24
0
    void GlobalProblem::ConstructSubproblemPrimal(int subproblem_index, long double budget_allocation,
                                                  int opt_region) {
        // Figure out opt u, v.
        long double u = subproblems_[subproblem_index].envelope_points_[opt_region].first;
        long double v = subproblems_[subproblem_index].envelope_points_[opt_region].second;

        long double allocation_value = 0;

        // If optimum is u = 0, optimal allocation is greedy wrt price.
        if (u == 0) {
            int max_price_index;
            long double max_price = 0;
            for (int i = 0; i < subproblems_[subproblem_index].num_vars_; ++i) {
                if ((max_price < subproblems_[subproblem_index].constraints_[i].price_) and (subproblems_[subproblem_index].constraints_[i].is_active_)) {
                    max_price_index = i;
                    max_price = subproblems_[subproblem_index].constraints_[i].price_;
                }
            }

            //(*primal_sol)[subproblems_[subproblem_index].advertiser_index_->at(max_price_index)][subproblem_index] = 1;
            //(*solution_)[subproblems_[subproblem_index].constraints_[max_price_index].advertiser_index_][subproblem_index].first = 1;
            //(*primal_changes)[subproblems_[subproblem_index].constraints_[max_price_index].advertiser_index_][subproblem_index] = 1;
            primal_changes_[subproblem_index].first = make_pair(subproblems_[subproblem_index].constraints_[max_price_index].advertiser_index_, 1.0);
            primal_changes_[subproblem_index].second = make_pair(-1, 0.0);
            allocation_value = primal_changes_[subproblem_index].first.second *
                               subproblems_[subproblem_index].constraints_[max_price_index].price_;
            primal_assignment_test_ += allocation_value;
        }

        // If optimum is v = 0, optimal allocation is greedy wrt price/weight ratio.
        if (v == 0) {
            int max_ratio_index;
            long double max_ratio = 0;
            for (int i = 0; i < subproblems_[subproblem_index].num_vars_; ++i) {
                if (max_ratio < (subproblems_[subproblem_index].constraints_[i].price_ /
                                 subproblems_[subproblem_index].constraints_[i].coefficient_) and
                    (subproblems_[subproblem_index].constraints_[i].is_active_)) {
                    max_ratio_index = i;
                    max_ratio = (subproblems_[subproblem_index].constraints_[i].price_ /
                                 subproblems_[subproblem_index].constraints_[i].coefficient_);
                }
            }

            //(*primal_changes)[subproblems_[subproblem_index].constraints_[max_ratio_index].advertiser_index_][subproblem_index] = budget_allocation / subproblems_[subproblem_index].constraints_[max_ratio_index].coefficient_;
            //(*solution_)[subproblems_[subproblem_index].constraints_[max_ratio_index].advertiser_index_][subproblem_index].first = budget_allocation / subproblems_[subproblem_index].constraints_[max_ratio_index].coefficient_;
            //(*primal_sol)[subproblems_[subproblem_index].advertiser_index_->at(max_ratio_index)][subproblem_index] = budget_allocation / subproblems_[subproblem_index].constraints_[max_ratio_index].coefficient_;

            primal_changes_[subproblem_index].first = make_pair(subproblems_[subproblem_index].constraints_[max_ratio_index].advertiser_index_, budget_allocation / subproblems_[subproblem_index].constraints_[max_ratio_index].coefficient_);
            primal_changes_[subproblem_index].second = make_pair(-1, 0.0);
            allocation_value = primal_changes_[subproblem_index].first.second * subproblems_[subproblem_index].constraints_[max_ratio_index].price_;
            primal_assignment_test_ += allocation_value;
        }

        // If opt is u, v > 0, the optimum whp only has two positive allocations, which are the
        // solutions to a system of 2 equations.
        if ((u > 0) and (v > 0)) {
            vector<int> tight_constraint_indices;
            for (int i = 0; i < subproblems_[subproblem_index].num_vars_; ++i) {
                if (subproblems_[subproblem_index].constraints_[i].is_active_) {
                    long double slack = subproblems_[subproblem_index].constraints_[i].price_ -
                    (u * subproblems_[subproblem_index].constraints_[i].coefficient_ + v);
                    if (slack < 0) { slack = (-1) * slack;}
                    if (slack < numerical_accuracy_tolerance_) {
                        tight_constraint_indices.push_back(i);
                    }
                }
            }
            if (tight_constraint_indices.size() > 2) {
                cout << "ERROR, PERTURB PRICES \n";
            }
            if (tight_constraint_indices.size() == 1) {
                /*
                 (*primal_sol)[subproblems_[subproblem_index].advertiser_index_->
                 at(tight_constraint_indices[0])]
                 [subproblem_index] = fmin(budget_allocation / subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].coefficient_, 1);
                 */
                //(*solution_)[subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].advertiser_index_][subproblem_index].first = fmin(budget_allocation / subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].coefficient_, 1);
                //(*primal_changes)[subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].advertiser_index_][subproblem_index] = fmin(budget_allocation / subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].coefficient_, 1);
                primal_changes_[subproblem_index].first = make_pair(subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].advertiser_index_, fmin(budget_allocation / subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].coefficient_, 1));
                primal_changes_[subproblem_index].second = make_pair(-1, 0.0);
                allocation_value = primal_changes_[subproblem_index].first.second * subproblems_[subproblem_index].constraints_[tight_constraint_indices[0]].coefficient_;
                primal_assignment_test_ += allocation_value;
            }
            if (tight_constraint_indices.size() == 2) {
                int first_index = tight_constraint_indices[0];
                int second_index = tight_constraint_indices[1];

                long double x_1 = (budget_allocation -
                                   subproblems_[subproblem_index].constraints_[second_index].coefficient_) / (subproblems_[subproblem_index].constraints_[first_index].coefficient_ - subproblems_[subproblem_index].constraints_[second_index].coefficient_);
                /*
                 (*primal_sol)[subproblems_[subproblem_index].advertiser_index_->at(first_index)][subproblem_index] = x_1;
                 (*primal_sol)[subproblems_[subproblem_index].advertiser_index_->at(second_index)][subproblem_index] = 1 - x_1;
                 */
                /*
                (*solution_)[subproblems_[subproblem_index].constraints_[first_index].advertiser_index_][subproblem_index].first = x_1;
                (*solution_)[subproblems_[subproblem_index].constraints_[second_index].advertiser_index_][subproblem_index].first = 1 - x_1;
                */
                /*
                (*primal_changes)[subproblems_[subproblem_index].constraints_[first_index].advertiser_index_][subproblem_index] = x_1;
                (*primal_changes)[subproblems_[subproblem_index].constraints_[second_index].advertiser_index_][subproblem_index] = 1 - x_1;
                */
                primal_changes_[subproblem_index].first = make_pair(subproblems_[subproblem_index].constraints_[first_index].advertiser_index_, x_1);
                primal_changes_[subproblem_index].second = make_pair(subproblems_[subproblem_index].constraints_[second_index].advertiser_index_, 1 - x_1);

                 allocation_value = x_1 * subproblems_[subproblem_index].constraints_[first_index].price_ + (1-x_1) * subproblems_[subproblem_index].constraints_[second_index].price_;
                primal_assignment_test_ += allocation_value;

            }
        }
        if (((allocation_value - (u * budget_allocation + v)) > numerical_accuracy_tolerance_) ||
            ((allocation_value - (u * budget_allocation + v)) < -numerical_accuracy_tolerance_)) {
            cout << "**************Error at problem************ " << subproblem_index << " equal to " <<
            allocation_value << " - " << (u * budget_allocation + v) << "\n";
        }
    }
int main( int argc , char** argv ) {

  int L_flag=0,i,j,k,l;

  if ( argc > 1 and !strcmp( "-nt" , argv[1] ) ) {
    nthreads = atoi( argv[2] ) ;
    omp_set_num_threads( nthreads ) ;
    printf("\nNumber of threads set to %d!\n" , nthreads ) ;
  }
  else {
    nthreads = 1 ;
    omp_set_num_threads( nthreads ) ;
    printf("\nNumber of threads set to %d!\n" , nthreads ) ;
  }


  read_input() ;

   if(argc == 5 ) {
     Nhc =  atoi(argv[4]);
     cout<<"new Nhc "<<Nhc<<endl;
   }
  
  initialize() ;

  write_gro( ) ;
  write_quaternions( ) ;
  // Save chi for pre-equilibration steps //
  double tmp_ang,chi_bkp = chiAB ;

  FILE *otp ,*otpL;
  otp = fopen( "data.dat" , "w" ) ;
  otpL = fopen("box_L.dat","w");

  printf("Entering main loop!\n") ; fflush( stdout ) ;
  for ( step = 0 ; step < nsteps ; step++ )  {

 //   if ( step < pre_equil_steps )
 //     chiAB = 0.0 ;
 //   else
  //    chiAB = chi_bkp ;
   

    forces() ;
  
    //cout<<"here"<<endl;

    if(sigma>0){
       torque();
    }
  //  exit(1);

    if(step >0 || rst_para == 1)
   	update_positions() ;
    else
    	update_positions_init() ;
    
    if(sigma>0){
    update_euler();
    }

    

    if ( stress_freq > 0 && step % stress_freq == 0 ) {
      calc_stress() ;

      for ( j=0 ; j<Dim ; j++ ){ 
        for ( k=0 ; k<Dim ; k++ ) {
          sts_buf[buff_ind][j][k]= Rg3*Ptens[j][k];//( j<Dim ? Stress_bonds[j][k]:0.0) ;
           sts_buf_pp[buff_ind][j][k] = Rg3*Stress_PP[j][k];
      	   sts_buf_ng[buff_ind][j][k] = Rg3*Stress_Ng[j][k];
            
	    if( ((L_fren-L_aver) < L_flag)  and (optm_L >0) and (j ==k))
	        aver_Ptens[j][j] += Rg3*Ptens[j][j];


	/*for ( k=0 ; k<nP;  k++ ){
		//euler_adot[k][j] = euler_q[k][j];	
		sts_buf[buff_ind][j][k+Dim] = euler_q[k][j];
	}*/
	}
      }
      if(((L_fren-L_aver) < L_flag) and   (optm_L >0))
      aver_Ptens[0][1] +=1;
 
      buff_ind++ ;
    }

   if(optm_L>0  ){
    	if( step > pre_equil_steps )
       		L_flag +=1 ;

    	if(L_flag == L_fren){
       		adj_L();
		L_flag = 0 ;
               
		
		
	        fprintf( otpL , "%d %lf %lf %lf \n" ,step ,L[0],L[1],L[2]);fflush( otpL ) ;
	}		
   }//optm_L

    if(step % sample_freq == 0){
	write_np();
    }  

    
    if ( step > sample_wait && step % sample_freq == 0 ) {
     /* fftw_fwd( rho[0] , ktmp ) ;
      for ( i=0 ; i<M ; i++ ) {
        avg_sk[0][i] += ktmp[i] * conj(ktmp[i]) ;
      }

      if ( nP > 0 ) {

        fftw_fwd( rho[2] , ktmp ) ;
        for ( i=0 ; i<M ; i++ ) {
          avg_sk[2][i] += ktmp[i] * conj( ktmp[i] ) ;
        }
      }*/
   /*   for ( i=0 ; i<M ; i++ ) {
        avg_rho[0][i] += rho[0][i];
	avg_rho[1][i] += rho[1][i];
        avg_rho[3][i] += rho[3][i];
      }
    */	
     calc_Unb() ;

      fprintf( otp , "%d %d %lf %lf %lf %lf %lf %lf %lf\n" , step ,n_surf_bonds,Ubond , U_chi_gg, U_kappa_gg,U_chi_pg,U_kappa_pg,U_kappa_pp , Utt) ;
      fflush( otp ) ;



      num_averages += 1.0 ;
    }


    if ( step % print_freq == 0 || step == nsteps-1 ) {
      printf("step %d of %d  Ubond: %lf\n" , step , nsteps , Ubond ) ;
      fflush( stdout ) ;
      write_gro() ;
      write_rst_gro();
      write_quaternions();


      if ( stress_freq > 0 )
        write_stress() ;
  
      if ( wall_para && graft_surface )
        write_surface_bonds() ;

      write_grid_data( "rhoda.dat" , rhoda ) ;
      write_grid_data( "rhodb.dat" , rhodb ) ;
      
      if ( nA > 0.0 )
        write_grid_data( "rhoha.dat" , rhoha ) ;

      if ( nB > 0.0 )
        write_grid_data( "rhohb.dat" , rhohb ) ;
      if(  nC > 0.0 )
         write_grid_data( "rhohc.dat" , rhohb ) ;

      if ( nP > 0.0 ) 
        write_grid_data( "rhop.dat" , rhop ) ;

      if ( step > sample_wait ) {
       /* for ( i=0 ; i<M ; i++ ) 
          ktmp2[i] = avg_sk[0][i] / num_averages ;
        write_kspace_data( "avg_sk_A.dat" , ktmp2 ) ;
        
        if ( nP > 0 ) {
          for ( i=0 ; i<M ; i++ )
            ktmp2[i] = avg_sk[2][i] / num_averages ;
          write_kspace_data( "avg_sk_np.dat" , ktmp2 ) ;
        }*/
        	
      /*  for ( i=0 ; i<M ; i++ )
	     tmp[i] = avg_rho[0][i]/ num_averages ;
         write_grid_data("avg_typeA.dat",tmp);	

	for ( i=0 ; i<M ; i++ )
	     tmp[i] = avg_rho[1][i]/ num_averages ;
         write_grid_data("avg_typeB.dat",tmp);	

        for ( i=0 ; i<M ; i++ )
	     tmp[i] = avg_rho[3][i]/ num_averages ;
         write_grid_data("avg_typeC.dat",tmp);	
        */

      }

    //  calc_Unb() ;

     // fprintf( otp , "%d %d %lf %lf %lf %lf %lf %lf %lf\n" , step ,n_surf_bonds,Ubond , U_chi_gg, U_kappa_gg,U_chi_pg,U_kappa_pg,U_kappa_pp , Utt) ;
     // fflush( otp ) ;

    }// if step % print_Freq == 0

        if ( step == frame_freq ) {

      char nm[20] ;
      if ( nA > 0.0 ) {
        sprintf( nm , "rhoha.frame%d.dat" , step ) ;
        write_grid_data( nm , rhoha ) ;
      }
      if ( nB > 0.0 ) {
        sprintf( nm , "rhohb.frame%d.dat" , step ) ;
        write_grid_data( nm , rhohb ) ;
      }
      if ( nP > 0.0 ) {
        sprintf( nm , "rhop.frame%d.dat" , step ) ;
        write_grid_data( nm , rhop ) ;
      }
      if ( nD > 0.0 ) {
        sprintf( nm , "rhoda.frame%d.dat" , step ) ;
        write_grid_data( nm , rhoda ) ;
        sprintf( nm , "rhodb.frame%d.dat" , step ) ;
        write_grid_data( nm , rhodb ) ;
      }

      frame_freq *= 2 ;
      } 
  
  }

  fclose( otp ) ;

  return 0 ;

}
Example #26
0
 /**
  * @brief Check if an object of this type is in a valid
  * state
  *
  * @return true if valid, false otherwise
  */
 bool is_valid() const noexcept
 { return (buffer_ not_eq nullptr) and (not err_); }
Example #27
0
    // **************************************************************
    void Initialize(Double (*_function)(Double),
                    const Double _range_min, const Double _range_max,
                    const int _n, const std::string _name, Double *_table = NULL)
    {
        is_initialized = true;

        function = _function;
        name        = _name;
        n           = _n;
        range_min   = _range_min;
        range_max   = _range_max;

        if (_table != NULL)
        {
            table   = _table;
        }
        else
        {
            table   = calloc_and_check<Double>(n, "LookUpTable");
        }

        /*
         *  Example:
         *      n   = 6 points
         *      n-1 = 5 intervals
         *      dx = (xmax - xmin) / nb_intervals = (xmax - xmin) / (n-1)
         *                          x               x
         *                  x               x
         *          x
         *  x________________________________________
         *  |       |       |       |       |       |
         * xmin                                    xmax
         */
        dx          = (range_max - range_min) / Double(n-1);
        inv_dx      = Double(1.0) / dx;

        if (verbose)
        {
            Print();

            std_cout << "Building lookup table table \"" << _name << "\"..." << std::flush;
        }
        Double x = 0.0;
        int percentage = 0;

        if (function != NULL)
        {
            assert(table != NULL);

            for (int i = 0 ; i < n ; i++)
            {
                x        = Get_x_from_i(i);
                table[i] = function(x);
                percentage = int(Double(i) / Double(n) * 100.0);
                if (verbose and (percentage % 2) == 0)
                    printf(" %3d %%\b\b\b\b\b\b", percentage);
                fflush(stdout);
            }
        }
        else
        {
            if (verbose)
                std_cout << " Nothing to do since function pointer given is NULL." << std::flush;
        }
        if (verbose)
            std_cout << " Done.   \n" << std::flush;
    }
Example #28
0
void eListboxServiceContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
{
	painter.clip(eRect(offset, m_itemsize));

	int marked = 0;

	if (m_current_marked && selected)
		marked = 2;
	else if (cursorValid() && isMarked(*m_cursor))
	{
		if (selected)
			marked = 2;
		else
			marked = 1;
	}
	else
		style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);

	eListboxStyle *local_style = 0;

		/* get local listbox style, if present */
	if (m_listbox)
		local_style = m_listbox->getLocalStyle();

	if (marked == 1)  // marked
	{
		style.setStyle(painter, eWindowStyle::styleListboxMarked);
		if (m_color_set[markedForeground])
			painter.setForegroundColor(m_color[markedForeground]);
		if (m_color_set[markedBackground])
			painter.setBackgroundColor(m_color[markedBackground]);
	}
	else if (marked == 2) // marked and selected
	{
		style.setStyle(painter, eWindowStyle::styleListboxMarkedAndSelected);
		if (m_color_set[markedForegroundSelected])
			painter.setForegroundColor(m_color[markedForegroundSelected]);
		if (m_color_set[markedBackgroundSelected])
			painter.setBackgroundColor(m_color[markedBackgroundSelected]);
	}
	else if (local_style)
	{
		if (selected)
		{
			/* if we have a local background color set, use that. */
			if (local_style->m_background_color_selected_set)
				painter.setBackgroundColor(local_style->m_background_color_selected);
			/* same for foreground */
			if (local_style->m_foreground_color_selected_set)
				painter.setForegroundColor(local_style->m_foreground_color_selected);
		}
		else
		{
			/* if we have a local background color set, use that. */
			if (local_style->m_background_color_set)
				painter.setBackgroundColor(local_style->m_background_color);
			/* same for foreground */
			if (local_style->m_foreground_color_set)
				painter.setForegroundColor(local_style->m_foreground_color);
		}
	}

	if (!local_style || !local_style->m_transparent_background)
		/* if we have no transparent background */
	{
		/* blit background picture, if available (otherwise, clear only) */
		if (local_style && local_style->m_background)
			painter.blit(local_style->m_background, offset, eRect(), 0);
		else
			painter.clear();
	} else
	{
		if (local_style->m_background)
			painter.blit(local_style->m_background, offset, eRect(), gPainter::BT_ALPHABLEND);
		else if (selected && !local_style->m_selection)
			painter.clear();
	}

	if (cursorValid())
	{
		/* get service information */
		ePtr<iStaticServiceInformation> service_info;
		m_service_center->info(*m_cursor, service_info);
		eServiceReference ref = *m_cursor;
		bool isMarker = ref.flags & eServiceReference::isMarker;
		bool isPlayable = !(ref.flags & eServiceReference::isDirectory || isMarker);
		bool isRecorded = m_record_indicator_mode && isPlayable && checkServiceIsRecorded(ref,pNavigation::RecordType(pNavigation::isRealRecording|pNavigation::isUnknownRecording));
		bool isStreamed = m_record_indicator_mode && isPlayable && checkServiceIsRecorded(ref,pNavigation::isStreaming);
		bool isPseudoRecorded = m_record_indicator_mode && isPlayable && checkServiceIsRecorded(ref,pNavigation::isPseudoRecording);
		ePtr<eServiceEvent> evt;
		bool serviceAvail = true;
		bool serviceFallback = false;
		int isplayable_value;

		if (!marked && isPlayable && service_info && m_is_playable_ignore.valid())
		{
			isplayable_value = service_info->isPlayable(*m_cursor, m_is_playable_ignore);

			if (isplayable_value == 0) // service unavailable
			{
				if (m_color_set[serviceNotAvail])
					painter.setForegroundColor(m_color[serviceNotAvail]);
				else
					painter.setForegroundColor(gRGB(0xbbbbbb));
				serviceAvail = false;
			}
			else
			{
				if (isplayable_value == 2) // fallback receiver service
				{
					if (m_color_set[serviceItemFallback])
						painter.setForegroundColor(m_color[serviceItemFallback]);
					serviceFallback = true;
				}
			}
		}
		if (m_record_indicator_mode == 3 && isPseudoRecorded)
		{
			if (m_color_set[servicePseudoRecorded])
				painter.setForegroundColor(m_color[servicePseudoRecorded]);
			else
				painter.setForegroundColor(gRGB(0x41b1ec));
		}
		if (m_record_indicator_mode == 3 && isStreamed)
		{
			if (m_color_set[serviceStreamed])
				painter.setForegroundColor(m_color[serviceStreamed]);
			else
				painter.setForegroundColor(gRGB(0xf56712));
		}
		if (m_record_indicator_mode == 3 && isRecorded)
		{
			if (m_color_set[serviceRecorded])
				painter.setForegroundColor(m_color[serviceRecorded]);
			else
				painter.setForegroundColor(gRGB(0xb40431));
		}

		if (selected && local_style && local_style->m_selection)
			painter.blit(local_style->m_selection, offset, eRect(), gPainter::BT_ALPHABLEND);

		int xoffset=0;  // used as offset when painting the folder/marker symbol or the serviceevent progress
		time_t now = time(0);

		for (int e = 0; e != celServiceTypePixmap; ++e)
		{
			if (m_element_font[e])
			{
				int flags=gPainter::RT_VALIGN_CENTER;
				int yoffs = 0;
				eRect area = m_element_position[e];
				std::string text = "<n/a>";
				switch (e)
				{
				case celServiceNumber:
				{
					if (area.width() <= 0)
						continue; // no point in going on if we won't paint anything

					if( m_cursor->getChannelNum() == 0 )
						continue;

					char buffer[15];
					snprintf(buffer, sizeof(buffer), "%d", m_cursor->getChannelNum() );
					text = buffer;
					flags|=gPainter::RT_HALIGN_RIGHT;
					if (isPlayable && serviceFallback && selected && m_color_set[serviceSelectedFallback])
						painter.setForegroundColor(m_color[serviceSelectedFallback]);
					break;
				}
				case celServiceName:
				{
					if (service_info)
						service_info->getName(*m_cursor, text);
					if (!isPlayable)
					{
						area.setWidth(area.width() + m_element_position[celServiceEventProgressbar].width() +  m_nonplayable_margins);
						if (m_element_position[celServiceEventProgressbar].left() == 0)
							area.setLeft(0);
						if (m_element_position[celServiceNumber].width() && m_element_position[celServiceEventProgressbar].left() == m_element_position[celServiceNumber].width() +  m_nonplayable_margins)
							area.setLeft(m_element_position[celServiceNumber].width() +  m_nonplayable_margins);
					}
					if (!(m_record_indicator_mode == 3 && isRecorded) && isPlayable && serviceFallback && selected && m_color_set[serviceSelectedFallback])
						painter.setForegroundColor(m_color[serviceSelectedFallback]);
					break;
				}
				case celServiceInfo:
				{
					if ( isPlayable && service_info && !service_info->getEvent(*m_cursor, evt) )
					{
						std::string name = evt->getEventName();
						if (name.empty())
							continue;
						text = evt->getEventName();
						if (serviceAvail)
						{
							if (!selected && m_color_set[eventForeground])
								painter.setForegroundColor(m_color[eventForeground]);
							else if (selected && m_color_set[eventForegroundSelected])
								painter.setForegroundColor(m_color[eventForegroundSelected]);
							else
								painter.setForegroundColor(gRGB(0xe7b53f));

							if (serviceFallback && !selected && m_color_set[eventForegroundFallback]) // fallback receiver
								painter.setForegroundColor(m_color[eventForegroundFallback]);
							else if (serviceFallback && selected && m_color_set[eventForegroundSelectedFallback])
								painter.setForegroundColor(m_color[eventForegroundSelectedFallback]);

						}
						break;
					}
					continue;
				}
				case celServiceEventProgressbar:
				{
					if (area.width() > 0 && isPlayable && service_info && !service_info->getEvent(*m_cursor, evt))
					{
						char buffer[15];
						snprintf(buffer, sizeof(buffer), "%d %%", (int)(100 * (now - evt->getBeginTime()) / evt->getDuration()));
						text = buffer;
						flags|=gPainter::RT_HALIGN_RIGHT;
						break;
					}
					continue;
				}
				}

				eRect tmp = area;
				int xoffs = 0;
				ePtr<gPixmap> piconPixmap;

				if (e == celServiceName)
				{
					//picon stuff
					if (isPlayable && PyCallable_Check(m_GetPiconNameFunc))
					{
						ePyObject pArgs = PyTuple_New(1);
						PyTuple_SET_ITEM(pArgs, 0, PyString_FromString(ref.toString().c_str()));
						ePyObject pRet = PyObject_CallObject(m_GetPiconNameFunc, pArgs);
						Py_DECREF(pArgs);
						if (pRet)
						{
							if (PyString_Check(pRet))
							{
								std::string piconFilename = PyString_AS_STRING(pRet);
								if (!piconFilename.empty())
									loadPNG(piconPixmap, piconFilename.c_str());
							}
							Py_DECREF(pRet);
						}
					}
					xoffs = xoffset;
					tmp.setWidth(((!isPlayable || m_column_width == -1 || (!piconPixmap && !m_column_width)) ? tmp.width() : m_column_width) - xoffs);
				}

				eTextPara *para = new eTextPara(tmp);
				para->setFont(m_element_font[e]);
				para->renderString(text.c_str());

				if (e == celServiceName)
				{
					eRect bbox = para->getBoundBox();

					int servicenameWidth = ((!isPlayable || m_column_width == -1 || (!piconPixmap && !m_column_width)) ? bbox.width() : m_column_width);
					m_element_position[celServiceInfo].setLeft(area.left() + servicenameWidth + m_items_distances + xoffs);
					m_element_position[celServiceInfo].setTop(area.top());
					m_element_position[celServiceInfo].setWidth(area.width() - (servicenameWidth + m_items_distances + xoffs));
					m_element_position[celServiceInfo].setHeight(area.height());

					if (isPlayable)
					{
						//picon stuff
						if (PyCallable_Check(m_GetPiconNameFunc) and (m_column_width || piconPixmap))
						{
							eRect area = m_element_position[celServiceInfo];
							/* PIcons are usually about 100:60. Make it a
							 * bit wider in case the icons are diffently
							 * shaped, and to add a bit of margin between
							 * icon and text. */
							const int iconWidth = (area.height() + m_service_picon_downsize * 2) * 1.67 + m_items_distances;
							m_element_position[celServiceInfo].setLeft(area.left() + iconWidth);
							m_element_position[celServiceInfo].setWidth(area.width() - iconWidth);
							area = m_element_position[celServiceName];
							xoffs += iconWidth;
							if (piconPixmap)
							{
								area.moveBy(offset);
								painter.clip(area);
								painter.blitScale(piconPixmap,
									eRect(area.left(), area.top() - m_service_picon_downsize, iconWidth, area.height() + m_service_picon_downsize * 2),
									area,
									gPainter::BT_ALPHABLEND | gPainter::BT_KEEP_ASPECT_RATIO);
								painter.clippop();
							}
						}

						//service type marker stuff
						if (m_servicetype_icon_mode)
						{
							int orbpos = m_cursor->getUnsignedData(4) >> 16;
							const char *filename = ref.path.c_str();
							ePtr<gPixmap> &pixmap =
								(m_cursor->flags & eServiceReference::isGroup) ? m_pixmaps[picServiceGroup] :
								(strstr(filename, "://")) ? m_pixmaps[picStream] :
								(orbpos == 0xFFFF) ? m_pixmaps[picDVB_C] :
								(orbpos == 0xEEEE) ? m_pixmaps[picDVB_T] : m_pixmaps[picDVB_S];
							if (pixmap)
							{
								eSize pixmap_size = pixmap->size();
								eRect area = m_element_position[celServiceInfo];
								m_element_position[celServiceInfo].setLeft(area.left() + pixmap_size.width() + m_items_distances);
								m_element_position[celServiceInfo].setWidth(area.width() - pixmap_size.width() - m_items_distances);
								int offs = 0;
								if (m_servicetype_icon_mode == 1)
								{
									area = m_element_position[celServiceName];
									offs = xoffs;
									xoffs += pixmap_size.width() + m_items_distances;
								}
								else if (m_crypto_icon_mode == 1 && m_pixmaps[picCrypto])
									offs = offs + m_pixmaps[picCrypto]->size().width() + m_items_distances;
								int correction = (area.height() - pixmap_size.height()) / 2;
								area.moveBy(offset);
								painter.clip(area);
								painter.blit(pixmap, ePoint(area.left() + offs, offset.y() + correction), area, gPainter::BT_ALPHABLEND);
								painter.clippop();
							}
						}

						//crypto icon stuff
						if (m_crypto_icon_mode && m_pixmaps[picCrypto])
						{
							eSize pixmap_size = m_pixmaps[picCrypto]->size();
							eRect area = m_element_position[celServiceInfo];
							int offs = 0;
							if (m_crypto_icon_mode == 1)
							{
								m_element_position[celServiceInfo].setLeft(area.left() + pixmap_size.width() + m_items_distances);
								m_element_position[celServiceInfo].setWidth(area.width() - pixmap_size.width() - m_items_distances);
								area = m_element_position[celServiceName];
								offs = xoffs;
								xoffs += pixmap_size.width() + m_items_distances;
							}
							int correction = (area.height() - pixmap_size.height()) / 2;
							area.moveBy(offset);
							if (service_info->isCrypted())
							{
								if (m_crypto_icon_mode == 2)
								{
									m_element_position[celServiceInfo].setLeft(area.left() + pixmap_size.width() + m_items_distances);
									m_element_position[celServiceInfo].setWidth(area.width() - pixmap_size.width() - m_items_distances);
								}
								painter.clip(area);
								painter.blit(m_pixmaps[picCrypto], ePoint(area.left() + offs, offset.y() + correction), area, gPainter::BT_ALPHABLEND);
								painter.clippop();
							}
						}

						//record icon stuff
						if (isRecorded && m_record_indicator_mode < 3 && m_pixmaps[picRecord])
						{
							eSize pixmap_size = m_pixmaps[picRecord]->size();
							eRect area = m_element_position[celServiceInfo];
							int offs = 0;
							if (m_record_indicator_mode == 1)
							{
								m_element_position[celServiceInfo].setLeft(area.left() + pixmap_size.width() + m_items_distances);
								m_element_position[celServiceInfo].setWidth(area.width() - pixmap_size.width() - m_items_distances);
								area = m_element_position[celServiceName];
								offs = xoffs;
								xoffs += pixmap_size.width() + m_items_distances;
							}
							int correction = (area.height() - pixmap_size.height()) / 2;
							area.moveBy(offset);
							if (m_record_indicator_mode == 2)
							{
								m_element_position[celServiceInfo].setLeft(area.left() + pixmap_size.width() + m_items_distances);
								m_element_position[celServiceInfo].setWidth(area.width() - pixmap_size.width() - m_items_distances);
							}
							painter.clip(area);
							painter.blit(m_pixmaps[picRecord], ePoint(area.left() + offs, offset.y() + correction), area, gPainter::BT_ALPHABLEND);
							painter.clippop();
						}
					}
				}

				if (flags & gPainter::RT_HALIGN_RIGHT)
					para->realign(eTextPara::dirRight);
				else if (flags & gPainter::RT_HALIGN_CENTER)
					para->realign(eTextPara::dirCenter);
				else if (flags & gPainter::RT_HALIGN_BLOCK)
					para->realign(eTextPara::dirBlock);

				if (flags & gPainter::RT_VALIGN_CENTER)
				{
					eRect bbox = para->getBoundBox();
					yoffs = (area.height() - bbox.height()) / 2 - bbox.top();
				}

				painter.renderPara(para, offset+ePoint(xoffs, yoffs));
			}
			else if ((e == celFolderPixmap && m_cursor->flags & eServiceReference::isDirectory) ||
				(e == celMarkerPixmap && m_cursor->flags & eServiceReference::isMarker &&
				!(m_cursor->flags & eServiceReference::isNumberedMarker)))
			{
				ePtr<gPixmap> &pixmap =
					(e == celFolderPixmap) ? m_pixmaps[picFolder] : m_pixmaps[picMarker];
				if (pixmap)
				{
					eSize pixmap_size = pixmap->size();
					eRect area = m_element_position[e == celFolderPixmap ? celServiceName: celServiceNumber];
					int correction = (area.height() - pixmap_size.height()) / 2;
					if (e == celFolderPixmap)
						if (m_element_position[celServiceEventProgressbar].left() == 0)
							area.setLeft(0);
						xoffset = pixmap_size.width() + m_items_distances;
					area.moveBy(offset);
					painter.clip(area);
					painter.blit(pixmap, ePoint(area.left(), offset.y() + correction), area, gPainter::BT_ALPHABLEND);
					painter.clippop();
				}
			}
		}
static bool is_same_freq(const double f1, const double f2)
{
    const double epsilon = 0.1;
    return ((f1 - epsilon) < f2 and (f1 + epsilon) > f2);
}
Example #30
0
bool VEventComponent::validate()
{
    int count_uid = 0;          // MUST 1
    int count_dtstamp = 0;      // Must 1
    int count_dtstart = 0;      // MUST 1
    int count_dtend_duration = 0;   // < 2
    for( Property &prop : m_properties )
    {
        if( not prop.validate() )
            return false;
        if( prop.m_type == Property::PT_UID )
        {
            count_uid++;
            continue;
        }
        if( prop.m_type == Property::PT_DTSTAMP )
        {
            count_dtstamp++;
            continue;
        }
        if( prop.m_type == Property::PT_DTSTART )
        {
            count_dtstart++;
            continue;
        }
        if( prop.m_type == Property::PT_DTEND or prop.m_type == Property::PT_DURATION )
        {
            count_dtend_duration++;
            continue;
        }
        if( prop.m_type == Property::PT_RRULE )
        {
            int count_and_until = 0;        // MUST 0 or 1
            for( const Parameter param : prop.m_parameters )
            {
                if( param.m_type == Parameter::RR_COUNT or param.m_type == Parameter::RR_UNTIL )
                    count_and_until++;
            }
            if( count_and_until > 1 )
            {
                qDebug() << "VEventComponent::validate(): too many COUNT or UNTIL in RRULE";
                return false;
            }
        }
    }
    if( count_uid == 0 )
    {
        Property p = Property();
        QString u( "UID:DAYLIGHT-Modified-Uid" );
        u = u.append( QDateTime::currentDateTime().toString( "yyyyMMddhhmmss" ) );
        if( p.readProperty( u ) )
        {
            m_properties.append( p );
            count_uid++;
            qDebug() << " * Append UID" << u ;
        }
    }
    if( count_dtstamp == 0 )
    {
        Property p = Property();
        QString s( "DTSTAMP:" );
        s = s.append( QDateTime::currentDateTime().toString( "yyyyMMddThhmmssZ" ) );
        if( p.readProperty( s ) )
        {
            m_properties.append( p );
            count_dtstamp++;
            qDebug() << " * Append DTSTAMP" << s ;
        }
    }

    bool alarm_ok = true;
    for( VAlarmComponent va : m_vAlarmComponents )
        alarm_ok = alarm_ok and va.validate();
    if( not alarm_ok )
        qDebug() << " * Alarm not ok.";

    bool ret = alarm_ok and ( count_uid == 1 ) and ( count_dtstamp == 1 ) and
            ( count_dtstart == 1 ) and ( count_dtend_duration < 2 ) ;
    if( not ret ) qDebug() << " Validate VEventComponent FALSE";
    return ret;
}