int main(int argc, char** argv) {
int menuNum;
printf("1 = IF Statement:PH Level | 2 = Loops:Fibonacci Series| 3 = Array:Temperature| 4 = Methods:Number to Words ");
printf("Please enter a number for what you would like to see:");
scanf( "%d", & menuNum);
if (menuNum == 1) {
ifStatement();
} else if(menuNum == 2){
loops();
} else if(menuNum == 3){
arrays();
} else if(menuNum == 4){
methods();
}
void ifStatement(){
//Variables
double pH;
printf("Acid Rain\n");
printf("Acid Rain is an enviromentmatal problem. This program determines if the pH level in water is safe for fish.");
printf(" \nEnter pH level:");
scanf( "%d", & pH);
if( pH < 0 | pH > 14 ) {
printf( "ERROR");
}
else if(pH < 6.5) {
printf("TOO ACIDIC - FISH IN STREAMS, RIVERS AND LAKES WILL NOT SURVIVE.");
} else if (pH > 7.5) {
printf("TOO ALKALINE - FISH IN STREAMS, RIVERS AND LAKES WILL NOT SURVIVE");
} else {
printf("NEUTRAL - FISH IN STREAMS, RIVERS AND LAKES WILL SURVIVE.");
}
}
static node_t *func_or_array(bool abstract, int *params)
{
node_t *ty = NULL;
int follow[] = { '[', ID, IF, 0 };
for (; token->id == '(' || token->id == '[';) {
if (token->id == '[') {
node_t *atype;
expect('[');
atype = arrays(abstract);
match(']', follow);
attach_type(&ty, atype);
} else {
node_t *ftype = func_type();
expect('(');
TYPE_PARAMS(ftype) = parameters(ftype, params);
match(')', follow);
attach_type(&ty, ftype);
}
}
return ty;
}
bool FArchiveXML::LoadAnimationChannel(FCDObject* object, xmlNode* channelNode)
{
FCDAnimationChannel* animationChannel = (FCDAnimationChannel*)object;
FCDAnimationChannelData& data = FArchiveXML::documentLinkDataMap[animationChannel->GetDocument()].animationChannelData[animationChannel];
bool status = true;
// Read the channel-specific ID
fm::string daeId = ReadNodeId(channelNode);
fm::string samplerId = ReadNodeSource(channelNode);
ReadNodeTargetProperty(channelNode, data.targetPointer, data.targetQualifier);
#ifdef DONT_DEFINE_THIS
FCDAnimation* anim = animationChannel->GetParent();
FCDExtra* extra = anim->GetExtra();
extra->SetTransientFlag(); // Dont save this, its wasted whatever it is.
FCDEType* type = extra->AddType("AnimTargets");
FCDETechnique* teq = type->AddTechnique("TEMP");
teq->AddChildNode("pointer")->SetContent(TO_FSTRING(data.targetPointer));
teq->AddChildNode("pointer")->SetContent(TO_FSTRING(data.targetQualifier));
#endif
xmlNode* samplerNode = FArchiveXML::FindChildByIdFCDAnimation(animationChannel->GetParent(), samplerId);
if (samplerNode == NULL || !IsEquivalent(samplerNode->name, DAE_SAMPLER_ELEMENT))
{
FUError::Error(FUError::ERROR_LEVEL, FUError::ERROR_MISSING_ELEMENT, channelNode->line);
return false;
}
// Find and process the sources
xmlNode* inputSource = NULL, * outputSource = NULL, * inTangentSource = NULL, * outTangentSource = NULL, * tcbSource = NULL, * easeSource = NULL, * interpolationSource = NULL;
xmlNodeList samplerInputNodes;
fm::string inputDriver;
FindChildrenByType(samplerNode, DAE_INPUT_ELEMENT, samplerInputNodes);
for (size_t i = 0; i < samplerInputNodes.size(); ++i) // Don't use iterator here because we are possibly appending source nodes in the loop
{
xmlNode* inputNode = samplerInputNodes[i];
fm::string sourceId = ReadNodeSource(inputNode);
xmlNode* sourceNode = FArchiveXML::FindChildByIdFCDAnimation(animationChannel->GetParent(), sourceId);
fm::string sourceSemantic = ReadNodeSemantic(inputNode);
if (sourceSemantic == DAE_INPUT_ANIMATION_INPUT) inputSource = sourceNode;
else if (sourceSemantic == DAE_OUTPUT_ANIMATION_INPUT) outputSource = sourceNode;
else if (sourceSemantic == DAE_INTANGENT_ANIMATION_INPUT) inTangentSource = sourceNode;
else if (sourceSemantic == DAE_OUTTANGENT_ANIMATION_INPUT) outTangentSource = sourceNode;
else if (sourceSemantic == DAEFC_TCB_ANIMATION_INPUT) tcbSource = sourceNode;
else if (sourceSemantic == DAEFC_EASE_INOUT_ANIMATION_INPUT) easeSource = sourceNode;
else if (sourceSemantic == DAE_INTERPOLATION_ANIMATION_INPUT) interpolationSource = sourceNode;
else if (sourceSemantic == DAEMAYA_DRIVER_INPUT) inputDriver = sourceId;
}
if (inputSource == NULL || outputSource == NULL)
{
FUError::Error(FUError::ERROR_LEVEL, FUError::ERROR_MISSING_INPUT, samplerNode->line);
return false;
}
// Calculate the number of curves that in contained by this channel
xmlNode* outputAccessor = FindTechniqueAccessor(outputSource);
fm::string accessorStrideString = ReadNodeProperty(outputAccessor, DAE_STRIDE_ATTRIBUTE);
uint32 curveCount = FUStringConversion::ToUInt32(accessorStrideString);
if (curveCount == 0) curveCount = 1;
// Create the animation curves
for (uint32 i = 0; i < curveCount; ++i)
{
animationChannel->AddCurve();
}
// Read in the animation curves
// The input keys and interpolations are shared by all the curves
FloatList inputs;
ReadSource(inputSource, inputs);
size_t keyCount = inputs.size();
if (keyCount == 0) return true; // Valid although very boring channel.
UInt32List interpolations; interpolations.reserve(keyCount);
ReadSourceInterpolation(interpolationSource, interpolations);
if (interpolations.size() < keyCount)
{
// Not enough interpolation types provided, so append BEZIER as many times as needed.
interpolations.insert(interpolations.end(), keyCount - interpolations.size(), FUDaeInterpolation::FromString(""));
}
// Read in the interleaved outputs as floats
fm::vector<FloatList> tempFloatArrays;
tempFloatArrays.resize(curveCount);
fm::pvector<FloatList> outArrays(curveCount);
for (uint32 i = 0; i < curveCount; ++i) outArrays[i] = &tempFloatArrays[i];
ReadSourceInterleaved(outputSource, outArrays);
for (uint32 i = 0; i < curveCount; ++i)
{
// Fill in the output array with zeroes, if it was not large enough.
if (tempFloatArrays[i].size() < keyCount)
{
tempFloatArrays[i].insert(tempFloatArrays[i].end(), keyCount - tempFloatArrays[i].size(), 0.0f);
}
// Create all the keys, on the curves, according to the interpolation types.
for (size_t j = 0; j < keyCount; ++j)
{
FCDAnimationKey* key = animationChannel->GetCurve(i)->AddKey((FUDaeInterpolation::Interpolation) interpolations[j]);
key->input = inputs[j];
key->output = tempFloatArrays[i][j];
// Set the default values for Bezier/TCB interpolations.
if (key->interpolation == FUDaeInterpolation::BEZIER)
{
FCDAnimationKeyBezier* bkey = (FCDAnimationKeyBezier*) key;
float previousInput = (j == 0) ? inputs[j] - 1.0f : inputs[j-1];
float nextInput = (j == keyCount - 1) ? inputs[j] + 1.0f : inputs[j+1];
bkey->inTangent.x = (previousInput + 2.0f * bkey->input) / 3.0f;
bkey->outTangent.x = (nextInput + 2.0f * bkey->input) / 3.0f;
bkey->inTangent.y = bkey->outTangent.y = bkey->output;
}
else if (key->interpolation == FUDaeInterpolation::TCB)
{
FCDAnimationKeyTCB* tkey = (FCDAnimationKeyTCB*) key;
tkey->tension = tkey->continuity = tkey->bias = 0.5f;
tkey->easeIn = tkey->easeOut = 0.0f;
}
}
}
tempFloatArrays.clear();
// Read in the interleaved in_tangent source.
if (inTangentSource != NULL)
{
fm::vector<FMVector2List> tempVector2Arrays;
tempVector2Arrays.resize(curveCount);
fm::pvector<FMVector2List> arrays(curveCount);
for (uint32 i = 0; i < curveCount; ++i) arrays[i] = &tempVector2Arrays[i];
uint32 stride = ReadSourceInterleaved(inTangentSource, arrays);
if (stride == curveCount)
{
// Backward compatibility with 1D tangents.
// Remove the relativity from the 1D tangents and calculate the second-dimension.
for (uint32 i = 0; i < curveCount; ++i)
{
FMVector2List& inTangents = tempVector2Arrays[i];
FCDAnimationKey** keys = animationChannel->GetCurve(i)->GetKeys();
size_t end = min(inTangents.size(), keyCount);
for (size_t j = 0; j < end; ++j)
{
if (keys[j]->interpolation == FUDaeInterpolation::BEZIER)
{
FCDAnimationKeyBezier* bkey = (FCDAnimationKeyBezier*) keys[j];
bkey->inTangent.y = bkey->output - inTangents[j].x;
}
}
}
}
else if (stride == curveCount * 2)
{
// This is the typical, 2D tangent case.
for (uint32 i = 0; i < curveCount; ++i)
{
FMVector2List& inTangents = tempVector2Arrays[i];
FCDAnimationKey** keys = animationChannel->GetCurve(i)->GetKeys();
size_t end = min(inTangents.size(), keyCount);
for (size_t j = 0; j < end; ++j)
{
if (keys[j]->interpolation == FUDaeInterpolation::BEZIER)
{
FCDAnimationKeyBezier* bkey = (FCDAnimationKeyBezier*) keys[j];
bkey->inTangent = inTangents[j];
}
}
}
}
}
// Read in the interleaved out_tangent source.
if (outTangentSource != NULL)
{
fm::vector<FMVector2List> tempVector2Arrays;
tempVector2Arrays.resize(curveCount);
fm::pvector<FMVector2List> arrays(curveCount);
for (uint32 i = 0; i < curveCount; ++i) arrays[i] = &tempVector2Arrays[i];
uint32 stride = ReadSourceInterleaved(outTangentSource, arrays);
if (stride == curveCount)
{
// Backward compatibility with 1D tangents.
// Remove the relativity from the 1D tangents and calculate the second-dimension.
for (uint32 i = 0; i < curveCount; ++i)
{
FMVector2List& outTangents = tempVector2Arrays[i];
FCDAnimationKey** keys = animationChannel->GetCurve(i)->GetKeys();
size_t end = min(outTangents.size(), keyCount);
for (size_t j = 0; j < end; ++j)
{
if (keys[j]->interpolation == FUDaeInterpolation::BEZIER)
{
FCDAnimationKeyBezier* bkey = (FCDAnimationKeyBezier*) keys[j];
bkey->outTangent.y = bkey->output + outTangents[j].x;
}
}
}
}
else if (stride == curveCount * 2)
{
// This is the typical, 2D tangent case.
for (uint32 i = 0; i < curveCount; ++i)
{
FMVector2List& outTangents = tempVector2Arrays[i];
FCDAnimationKey** keys = animationChannel->GetCurve(i)->GetKeys();
size_t end = min(outTangents.size(), keyCount);
for (size_t j = 0; j < end; ++j)
{
if (keys[j]->interpolation == FUDaeInterpolation::BEZIER)
{
FCDAnimationKeyBezier* bkey = (FCDAnimationKeyBezier*) keys[j];
bkey->outTangent = outTangents[j];
}
}
}
}
}
if (tcbSource != NULL)
{
//Process TCB parameters
fm::vector<FMVector3List> tempVector3Arrays;
tempVector3Arrays.resize(curveCount);
fm::pvector<FMVector3List> arrays(curveCount);
for (uint32 i = 0; i < curveCount; ++i) arrays[i] = &tempVector3Arrays[i];
ReadSourceInterleaved(tcbSource, arrays);
for (uint32 i = 0; i < curveCount; ++i)
{
FMVector3List& tcbs = tempVector3Arrays[i];
FCDAnimationKey** keys = animationChannel->GetCurve(i)->GetKeys();
size_t end = min(tcbs.size(), keyCount);
for (size_t j = 0; j < end; ++j)
{
if (keys[j]->interpolation == FUDaeInterpolation::TCB)
{
FCDAnimationKeyTCB* tkey = (FCDAnimationKeyTCB*) keys[j];
tkey->tension = tcbs[j].x;
tkey->continuity = tcbs[j].y;
tkey->bias = tcbs[j].z;
}
}
}
}
if (easeSource != NULL)
{
//Process Ease-in and ease-out data
fm::vector<FMVector2List> tempVector2Arrays;
tempVector2Arrays.resize(curveCount);
fm::pvector<FMVector2List> arrays(curveCount);
for (uint32 i = 0; i < curveCount; ++i) arrays[i] = &tempVector2Arrays[i];
ReadSourceInterleaved(easeSource, arrays);
for (uint32 i = 0; i < curveCount; ++i)
{
FMVector2List& eases = tempVector2Arrays[i];
FCDAnimationKey** keys = animationChannel->GetCurve(i)->GetKeys();
size_t end = min(eases.size(), keyCount);
for (size_t j = 0; j < end; ++j)
{
if (keys[j]->interpolation == FUDaeInterpolation::TCB)
{
FCDAnimationKeyTCB* tkey = (FCDAnimationKeyTCB*) keys[j];
tkey->easeIn = eases[j].x;
tkey->easeOut = eases[j].y;
}
}
}
}
// Read in the pre/post-infinity type
xmlNodeList mayaParameterNodes; StringList mayaParameterNames;
xmlNode* mayaTechnique = FindTechnique(inputSource, DAEMAYA_MAYA_PROFILE);
FindParameters(mayaTechnique, mayaParameterNames, mayaParameterNodes);
size_t parameterCount = mayaParameterNodes.size();
for (size_t i = 0; i < parameterCount; ++i)
{
xmlNode* parameterNode = mayaParameterNodes[i];
const fm::string& paramName = mayaParameterNames[i];
const char* content = ReadNodeContentDirect(parameterNode);
if (paramName == DAEMAYA_PREINFINITY_PARAMETER)
{
size_t curveCount = animationChannel->GetCurveCount();
for (size_t c = 0; c < curveCount; ++c)
{
animationChannel->GetCurve(c)->SetPreInfinity(FUDaeInfinity::FromString(content));
}
}
else if (paramName == DAEMAYA_POSTINFINITY_PARAMETER)
{
size_t curveCount = animationChannel->GetCurveCount();
for (size_t c = 0; c < curveCount; ++c)
{
animationChannel->GetCurve(c)->SetPostInfinity(FUDaeInfinity::FromString(content));
}
}
else
{
// Look for driven-key input target
if (paramName == DAE_INPUT_ELEMENT)
{
fm::string semantic = ReadNodeSemantic(parameterNode);
if (semantic == DAEMAYA_DRIVER_INPUT)
{
inputDriver = ReadNodeSource(parameterNode);
}
}
}
}
if (!inputDriver.empty())
{
const char* driverTarget = FUDaeParser::SkipPound(inputDriver);
if (driverTarget != NULL)
{
fm::string driverQualifierValue;
FUStringConversion::SplitTarget(driverTarget, data.driverPointer, driverQualifierValue);
data.driverQualifier = FUStringConversion::ParseQualifier(driverQualifierValue);
if (data.driverQualifier < 0) data.driverQualifier = 0;
}
}
animationChannel->SetDirtyFlag();
return status;
}
/*
* Initialization function of arrays extension module which is automatically invoked
* by SBMLExtensionRegister class before main() function invoked.
*/
void
ArraysExtension::init()
{
//----------------------------------------------------------------
//
// 1. Check if the arrays package has already been registered
//
//----------------------------------------------------------------
if (SBMLExtensionRegistry::getInstance().isRegistered(getPackageName()))
{
// do nothing
return;
}
//----------------------------------------------------------------
//
// 2. Creates an SBMLExtension derived object
//
//----------------------------------------------------------------
ArraysExtension arraysExtension;
//----------------------------------------------------------------
//
// 3. Creates the SBasePlugins required by this package
//
//----------------------------------------------------------------
std::vector<std::string> packageURIs;
packageURIs.push_back(getXmlnsL3V1V1());
SBaseExtensionPoint sbmldocExtPoint("core", SBML_DOCUMENT);
SBaseExtensionPoint sbaseExtPoint("all", SBML_GENERIC_SBASE);
SBasePluginCreator<ArraysSBMLDocumentPlugin, ArraysExtension> sbmldocPluginCreator(sbmldocExtPoint, packageURIs);
SBasePluginCreator<ArraysSBasePlugin, ArraysExtension> sbasePluginCreator(sbaseExtPoint, packageURIs);
//----------------------------------------------------------------
//
// 4. Adds the creator objects to the extension
//
//----------------------------------------------------------------
arraysExtension.addSBasePluginCreator(&sbmldocPluginCreator);
arraysExtension.addSBasePluginCreator(&sbasePluginCreator);
ArraysASTPlugin arrays(getXmlnsL3V1V1());
arraysExtension.setASTBasePlugin(&arrays);
//----------------------------------------------------------------
//
// 5. Register the object with the registry
//
//----------------------------------------------------------------
int result = SBMLExtensionRegistry::getInstance().addExtension(&arraysExtension);
if (result != LIBSBML_OPERATION_SUCCESS)
{
std::cerr << "[Error] ArraysExtension::init() failed." << std::endl;
}
}
