void Insert(State *state, Mode mode) {
State *aux;
if (IsEmpty()) {
state->value = CalculateValue(state);
myQueue->firstState = state;
myQueue->queueHead = state;
myQueue->numberOfElements++;
}
else {
aux = myQueue->queueHead;
switch (mode)
{
// Breadth First Search
case 1:
while (aux->next != NULL) {
aux = aux->next;
}
aux->next = state;
myQueue->numberOfElements++;
break;
// Depth First Search
case 2:
state->next = aux->next;
aux->next = state;
myQueue->numberOfElements++;
break;
// Greedy best-first search
case 3:
state->value = CalculateValue(state);
while ((aux->next != NULL) && (aux->next->value <= state->value)) {
aux = aux->next;
}
state->next = aux->next;
aux->next = state;
myQueue->numberOfElements++;
break;
case 4:
break;
default:
break;
}
}
}
bool CFX_LedAnimationSequence::UpdateAnimation(int timeStep)
{
bool returnval = false;
m_stepIncrement++;
m_output->SetBrightness(CalculateValue(m_stepIncrement, m_totalIncrements, m_startBrightness,
m_steps[m_activeStep].brightness, m_steps[m_activeStep].type));
if (m_stepIncrement >= m_totalIncrements)
{
returnval = NextStep();
}
return returnval;
}
ECode MultiFloatValuesHolder::SetupSetter(
/* [in] */ IInterface* targetClass)
{
if (mJniSetter != NULL) {
return NOERROR;
}
// try {
AutoLock lock(mPropertyMapLock);
// mPropertyMapLock.writeLock().lock();
AutoPtr<IClassInfo> info = TransformClassInfo(targetClass);
AutoPtr<MethodMap> propertyMap = sJNISetterPropertyMap[info];
typename ClassMethodMap::Iterator it = sJNISetterPropertyMap.Find(info);
if ((it != sJNISetterPropertyMap.End()) && (it->mSecond != NULL)) {
propertyMap = it->mSecond;
typename MethodMap::Iterator it2 = propertyMap->Find(mPropertyName);
if ((it2 != propertyMap->End()) && (it2->mSecond != NULL)) {
mJniSetter = it2->mSecond;
}
}
if (mJniSetter == NULL) {
String methodName = GetMethodName(String("Set"), mPropertyName);
CalculateValue(0.f);
AutoPtr<IArrayList> values;
GetAnimatedValue((IInterface**)&values);
Int32 numParams = 0;
values->GetSize(&numParams);
try {
mJniSetter = nGetMultipleFloatMethod(info, methodName, numParams);
} catch (NoSuchMethodError e) {
// try without the 'set' prefix
mJniSetter = nGetMultipleFloatMethod(info, mPropertyName, numParams);
}
if (mJniSetter != NULL) {
if (propertyMap == NULL) {
propertyMap = new MethodMap();
sJNISetterPropertyMap[info] = propertyMap;
}
(*propertyMap)[mPropertyName] = mJniSetter;
}
}
// } finally {
// mPropertyMapLock.writeLock().unlock();
// }
return NOERROR;
}
//The CAN receive interruption function
interrupt void CANARX_ISR(void)
{
struct ECAN_REGS ECanaShadow;
Uint16 CANRX_MSGID;
ECanaShadow.CANRMP.all = ECanaRegs.CANRMP.all;
ECanaShadow.CANRMP.bit.RMP0 = 1;//clear RMLIF0(接收邮箱溢出) by set RMP0
ECanaRegs.CANRMP.all = ECanaShadow.CANRMP.all;
CANRX_MSGID = ECanaMboxes.MBOX0.MSGID.bit.STDMSGID;
if (CANRX_MSGID == 0x100)
{
struct CANFrame frame;
frame.data[0] = ECanaMboxes.MBOX0.MDL.byte.BYTE0;
frame.data[1] = ECanaMboxes.MBOX0.MDL.byte.BYTE1;
frame.data[2] = ECanaMboxes.MBOX0.MDL.byte.BYTE2;
frame.data[3] = ECanaMboxes.MBOX0.MDL.byte.BYTE3;
frame.data[4] = ECanaMboxes.MBOX0.MDH.byte.BYTE4;
frame.data[5] = ECanaMboxes.MBOX0.MDH.byte.BYTE5;
frame.data[6] = ECanaMboxes.MBOX0.MDH.byte.BYTE6;
frame.data[7] = ECanaMboxes.MBOX0.MDH.byte.BYTE7;
CalculateValue(&frame);
//处理信息
HandleMessage(&frame);
}
PieCtrlRegs.PIEACK.all = PIEACK_GROUP9;
if (SendQGetLength())
{
struct CANFrame frame;
SendQPopFront(&frame);
ECanaMboxes.MBOX1.MDL.byte.BYTE0 = frame.data[0];
ECanaMboxes.MBOX1.MDL.byte.BYTE1 = frame.data[1];
ECanaMboxes.MBOX1.MDL.byte.BYTE2 = frame.data[2];
ECanaMboxes.MBOX1.MDL.byte.BYTE3 = frame.data[3];
ECanaMboxes.MBOX1.MDH.byte.BYTE4 = frame.data[4];
ECanaMboxes.MBOX1.MDH.byte.BYTE5 = frame.data[5];
ECanaMboxes.MBOX1.MDH.byte.BYTE6 = frame.data[6];
ECanaMboxes.MBOX1.MDH.byte.BYTE7 = frame.data[7];
ECanaShadow.CANTRS.all = 0;
ECanaShadow.CANTRS.bit.TRS1 = 1;
ECanaRegs.CANTRS.all = ECanaShadow.CANTRS.all;
}
}
virtual void AdvanceFrame(MotiveTime delta_time) {
Defragment();
// Loop through every motivator one at a time.
// TODO: change this to a closed-form equation.
// TODO OPT: reorder data and then optimize with SIMD to process in groups
// of 4 floating-point or 8 fixed-point values.
for (auto d = data_.begin(); d < data_.end(); ++d) {
for (MotiveTime time_remaining = delta_time; time_remaining > 0;) {
MotiveTime dt = std::min(time_remaining, d->init.max_delta_time());
d->velocity = CalculateVelocity(dt, *d);
d->value = CalculateValue(dt, *d);
time_remaining -= dt;
}
}
}
// Handle the movement of buttons
void Slider::HandleButton(Button *button, GLint limitXLeft, GLint limitXRight, GLint maxPos, GLint minPos, GLfloat *value)
{
// Sync the button
button->active = active;
button->visible = visible;
// Get the mouse-offset as the button is clicked
if (menuSystem->GetFocus() == button && Input::getMouseLeftPressed())
{
mouseOffset = button->GetPosition() - Input::getMousePos() - button->GetOrigin();
}
// Get button-input
if (menuSystem->GetFocus() == button && button->GetState() == 2)
{
// Button is pressed
if (Input::getMouseLeft())
{
Vec2 mouse = Input::getMousePos() + origin;
// Move the button
button->SetPosition(Vec2(mouse.x + mouseOffset.x, button->GetPosition().y));
// Clamp the button's movement
GLint sliderX, buttonX;
sliderX = (GLint)position.x;
buttonX = (GLint)button->GetPosition().x;
if (buttonX < sliderX + minPos) button->SetPosition(Vec2(sliderX + minPos, button->GetPosition().y));
if (buttonX > sliderX + maxPos) button->SetPosition(Vec2(sliderX + maxPos, button->GetPosition().y));
if (buttonX < limitXLeft) button->SetPosition(Vec2(limitXLeft, button->GetPosition().y));
if (buttonX > limitXRight) button->SetPosition(Vec2(limitXRight, button->GetPosition().y));
// Set the mouse-position to the button's position
//Input::setMousePos(Vec2(Input::getMousePos().x, button->GetPosition().y - origin.y - mouseOffset.y));
// Calculate the new value of the slider
CalculateValue(button, maxPos, minPos, value);
// Check if step is enabled and move button to correct position
SnapButton(button, value, limitXLeft, limitXRight, maxPos, minPos);
}
}
}
int main (int argc, char** argv) {
assert(argc == 2);
int coordinate_steps = atoi(argv[1]);
double length = 1.0;
double total_time = 0.6;
double sigma = 0.3;
double lambda = 1.0;
double boundary_value = 0.0;
double coordinate_step = length / coordinate_steps;
double time_step = sigma * coordinate_step / lambda;
int time_steps = total_time / time_step;
int rv = MPI_Init(&argc, &argv);
assert(rv == MPI_SUCCESS);
int size;
rv = MPI_Comm_size(MPI_COMM_WORLD, &size);
assert(rv == MPI_SUCCESS);
int rank;
rv = MPI_Comm_rank(MPI_COMM_WORLD, &rank);
assert(rv == MPI_SUCCESS);
MPI_Request request;
MPI_Status status;
std::vector<double> current_values(coordinate_steps, 0.0);
std::vector<double> previous_values(coordinate_steps, 0.0);
double start_time = MPI_Wtime();
if (rank == 0) {
for (int s = 0; s <= coordinate_steps; s++) {
double coordinate = static_cast<double>(s) / coordinate_steps * length;
if (coordinate >= 0.1 && coordinate <= 0.2) {
current_values[s] = 1.0;
}
}
}
if (rank == 0) {
for (int s = 0; s <= coordinate_steps; s++) {
rv = MPI_Isend(¤t_values[s], 1, MPI_DOUBLE, Next(rank, size), s, MPI_COMM_WORLD, &request);
assert(rv == MPI_SUCCESS);
rv = MPI_Request_free(&request);
assert(rv == MPI_SUCCESS);
}
}
for (int i = (rank == 0) ? 1 : 0; i * size + rank <= time_steps; i++) {
for (int s = 0; s <= coordinate_steps; s++) {
rv = MPI_Recv(&previous_values[s], 1, MPI_DOUBLE, Prev(rank, size), s, MPI_COMM_WORLD, &status);
assert(rv == MPI_SUCCESS);
double left_value = (s == 0) ? boundary_value : current_values[s - 1];
double left_down_value = (s == 0) ? boundary_value : previous_values[s - 1];
double down_value = previous_values[s];
current_values[s] = CalculateValue(sigma, left_value, down_value, left_down_value);
int receiver = (i * size + rank == time_steps) ? 0 : Next(rank, size);
rv = MPI_Isend(¤t_values[s], 1, MPI_DOUBLE, receiver, s, MPI_COMM_WORLD, &request);
assert(rv == MPI_SUCCESS);
rv = MPI_Request_free(&request);
assert(rv == MPI_SUCCESS);
}
}
if (rank == 0) {
for (int s = 0; s <= coordinate_steps; s++) {
int sender = time_steps % size;
rv = MPI_Recv(&previous_values[s], 1, MPI_DOUBLE, sender, s, MPI_COMM_WORLD, &status);
assert(rv == MPI_SUCCESS);
}
}
if (rank == 0 && coordinate_steps <= 100) {
for (int s = 0; s <= coordinate_steps; s++) {
double coordinate = static_cast<double>(s) / coordinate_steps * length;
printf("%lf %lf\n", coordinate, previous_values[s]);
}
}
if (rank == 0) {
double current_time = MPI_Wtime();
printf("%d %lf\n", size, current_time - start_time);
}
rv = MPI_Finalize();
assert(rv == MPI_SUCCESS);
return EXIT_SUCCESS;
}
double NaturalNeighbourInterpolation (glm::vec3 point, DelaunayTriangulation* dt)
{
Vertex p;
p.m_Point[0] = point.x;
p.m_Point[1] = point.y;
p.m_Point[2] = point.z;
p.m_VoronoiVolume = -1;
ArrayList* neighbours;
ArrayList* neighbourSimplices;
AddPoint(&p, dt);
neighbours = NewArrayList();
neighbourSimplices = NewArrayList();
LastNaturalNeighbours(&p, dt, neighbours, neighbourSimplices);
double pointVolume;
std::vector<double> neighbourVolumes;
std::vector<double> neighbourWeights;
neighbourVolumes.resize (ArrayListSize(neighbours));
neighbourWeights.resize (ArrayListSize(neighbours));
for (int i = 0; i < ArrayListSize(neighbours); i++)
{
Vertex* thisVertex = static_cast<Vertex*> (GetFromArrayList(neighbours, i));
Simplex* thisSimplex = static_cast<Simplex*> (GetFromArrayList(neighbourSimplices, i));
VoronoiCell* voronoiCell = GetVoronoiCell(thisVertex, thisSimplex, dt);
neighbourVolumes[i] = VoronoiCellVolume(voronoiCell, thisVertex);
FreeVoronoiCell(voronoiCell, dt);
}
Simplex* simplex = static_cast<Simplex*> (GetFromArrayList(neighbourSimplices, 0));
VoronoiCell* pointCell = GetVoronoiCell(&p, simplex, dt);
pointVolume = VoronoiCellVolume(pointCell, &p);
FreeVoronoiCell(pointCell, dt);
RemovePoint(dt);
for (int i = 0; i < ArrayListSize(neighbours); i++)
{
Vertex* neighbourVertex = static_cast<Vertex*> (GetFromArrayList(neighbours, i));
if (neighbourVertex->m_VoronoiVolume < 0)
{
Simplex* s = FindAnyNeighbour(neighbourVertex, dt->m_Conflicts);
VoronoiCell* voronoiCell = GetVoronoiCell(neighbourVertex, s, dt);
neighbourVertex->m_VoronoiVolume = VoronoiCellVolume(voronoiCell, neighbourVertex);
FreeVoronoiCell(voronoiCell, dt);
}
double neighbourVol = neighbourVertex->m_VoronoiVolume-neighbourVolumes[i];
assert (neighbourVolumes[i]>= -0.001);
neighbourWeights[i] = neighbourVol/pointVolume;
}
double result = CalculateValue (neighbours, neighbourWeights);
for (int i = 0; i <ArrayListSize(dt->m_Updates); i++)
Push(dt->m_RemovedSimplices, GetFromArrayList(dt->m_Updates, i));
EmptyArrayList(dt->m_Conflicts);
EmptyArrayList(dt->m_Updates);
FreeArrayList(neighbours, nullptr);
FreeArrayList(neighbourSimplices, nullptr);
return result;
}
