ribi::PlaneZ::PlaneZ(
const Doubles& coefficients
)
: m_coefficients(coefficients)
{
// const bool verbose{false};
assert(GetCoefficients().size() == 4);
if (m_coefficients[2] == 0.0)
{
// if (verbose) { /* TRACE(Container().ToStr(m_coefficients)); */}
throw std::logic_error("PlaneZ (from coeffients) cannot be expressed in less than 3D space");
}
try
{
//TRACE(GetFunctionA());
//TRACE(GetFunctionB());
//TRACE(GetFunctionC());
assert(GetFunctionA() == 0.0 || GetFunctionA() != 0.0);
assert(GetFunctionB() == 0.0 || GetFunctionB() != 0.0);
assert(GetFunctionC() == 0.0 || GetFunctionC() != 0.0);
}
catch (...)
{
assert(!"Should not get here");
}
}
int main() {
double a, b, x;
GetCoefficients(&a,&b);
Solve(a,b,&x);
Display(x);
return EXIT_SUCCESS;
}
main(){
//Values
double A1, A2, B1, B2, C1, C2;
//Display
double X0,Y0,ANGLE;
UserInstructions();
GetCoefficients(&A1, &A2, &B1, &B2, &C1, &C2);
SolveIntersection(A1, A2, B1, B2, C1, C2, &X0, &Y0);
SolveAngle(A1,A2,B1,B2,&ANGLE);
DisplayResult(X0,Y0,ANGLE);
}
ribi::PlaneZ::PlaneZ(
const Coordinat3D& p1,
const Coordinat3D& p2,
const Coordinat3D& p3
) : PlaneZ(CalcPlaneZ(p1,p2,p3))
{
// const bool verbose{false};
assert(GetCoefficients().size() == 4);
if (m_coefficients[2] == 0.0)
{
// if (verbose) { /* TRACE(Container().ToStr(m_coefficients)); */}
throw std::logic_error("Plane (from points) that can be expressed in less than 3D space");
}
}
static PyObject* MaximumEntropyMethod (PyObject* self, PyObject *arg, PyObject *keywords)
{
// Declaring initial variables
double TimeStep;
int NumberOfCoefficients = 100; //Default value for number of coeficients
double AngularFrequency;
// Interface with Python
PyObject *velocity_obj, *frequency_obj;
static char *kwlist[] = {"frequency", "velocity", "time_step", "coefficients", NULL};
if (!PyArg_ParseTupleAndKeywords(arg, keywords, "OOd|i", kwlist, &frequency_obj, &velocity_obj, &TimeStep, &NumberOfCoefficients)) return NULL;
PyObject *velocity_array = PyArray_FROM_OTF(velocity_obj, NPY_CDOUBLE, NPY_IN_ARRAY);
PyObject *frequency_array = PyArray_FROM_OTF(frequency_obj, NPY_DOUBLE, NPY_IN_ARRAY);
if (velocity_array == NULL || frequency_array == NULL ) {
Py_XDECREF(velocity_array);
Py_XDECREF(frequency_array);
return NULL;
}
double _Complex *Velocity = (double _Complex*)PyArray_DATA(velocity_array);
double *Frequency = (double*)PyArray_DATA(frequency_array);
int NumberOfData = (int)PyArray_DIM(velocity_array, 0);
int NumberOfFrequencies = (int)PyArray_DIM(frequency_array, 0);
//Create new numpy array for storing result
PyArrayObject *PowerSpectrum_object;
int dims[1]={NumberOfFrequencies};
PowerSpectrum_object = (PyArrayObject *) PyArray_FromDims(1,dims,NPY_FLOAT);
float *PowerSpectrum = (float*)PyArray_DATA(PowerSpectrum_object);
//Declare internal variables
float coefficients[NumberOfCoefficients];
// Maximum Entropy Method Algorithm
double MeanSquareDiscrepancy = GetCoefficients((double *)Velocity, NumberOfData, NumberOfCoefficients, coefficients);
# pragma omp parallel for default(shared) private(AngularFrequency)
for (int i=0;i<NumberOfFrequencies;i++) {
AngularFrequency = Frequency[i]*2.0*M_PI;
PowerSpectrum[i] = FrequencyEvaluation(AngularFrequency*TimeStep/2.0, coefficients, NumberOfCoefficients, MeanSquareDiscrepancy);
}
//Returning Python array
return(PyArray_Return(PowerSpectrum_object));
}
int32_t CBC_ReedSolomonGF256Poly::EvaluateAt(int32_t a) {
if (a == 0) {
return GetCoefficients(0);
}
int32_t size = m_coefficients.GetSize();
if (a == 1) {
int32_t result = 0;
for (int32_t i = 0; i < size; i++) {
result = CBC_ReedSolomonGF256::AddOrSubtract(result, m_coefficients[i]);
}
return result;
}
int32_t result = m_coefficients[0];
for (int32_t j = 1; j < size; j++) {
result = CBC_ReedSolomonGF256::AddOrSubtract(m_field->Multiply(a, result),
m_coefficients[j]);
}
return result;
}
