PassOwnPtr<CCAnimationCurve> CCKeyframedTransformAnimationCurve::clone() const
{
OwnPtr<CCKeyframedTransformAnimationCurve> toReturn(CCKeyframedTransformAnimationCurve::create());
for (size_t i = 0; i < m_keyframes.size(); ++i)
toReturn->addKeyframe(m_keyframes[i]->clone());
return toReturn.release();
}
bool Ray::GetRefracted( Ray& outRay, const glm::vec3& normal,
const glm::vec3& hitPt, float matRefrIndex) const{
glm::vec3 incident = hitPt - this->m_start;
glm::vec3 normalNormal = glm::normalize( normal ); //normalized normal
incident = glm::normalize( incident );
if( isInside ){
matRefrIndex = 1.0f; //air
}
float nRatio = this->m_start_refr_ind / matRefrIndex;
float critDisc = 1 - nRatio*nRatio*( 1 -
(float)pow(glm::dot(normal, incident), 2) );
//NOTE: we are omitting the case where critical angle == incident angle.
//In practice, it probably won't happen due to floating point.
if( critDisc < 0 ) { //critical angle, ray gets reflected
return false;
} else {
float nScale = -1 * nRatio * glm::dot(normalNormal, incident) -
(float)sqrt(critDisc);
glm::vec3 transmitDir = nScale * normalNormal + nRatio * incident;
transmitDir = glm::normalize( transmitDir );
Ray toReturn( hitPt + 0.001f * transmitDir, transmitDir );
toReturn.m_start_refr_ind = matRefrIndex;
toReturn.isInside = !this->isInside;
outRay = toReturn;
return true;
}
}
CoefficientSpectrum operator*( float c, const CoefficientSpectrum& s ){
CoefficientSpectrum toReturn( s.getDim() );
for( int i = 0; i < s.getDim(); i++ ){
toReturn.m_v[i] = s.m_v[i] * c;
}
return toReturn;
}
std::string Client::moveString(const Move &move, Piece promotionChoice) const
{
std::string toReturn(colToString(move.square_1.col) + std::to_string(move.square_1.row+1)
+ colToString(move.square_2.col) + std::to_string(move.square_2.row+1));
if (promotionChoice != Piece::None) toReturn += "=" + pieceToSymbol(promotionChoice);
return toReturn;
}
Pattern ParallelInfo::rcvZi()
{
int P_Tag = 0;
MPI_Status P_Status;
#if defined(TIMING_MODE)
start = rdtsc();
#endif
#if defined(RNG_BUCKET)
P_RandComm->Recv(&(P_Nodes[0].P_zi[0]), totalNumNrns, MPI_INT,
P_ROOT_NODE_NUM, P_Tag, MPI_COMM_WORLD, &P_Status);
#else
MPI_Recv(&(P_Nodes[0].P_zi[0]), totalNumNrns, MPI_INT, P_ROOT_NODE_NUM,
P_Tag, MPI_COMM_WORLD, &P_Status);
#endif
#if defined(TIMING_MODE)
elapsed = rdtsc() - start;
Output::Out() << MSG << "Elapsed nonroot_rcv time = "
<< elapsed * 1.0 / TICKS_PER_SEC << " seconds" << endl;
#endif
Pattern toReturn(totalNumNrns);
for (unsigned int i = 0; i < totalNumNrns; i++)
toReturn.at(i) = P_Nodes[0].P_zi[i];
return toReturn;
}
std::string uParserBed::_getNextEntry(char* line)
{
char toReturnChar[4096];
int i = 0;
/**< Fetch the next entry */
do
{
toReturnChar[i] = line[i];
i++;
} while (line[i] != m_delimiter && line[i] != '\0');
toReturnChar[i] = '\0';
/**< Remove fetched entry from line */
int j = 0;
if (line[i] != '\0')
{
i++;
do
{
line[j] = line[i];
i++;
j++;
} while (line[i] != '\n' && line[i] != '\0');
}
line[j] = '\0';
std::string toReturn(toReturnChar);
return toReturn;
}
/// gets a user-inputted string until return is entered
/// will use getChar to process characters one by one so that individual
/// key handlers can be created
std::string getInputString(teasafe::TeaSafe &theBfs, std::string const &workingPath)
{
std::string toReturn("");
// disable echo and prevent need to press enter for getchar flush
setupTerminal();
int cursorPos(0);
while(1) {
char c = getchar();
if((int)c == 10) { // enter
std::cout<<std::endl;
break;
}
if((int)c == 127 || (int)c == 8) { // delete / backspace
handleBackspace(cursorPos, toReturn);
} else if((int)c == 9) { // tab
handleTabKey(theBfs, workingPath, cursorPos, toReturn);
} else { // print out char to screen and push into string vector
std::cout<<c;
++cursorPos;
toReturn.push_back(c);
}
}
return toReturn;
}
//----------------------------------------------------------------------------------------
// ConvertPageItemInnerToSpread
//----------------------------------------------------------------------------------------
PMRect
CZExpPageItemUtils::ConvertPageItemInnerToSpread(
const ISpread * inSpread,
const IGeometry * inPageItemGeometry,
const PMRect & inPageItemRect) const
{
PMRect toReturn(inPageItemRect);
#if 1
InterfacePtr<const ITransform> spreadTransform( inSpread, UseDefaultIID() );
ASSERT( inSpread );
InterfacePtr<const ITransform> pageItemTransform( inPageItemGeometry, UseDefaultIID() );
ASSERT( pageItemTransform );
PMMatrix pageItemToSpreadMatrix;
pageItemTransform->GetInnerToRootMatrix( &pageItemToSpreadMatrix, spreadTransform );
pageItemToSpreadMatrix.Transform( &toReturn );
#else
TransformInnerRectToParent( inPageItemGeometry, &toReturn ); //Page item parent is spread.
#endif
return toReturn;
}
elliptic_point elliptic_point::operator+(const elliptic_point &P) const{
int lambda = 0;
elliptic_point toReturn(0,0);
if(this->isPOI)
return P;
else if(P.isPOI)
return (*this);
if((*this) == P){
if(P.y == 0){
toReturn.isPOI = true;
return toReturn;
}
int twoypinv = modular_inverse(modular_positive(2 * P.y, mod), mod);
lambda = modular_positive((3 * P.x * P.x + a) * twoypinv, mod);
}else{
if(this->x == P.x){
toReturn.isPOI = true;
return toReturn;
}
int xsinv = modular_inverse(modular_positive(this->x - P.x, mod), mod);
lambda = modular_positive((this->y - P.y) * xsinv, mod);
}
toReturn.x = modular_positive(((lambda * lambda) - (P.x) - (this->x)), mod);
toReturn.y = modular_positive(((lambda * (P.x - toReturn.x)) - P.y), mod);
return toReturn;
}
CoefficientSpectrum CoefficientSpectrum::operator*( float c ) const{
CoefficientSpectrum toReturn( m_dim );
for( int i = 0; i < m_dim; i++ ){
toReturn.m_v[i] = this->m_v[i] * c;
}
return toReturn;
}
Point3D Shot::getWallIntersectionPoint(BoundingWall* wall) {
if (!isBeam) {
return Object3D::getWallIntersectionPoint(wall);
}
Point3D toReturn(*position);
Point3D pointOnPlane = wall->normal.scalarMultiply(-wall->wallSize);
// Calculate intersection between beam and wall.
Vector3D normalizedDirection = velocity->getNormalized();
Vector3D wallNormal = wall->normal.scalarMultiply(-1); // To make it face away from the center.
double rayDotNormal = normalizedDirection.dot(wallNormal);
if (rayDotNormal <= 0) {
wall->actuallyHit = false;
return toReturn;
}
Vector3D rayOriginToPointOnPlane(*position, pointOnPlane);
double distance = rayOriginToPointOnPlane.dot(wallNormal) / rayDotNormal;
if (distance < 0) {
wall->actuallyHit = false;
return toReturn;
}
toReturn.addUpdate(normalizedDirection.scalarMultiply(distance));
return toReturn;
}
// Prints out short options with a leading '-' and long ones with '--'.
// Puts a ',' between them if it has both.
string CommandOption::getFullOptionString() const
{
string toReturn(" ");
if (shortOpt != 0)
{
toReturn += string("-") + string(1, shortOpt);
if (!longOpt.empty())
{
toReturn += string(", --") + longOpt;
if (optFlag == hasArgument)
toReturn += "=" + getArgString();
}
else
{
if (optFlag == hasArgument)
toReturn += " " + getArgString();
}
}
else
{
toReturn += string(" --") + longOpt;
if (optFlag == hasArgument)
toReturn += "=" + getArgString();
}
return toReturn;
}
// turns a string into its lowercase...
inline std::string tolcstr(const std::string& s)
{
std::string::size_type i;
std::string toReturn(s);
for (i = 0; i < s.size(); i++)
toReturn[i] = tolower(s[i]);
return toReturn;
}
CoefficientSpectrum CoefficientSpectrum::operator*(
const CoefficientSpectrum &s2 ) const{
CoefficientSpectrum toReturn( m_dim );
for( int i = 0; i < m_dim; i++ ){
toReturn.m_v[i] = this->m_v[i] * s2.m_v[i];
}
return toReturn;
}
/**
* \brief Retrieves all the data currently entered in each of the
* individual widgets and compiles it into a TwoDArray.
*
* @return A TwoDArray representing the current values in the
* idividual widgets.
*/
TwoDArray<S> getArrayFromWidgets() {
Teuchos::TwoDArray<QWidget*>::size_type numRows =
widgetArray.getNumRows()-1;
Teuchos::TwoDArray<QWidget*>::size_type numCols =
widgetArray.getNumCols()-1;
TwoDArray<S> toReturn(
numRows, numCols);
int numColsToIterate =0;
for(int i=0; i<numRows; ++i) {
numColsToIterate = baseArray.isSymmetrical() ?
numCols-numRows+i : numCols;
for(int j=0; j<numColsToIterate; ++j) {
toReturn(i,j) = getWidgetValue(i+1,j+1);
}
}
toReturn.setSymmetrical(baseArray.isSymmetrical());
return toReturn;
}
Graph< typename F::node_type, typename F::edge_type > *copy_topology( const Graph<N,E>& originalGraph, F& creator )
{
// We need to go through all the nodes and edges, using the function to copy them.
std::auto_ptr< Graph< typename F::node_type, typename F::edge_type > > toReturn( new Graph< typename F::node_type, typename F::edge_type >() );
hidden_copy_topology( *toReturn, originalGraph, creator );
return toReturn.release();
}
CadenaDeBits Tabla::agregarString(string cadena){
CadenaDeBits toReturn(this->cantidadBitsTabla, this->tabla->size());
(*this->mapa)[cadena] = (int)this->tabla->size();
this->tabla->push_back(cadena);
this->lastCode++;
int maxValor = (pow(2.0,(int)(this->cantidadBitsTabla)));
if(this->lastCode >= maxValor){
this->cantidadBitsTabla++;
}
return toReturn;
}
// post decrement
delay_t operator--( int ) {
delay_t toReturn( *this );
if ( counter > 1 ) {
counter -= 1;
} else {
counter = 0;
}
return toReturn;
}
PassOwnPtr<CCActiveAnimation> CCActiveAnimation::cloneForImplThread() const
{
OwnPtr<CCActiveAnimation> toReturn(adoptPtr(new CCActiveAnimation(m_curve->clone(), m_id, m_group, m_targetProperty)));
toReturn->m_runState = m_runState;
toReturn->m_iterations = m_iterations;
toReturn->m_startTime = m_startTime;
toReturn->m_pauseTime = m_pauseTime;
toReturn->m_totalPausedTime = m_totalPausedTime;
toReturn->m_timeOffset = m_timeOffset;
return toReturn.release();
}
//----------------------------------------------------------------------------------------
// ConvertSpreadInnerToPageInner
//----------------------------------------------------------------------------------------
PMRect
CZExpPageItemUtils::ConvertSpreadInnerToPageInner(
const IGeometry * inPageGeometry,
const PMRect & inRectOnSpread) const
{
PMRect toReturn(inRectOnSpread);
TransformParentRectToInner( inPageGeometry, &toReturn );
return toReturn;
}
Matrix<int> zeroCrossing(Matrix<double> M){
Matrix<int> toReturn(M.getXdim(), M.getYdim());
for(unsigned int i=0; i<M.getXdim()-1;++i)
for(unsigned int j=0; j<M.getYdim()-1;++j){
double nx = M(i+1, j);//this->p[i+1][j];
double ny = M(i, j+1);//this->p[i][j+1];
double current = M(i,j);//this->p[i][j];
if((nx>0 && current<0) || (nx<0 && current>0) || (nx==0 && current>0) || (nx>0 && current==0)){
if(fabs(nx)<fabs(current))
toReturn(i+1,j) = 1;//m.p[i+1][j] = 1;
else
toReturn(i,j) = 1;//m.p[i][j] = 1;
}
if((ny>0 && current<0) || (ny<0 && current>0) || (ny==0 && current>0) || (ny>0 && current ==0)){
if(fabs(ny)<fabs(current))
toReturn(i, j+1) = 1;//m.p[i][j+1] = 1;
else
toReturn(i, j) = 1;//m.p[i][j] = 1;
}
}
return toReturn;
}
inline std::string ReadStringFromBuffer(const IReadBuffer &buf)
{
NTA_Byte *value = 0;
NTA_UInt32 size = 0;
NTA_Int32 result = buf.readString(value, size,
_ReadString_alloc, _ReadString_dealloc);
if(result != 0)
throw std::runtime_error("Failed to read string from stream.");
std::string toReturn(value, size);
// Real fps must be provided to use delete here.
delete[] value;
return toReturn;
}
PassOwnPtr<CCActiveAnimation> CCActiveAnimation::cloneAndInitialize(InstanceType instanceType, RunState initialRunState, double startTime) const
{
OwnPtr<CCActiveAnimation> toReturn(adoptPtr(new CCActiveAnimation(m_curve->clone(), m_id, m_group, m_targetProperty)));
toReturn->m_runState = initialRunState;
toReturn->m_iterations = m_iterations;
toReturn->m_startTime = startTime;
toReturn->m_pauseTime = m_pauseTime;
toReturn->m_totalPausedTime = m_totalPausedTime;
toReturn->m_timeOffset = m_timeOffset;
toReturn->m_alternatesDirection = m_alternatesDirection;
toReturn->m_isControllingInstance = instanceType == ControllingInstance;
return toReturn.release();
}
string getEnvDirPath(cchar *envVarName)
{
cchar* dir = std::getenv(envVarName);
if (dir == NULL || dir[0] == 0) {
CORE_ASSERT_FAIL_P(("Missed environment variable %s", envVarName));
return "";
}
string toReturn(dir);
if (!STR_HAS_SLASH_AT_END(toReturn)) {
toReturn += PATH_SEPARATOR;
}
return toReturn;
}
std::string lggHunSpell_Wrapper::VEC2CSV(std::vector<std::string> vec)
{
std::string toReturn("");
if (vec.size() < 1)
{
return toReturn;
}
for (int i = 0;i < (int)vec.size() ;i++)
{
toReturn += vec[i] + ",";
}
return toReturn.erase(toReturn.length()-1);
}
/*! \brief Verify command line parameters.
* \details Trim the parameters' line; remove everything after && or ; to prevent maluse.
* \param[in] in Original parameters as string
* \returns Modified parameters.
*/
BString ActivityData::VerifyCommandLineParameters( const BString& in )
{
BString toReturn( in );
int32 tempInt;
toReturn.Trim();
if ( ( ( tempInt = toReturn.FindFirst( "&&" ) ) != B_ERROR ) ||
( ( tempInt = toReturn.FindFirst( ";" ) ) != B_ERROR ) )
{
toReturn.Truncate( tempInt );
}
return toReturn;
} // <-- end of function ActivityData::VerifyCommandLineParameters
complex transmissioncom::getFromTransmissionSolver()
{
complex toReturn(0,0);
Message *myMesg=myinterface->getNextInboxMessage();
const uint8_t* data=myMesg->getData();
double realPart;
double imagineryPart;
memcpy(&realPart,data,sizeof(double));
memcpy(&imagineryPart,&data[sizeof(double)],sizeof(double));
toReturn.SetReal(realPart);
toReturn.SetImag(imagineryPart);
delete myMesg;
return toReturn;
}
//Refraction formula from Norm's notes...
const Ray Ray::GetRefracted( const glm::vec3& normal,
const glm::vec3& hitPt, float matRefrIndex) const{
glm::vec3 incident = hitPt - this->m_start;
glm::vec3 normalNormal = glm::normalize( normal ); //normalized normal
incident = glm::normalize( incident );
//making a BOLD assumption here. If our starting refractive
//index is the same as the index of the material we hit, then
//we started "inside" the material and now we are hitting the other side.
//ASSUMING no transparent materials inside each other (e.g. a glass of water)
//then we can set matRefrIndex to 1 (air/vacuum).
//bool isLeavingMat = false;
//if( m_start_refr_ind < matRefrIndex + RAY_EPSILON &&
//m_start_refr_ind > matRefrIndex - RAY_EPSILON ){
//matRefrIndex = 1.0f;
//isLeavingMat = true;
//}
if( isInside ){
matRefrIndex = 1.0f; //air
}
float nRatio = this->m_start_refr_ind / matRefrIndex;
float critDisc = 1 - nRatio*nRatio*( 1 -
(float)pow(glm::dot(normal, incident), 2) );
//NOTE: we are omitting the case where critical angle == incident angle.
//In practice, it probably won't happen due to floating point.
if( critDisc < 0 ) { //critical angle, ray gets reflected
//std::cout << "TOTAL INTERNAL REFLECTION" << std::endl;
Ray toReturn = GetReflected( normal, hitPt );
toReturn.m_start_refr_ind = matRefrIndex;
return toReturn;
} else {
float nScale = -1 * nRatio * glm::dot(normalNormal, incident) -
(float)sqrt(critDisc);
glm::vec3 transmitDir = nScale * normalNormal + nRatio * incident;
transmitDir = glm::normalize( transmitDir );
Ray toReturn( hitPt + 0.001f * transmitDir, transmitDir );
toReturn.m_start_refr_ind = matRefrIndex;
toReturn.isInside = !this->isInside;
return toReturn;
}
}
//2D Laplacian 3x3 edge filter (in pixel space, so it's slow)
PGMImage PGMImage::getEdges() {
PGMImage toReturn(width, height);
for (int i = 1; i < width - 1; i++) {
for (int j = 1; j < height - 1; j++) {
int total = 8 * getPixel(i, j);
for (int p = -1; p <= 1; p++) {
for (int q = -1; q <= 1; q++) {
if (!(p == 0 && q == 0))
total -= getPixel(i + p, j + q);
}
}
toReturn.setPixel(i, j, (BYTE)total);
}
}
return toReturn;
}
User FilesystemData::getUser( string name ) {
ENTER( "FilesystemData::getUser" );
if( !doesUserExist(name) ) {
Logger::error() << "No such user";
throw std::exception();
}
string serRole;
Io::initFromFile( getUserPath( name ), serRole );
User toReturn( name, User::roleFromString(serRole) );
EXIT( "FilesystemData::getUser" );
return toReturn;
}
