static sk_sp<SkMaskFilter> make_mask_filter() {
sk_sp<SkMaskFilter> maskFilter;
switch (R(3)) {
case 0:
maskFilter = SkBlurMaskFilter::Make(make_blur_style(), make_scalar(),
make_blur_mask_filter_flag());
case 1: {
SkEmbossMaskFilter::Light light;
for (int i = 0; i < 3; ++i) {
light.fDirection[i] = make_scalar();
}
light.fPad = R(65536);
light.fAmbient = R(256);
light.fSpecular = R(256);
maskFilter = SkEmbossMaskFilter::Make(make_scalar(), light);
}
case 2:
default:
break;
}
return maskFilter;
}
value cupl_min(value left, value right)
/* apply min functionnot yet supported for vectors and matrices */
{
value result;
int n;
make_scalar(&result, right.elements[0]);
for (n = 0; n < right.width * right.depth; n++)
if (result.elements[0] > right.elements[n])
result.elements[0] = right.elements[n];
return(result);
}
value cupl_max(value left, value right)
/* apply max function */
{
value result;
int n;
make_scalar(&result, right.elements[0]);
for (n = 0; n < right.width * right.depth; n++)
if (result.elements[0] < right.elements[n])
result.elements[0] = right.elements[n];
return(result);
}
value cupl_sqrt(value right)
/* apply square root */
{
value result;
if (right.rank != 0)
die("SQRT is only defined for scalar arguments\n");
else
{
make_scalar(&result, 0);
result.elements[0] = sqrt(right.elements[0]);
return(result);
}
}
value cupl_log(value right)
/* apply log10 function */
{
value result;
if (right.rank != 0)
die("LOG is only defined for scalar arguments\n");
else
{
make_scalar(&result, 0);
result.elements[0] = log10(right.elements[0]);
return(result);
}
}
value cupl_floor(value right)
/* apply floor function */
{
value result;
if (right.rank != 0)
die("FLOOR is only defined for scalar arguments\n");
else
{
make_scalar(&result, 0);
result.elements[0] = floor(right.elements[0]);
return(result);
}
}
value cupl_exp(value right)
/* apply exponent function */
{
value result;
if (right.rank != 0)
die("EXP is only defined for scalar arguments\n");
else
{
make_scalar(&result, 0);
result.elements[0] = exp(right.elements[0]);
return(result);
}
}
value cupl_cos(value right)
/* apply cosine */
{
value result;
if (right.rank != 0)
die("COS is only defined for scalar arguments\n");
else
{
make_scalar(&result, 0);
result.elements[0] = cos(right.elements[0]);
return(result);
}
}
value cupl_atan(value right)
/* apply arctangent */
{
value result;
if (right.rank != 0)
die("ATAN is only defined for scalar arguments\n");
else
{
make_scalar(&result, 0);
result.elements[0] = atan(right.elements[0]);
return(result);
}
}
value cupl_power(value left, value right)
/* apply power operation with two CUPL values */
{
if (left.rank == 0 && right.rank == 0)
{
value result;
make_scalar(&result, 0);
result.elements[0] = pow(left.elements[0], right.elements[0]);
return(result);
}
else
die("power operation on non-scalars is not yet supported\n");
}
static ERL_NIF_TERM process_events(ErlNifEnv* env, events_t **events,
yaml_parser_t *parser, int flags)
{
ERL_NIF_TERM els, el;
yaml_event_t *event;
els = enif_make_list(env, 0);
if (events) {
while (*events) {
event = hd(events);
if (event) {
switch (event->type) {
case YAML_SEQUENCE_END_EVENT:
el = process_events(env, events, parser, flags);
els = enif_make_list_cell(env, el, els);
break;
case YAML_MAPPING_END_EVENT:
el = process_events(env, events, parser, flags);
els = enif_make_list_cell(env, el, els);
break;
case YAML_MAPPING_START_EVENT:
yaml_event_delete(event);
enif_free(event);
return zip(env, els);
case YAML_SEQUENCE_START_EVENT:
yaml_event_delete(event);
enif_free(event);
return els;
case YAML_SCALAR_EVENT:
el = make_scalar(env, event, flags);
els = enif_make_list_cell(env, el, els);
break;
case YAML_ALIAS_EVENT:
el = make_alias(env, event);
els = enif_make_list_cell(env, el, els);
break;
default:
break;
}
yaml_event_delete(event);
enif_free(event);
} else {
break;
}
}
}
return els;
}
value cupl_rand(value right)
/* get a random number from a seed */
{
value result;
if (right.rank != 0)
die("RAND is only defined for scalar arguments\n");
else
{
make_scalar(&result, 0);
srand(right.elements[0]);
result.elements[0] = rand();
return(result);
}
}
value cupl_dot(value left, value right)
/* compute inner or dot product of two vectors */
{
if (!CONGRUENT(left, right) || right.rank != 1)
die("DOT failed, operands of different sizes or ranks\n");
else
{
value result;
int n;
make_scalar(&result, 0);
for (n = 0; n < left.width * left.depth; n++)
result.elements[0] += left.elements[n] * right.elements[n];
return(result);
}
}
value cupl_trc(value right)
/* compute sum of elements on main diagonals */
{
if (right.rank != 2 || right.width != right.depth)
die("TRACE failed, operands is not a square matrix\n");
else
{
value result;
int n;
make_scalar(&result, 0);
for (n = 0; n < right.width; n++)
result.elements[0] += SUB(right, n, n)[0];
return(result);
}
}
static sk_sp<SkPathEffect> make_path_effect(bool canBeNull = true) {
sk_sp<SkPathEffect> pathEffect;
if (canBeNull && (R(3) == 1)) { return pathEffect; }
switch (R(8)) {
case 0:
pathEffect = SkPath2DPathEffect::Make(make_matrix(), make_path());
break;
case 1:
pathEffect = SkPathEffect::MakeCompose(make_path_effect(false),
make_path_effect(false));
break;
case 2:
pathEffect = SkCornerPathEffect::Make(make_scalar());
break;
case 3: {
int count = R(10);
SkScalar intervals[10];
for (int i = 0; i < count; ++i) {
intervals[i] = make_scalar();
}
pathEffect = SkDashPathEffect::Make(intervals, count, make_scalar());
break;
}
case 4:
pathEffect = SkDiscretePathEffect::Make(make_scalar(), make_scalar());
break;
case 5:
pathEffect = SkPath1DPathEffect::Make(make_path(), make_scalar(), make_scalar(),
make_path_1d_path_effect_style());
break;
case 6:
pathEffect = SkLine2DPathEffect::Make(make_scalar(), make_matrix());
break;
case 7:
default:
pathEffect = SkPathEffect::MakeSum(make_path_effect(false),
make_path_effect(false));
break;
}
return pathEffect;
}
value cupl_posmin(value right)
/* row position of minimum element of argument */
{
if (right.rank == 0)
die("POSMIN argument is a scalar");
else
{
value result;
int n;
scalar minel = right.elements[0];;
make_scalar(&result, 0);
for (n = 0; n < right.width * right.depth; n++)
if (minel > right.elements[n])
{
result.elements[0] = SUBI(right, n);
minel = right.elements[n];
}
return(result);
}
}
static SkColorFilter* make_color_filter() {
SkColorFilter* colorFilter;
switch (R(6)) {
case 0: {
SkScalar array[20];
for (int i = 0; i < 20; ++i) {
array[i] = make_scalar();
}
colorFilter = SkColorMatrixFilter::Create(array);
break;
}
case 1:
colorFilter = SkLumaColorFilter::Create();
break;
case 2: {
uint8_t tableA[256];
uint8_t tableR[256];
uint8_t tableG[256];
uint8_t tableB[256];
rand_color_table(tableA);
rand_color_table(tableR);
rand_color_table(tableG);
rand_color_table(tableB);
colorFilter = SkTableColorFilter::CreateARGB(tableA, tableR, tableG, tableB);
break;
}
case 3:
colorFilter = SkColorFilter::CreateModeFilter(make_color(), make_xfermode());
break;
case 4:
colorFilter = SkColorMatrixFilter::CreateLightingFilter(make_color(), make_color());
break;
case 5:
default:
colorFilter = nullptr;
break;
}
return colorFilter;
}
static SkImageFilter* make_image_filter(bool canBeNull) {
SkImageFilter* filter = 0;
// Add a 1 in 3 chance to get a nullptr input
if (canBeNull && (R(3) == 1)) { return filter; }
enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
switch (R(NUM_FILTERS)) {
case ALPHA_THRESHOLD:
filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar());
break;
case MERGE:
filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
break;
case COLOR:
{
SkAutoTUnref<SkColorFilter> cf(make_color_filter());
filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
}
break;
case LUT3D:
{
int cubeDimension;
SkAutoDataUnref lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
SkAutoTUnref<SkColorFilter> cf(SkColorCubeFilter::Create(lut3D, cubeDimension));
filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
}
break;
case BLUR:
filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter());
break;
case MAGNIFIER:
filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true));
break;
case DOWN_SAMPLE:
filter = SkDownSampleImageFilter::Create(make_scalar());
break;
case XFERMODE:
{
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(make_xfermode()));
filter = SkXfermodeImageFilter::Create(mode, make_image_filter(), make_image_filter());
}
break;
case OFFSET:
filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter());
break;
case MATRIX:
filter = SkImageFilter::CreateMatrixFilter(make_matrix(),
(SkFilterQuality)R(4),
make_image_filter());
break;
case MATRIX_CONVOLUTION:
{
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
SkISize size = SkISize::Make(R(10)+1, R(10)+1);
int arraySize = size.width() * size.height();
SkTArray<SkScalar> kernel(arraySize);
for (int i = 0; i < arraySize; ++i) {
kernel.push_back() = make_scalar();
}
SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())),
R(SkIntToScalar(size.height())));
filter = SkMatrixConvolutionImageFilter::Create(size,
kernel.begin(),
make_scalar(),
make_scalar(),
kernelOffset,
(SkMatrixConvolutionImageFilter::TileMode)R(3),
R(2) == 1,
make_image_filter(),
&cropR);
}
break;
case COMPOSE:
filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter());
break;
case DISTANT_LIGHT:
filter = (R(2) == 1) ?
SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
make_color(), make_scalar(), make_scalar(), make_image_filter()) :
SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
make_image_filter());
break;
case POINT_LIGHT:
filter = (R(2) == 1) ?
SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
make_color(), make_scalar(), make_scalar(), make_image_filter()) :
SkLightingImageFilter::CreatePointLitSpecular(make_point(),
make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
make_image_filter());
break;
case SPOT_LIGHT:
filter = (R(2) == 1) ?
SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
make_point(), make_scalar(), make_scalar(), make_color(),
make_scalar(), make_scalar(), make_image_filter()) :
SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
make_point(), make_scalar(), make_scalar(), make_color(),
make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter());
break;
case NOISE:
{
SkAutoTUnref<SkShader> shader((R(2) == 1) ?
SkPerlinNoiseShader::CreateFractalNoise(
make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
SkPerlinNoiseShader::CreateTurbulence(
make_scalar(true), make_scalar(true), R(10.0f), make_scalar()));
SkPaint paint;
paint.setShader(shader);
SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize)));
filter = SkPaintImageFilter::Create(paint, &cropR);
}
break;
case DROP_SHADOW:
filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(), make_scalar(true),
make_scalar(true), make_color(), make_shadow_mode(), make_image_filter(),
nullptr);
break;
case MORPHOLOGY:
if (R(2) == 1) {
filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
R(static_cast<float>(kBitmapSize)), make_image_filter());
} else {
filter = SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)),
R(static_cast<float>(kBitmapSize)), make_image_filter());
}
break;
case BITMAP:
{
SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(make_bitmap()));
if (R(2) == 1) {
filter = SkImageSource::Create(image, make_rect(), make_rect(), kHigh_SkFilterQuality);
} else {
filter = SkImageSource::Create(image);
}
}
break;
case DISPLACE:
filter = SkDisplacementMapEffect::Create(make_channel_selector_type(),
make_channel_selector_type(), make_scalar(),
make_image_filter(false), make_image_filter());
break;
case TILE:
filter = SkTileImageFilter::Create(make_rect(), make_rect(), make_image_filter(false));
break;
case PICTURE:
{
SkRTreeFactory factory;
SkPictureRecorder recorder;
SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize),
SkIntToScalar(kBitmapSize),
&factory, 0);
drawSomething(recordingCanvas);
SkAutoTUnref<SkPicture> pict(recorder.endRecording());
filter = SkPictureImageFilter::Create(pict.get(), make_rect());
}
break;
case PAINT:
{
SkImageFilter::CropRect cropR(make_rect());
filter = SkPaintImageFilter::Create(make_paint(), &cropR);
}
default:
break;
}
return (filter || canBeNull) ? filter : make_image_filter(canBeNull);
}
static SkPath make_path() {
SkPath path;
int numOps = R(30);
for (int i = 0; i < numOps; ++i) {
switch (R(6)) {
case 0:
path.moveTo(make_scalar(), make_scalar());
break;
case 1:
path.lineTo(make_scalar(), make_scalar());
break;
case 2:
path.quadTo(make_scalar(), make_scalar(), make_scalar(), make_scalar());
break;
case 3:
path.conicTo(make_scalar(), make_scalar(), make_scalar(), make_scalar(), make_scalar());
break;
case 4:
path.cubicTo(make_scalar(), make_scalar(), make_scalar(),
make_scalar(), make_scalar(), make_scalar());
break;
case 5:
default:
path.arcTo(make_scalar(), make_scalar(), make_scalar(), make_scalar(), make_scalar());
break;
}
}
path.close();
return path;
}
static SkPoint3 make_point() {
return SkPoint3::Make(make_scalar(), make_scalar(), make_scalar(true));
}
int main()
{
mscalar ma, mb, mc, md, me;
struct polynomial A, B, C, D, E, F, G, H;
make_scalar(ma);
make_scalar(mb);
make_scalar(mc);
make_scalar(md);
make_scalar(me);
A.leading = NULL;
B.leading = NULL;
C.leading = NULL;
D.leading = NULL;
E.leading = NULL;
F.leading = NULL;
G.leading = NULL;
H.leading = NULL;
printf("The prime is: %d.\n", p);
printf("The power is: %d.\n", r);
setup_scalars();
set_seed(0);
sc_zero(ma);
printf("The number 0 is: ");
printmscalar(ma);
printf(".\n");
sc_one(mb);
printf("The number 1 is: ");
printmscalar(mb);
printf(".\n");
ito_sc(541, mc);
printf("The number 541 is: ");
printmscalar(mc);
printf(".\n");
sc_inv(mc, md);
printf("The inverse of 541 is: ");
printmscalar(md);
printf(".\n");
sc_mult(md, mc, me);
printf("The number 1 is: ");
printmscalar(me);
printf(".\n");
A = make_random(10);
F = copy_pol(A);
/* print_pol(A);
printf("\n"); */
B = make_random(11);
H = copy_pol(B);
/* print_pol(B);
printf("\n"); */
C = pol_mult(A, B);
/* print_pol(C);
printf("\n"); */
D = pol_mult(B, A);
/* print_pol(D);
printf("\n"); */
times_int(-1, &D);
E = pol_add(C, D);
print_pol(E);
printf("\n");
times_int(-1, &F);
G = pol_add(A, F);
print_pol(G);
printf("\n");
times_int(-1, &H);
G = pol_add(B, H);
print_pol(G);
exit(0);
}
/* Optimized for dividing by myf. */
struct polynomial *myf_division(struct polynomial *pp)
{
struct polynomial save_the_spot, uit;
struct term test;
struct polynomial myf_rest;
struct polynomial *aa;
struct polynomial *ppp;
struct term **ptraa;
struct term **ptrterm;
int first;
mscalar c;
myf_rest.degree = myf.degree;
myf_rest.leading = myf.leading->next;
make_scalar(c);
sc_inv(myf.leading->c, c);
ppp = NULL;
make_pol(&ppp);
aa = NULL;
make_pol(&aa);
aa->degree = pp->degree - myf.degree;
ptraa = &(aa->leading);
save_the_spot.degree = aa->degree;
/* Copy pp into ppp. */
ppp->degree = pp->degree;
ppp->leading = pp->leading;
/* Set pp equal to ``zero'' */
pp->leading = NULL;
ptrterm = &pp->leading;
while (ppp->leading) {
if (deelbaar(myf.leading, ppp->leading)) {
save_the_spot.leading = ppp->leading;
first = 1;
do {
/* No sign in front of pppterm->c */
sc_mult_replace(c, ppp->leading->c);
/* Change sign mon.c */
sc_negate(ppp->leading->c);
*ptraa = ppp->leading;
ppp->leading->n1 -= myf.leading->n1;
ppp->leading->n2 -= myf.leading->n2;
ppp->leading->n3 -= myf.leading->n3;
ppp->leading->n4 -= myf.leading->n4;
ppp->leading = ppp->leading->next;
(*ptraa)->next = NULL;
if (first) {
test.n1 = (*ptraa)->n1 +
myf_rest.leading->n1;
test.n2 = (*ptraa)->n2 +
myf_rest.leading->n2;
test.n3 = (*ptraa)->n3 +
myf_rest.leading->n3;
test.n4 = (*ptraa)->n4 +
myf_rest.leading->n4;
first = 0;
}
ptraa = &((*ptraa)->next);
} while ((ppp->leading) &&
deelbaar(myf.leading, ppp->leading) &&
(GROTER == kleiner(ppp->leading, &test)));
uit = pol_mult(save_the_spot, myf_rest);
merge_add(ppp, uit);
} else {
*ptrterm = ppp->leading;
ptrterm = &((*ptrterm)->next);
/* Move on to the next one. */
ppp->leading = ppp->leading->next;
/* Terminate pp. */
*ptrterm = NULL;
}
}
free(ppp);
free_scalar(c);
return(aa);
}
static PyObject* fun(const bool& x) {
return make_scalar(x);
}
static PyObject* fun(const long& x) {
return make_scalar(x);
}
static PyObject* fun(const float& x) {
return make_scalar(x);
}
static PyObject* fun(const double& x) {
return make_scalar(x);
}
