double cos(double arg)
{
if (arg < 0) {
arg = -arg;
}
return (sinus(arg, 1));
}
double
cos(double arg)
{
if(arg < 0)
arg = -arg;
return sinus(arg, 1);
}
double tangente(int n)
{
double res;
double x;
x = deg_rad(n);
res = sinus(x) / cosinus(x);
return (res);
}
int main (int argc, char const *argv[]){
// long double a = 1.4;
// printf("%10.10f\n", a);
//
// long double x = 3.12345678;
// long double oldsin, newsin;
// int k = 16;
//
// oldsin = x/pow(3, k);
//
//
// for(k=16; k>0; k--){
// newsin = 3*oldsin - 4*pow(oldsin, 3);
// oldsin = newsin;
// }
double x = 3.5;
double real = sin(x);
double a;
printf("sin: %10.10lf\n", sin(x));
for(k=10; k<20; k++){
printf("\nk=%d\n", k);
a = sinus(x, k, 0xCFF);
printf("hax sin: %10.10lf (%10.10lf)\n", a, real-a);
a = sinus(x, k, 0xFFF);
printf("hax sin: %10.10lf (%10.10lf)\n", a, real-a);
a = sinus(x, k, 0xEFF);
printf("hax sin: %10.10lf (%10.10lf)\n", a, real-a);
}
return 0;
}
int main()
{
double kat, kat_rad;
int n;
printf("\nPodaj kat (w stopniach): ");
scanf("%f", &kat);
printf("\nPodaj precyzje: ");
scanf("%d", &n);
kat_rad=(kat*3.14)/180;
double sinus_kata = sinus(kat_rad, n);
printf("Sinus(%.2f) = %.30lf dla %d krokow\n", kat, sinus_kata, n);
return 0;
}
int main() {
int action = 0;
char exitFlag = 0;
while(exitFlag == 0){
printf("1) Add\n");
printf("2) Sub\n");
printf("3) Mul\n");
printf("4) Div\n");
printf("5) Mod\n");
printf("6) AddMod2\n");
printf("7) Sin\n");
printf("8) Cos\n");
printf("9) Tan\n");
printf("10) ArcTan\n");
printf("11) Factorial\n");
printf("12) Exit\n" );
printf("Action: ");
scanf("%d", &action);
getchar();
fflush(stdin);
sync();
switch(action) {
case(1): add(); break;
case(2): sub_func(); break;
case(3): multiplication(); break;
case(4): Div(); break;
case(5): mod(); break;
case(6): modul2(); break;
case(7): sinus(); break;
case(8): my_cos(); break;
case(9): tang(); break;
case(10): arctg(); break;
case(11): factorial(); break;
case(12): exitFlag = 1; break;
default: printf("Wrong index\n");
}
}
return 0;
}
t_vect rot(t_vect v, t_vect r)
{
double tmp;
tmp = v.y;
r.x = (int)r.x % 360;
if (r.x < 0)
r.x += 360;
v.y = tmp * cosinus(r.x) - v.z * sinus(r.x);
v.z = tmp * sinus(r.x) + v.z * cosinus(r.x);
tmp = v.x;
r.y = (int)r.y % 360;
if (r.y < 0)
r.y += 360;
v.x = tmp * cosinus(r.y) - v.z * sinus(r.y);
v.z = tmp * sinus(r.y) + v.z * cosinus(r.y);
tmp = v.x;
r.z = (int)r .z % 360;
if (r.z < 0)
r.z += 360;
v.x = tmp * cosinus(r.z) - v.y *sinus(r.z);
v.y = tmp * sinus(r.z) + v.y *cosinus(r.z);
return (v);
}
double
cos(double x)
{
if (x < 0) x = -x;
return sinus(x, 1);
}
double
sin(double x)
{
return sinus(x, 0);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
INIT_I18N ();
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &svals);
/* In order to prepare the dialog I need to know wether it's grayscale or not */
drawable = gimp_drawable_get (param[2].data.d_drawable);
thePreview = mw_preview_build_virgin(drawable);
drawable_is_grayscale = gimp_drawable_is_gray (drawable->drawable_id);
if (! sinus_dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 17)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
svals.scalex = param[3].data.d_float;
svals.scaley = param[4].data.d_float;
svals.cmplx = param[5].data.d_float;
svals.seed = param[6].data.d_int32;
svals.tiling = param[7].data.d_int32;
svals.perturbation = param[8].data.d_int32;
svals.colors = param[9].data.d_int32;
svals.col1 = param[10].data.d_color;
svals.col2 = param[11].data.d_color;
gimp_rgb_set_alpha (&svals.col1, param[12].data.d_float);
gimp_rgb_set_alpha (&svals.col2, param[13].data.d_float);
svals.colorization = param[14].data.d_int32;
svals.blend_power = param[15].data.d_float;
if (svals.random_seed)
svals.seed = g_random_int ();
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &svals);
if (svals.random_seed)
svals.seed = g_random_int ();
break;
default:
break;
}
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
gimp_progress_init (_("Sinus: rendering"));
gimp_tile_cache_ntiles (1);
sinus ();
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &svals, sizeof (SinusVals));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
double
sin(double arg)
{
return sinus(arg, 0);
}
double sin(double arg)
{
return (sinus(arg, 0));
}
void setUp() {
file = nix::File::open("test_dataAccess.h5", nix::FileMode::Overwrite);
block = file.createBlock("dimensionTest","test");
data_array = block.createDataArray("dimensionTest",
"test",
nix::DataType::Double,
nix::NDSize({0, 0, 0}));
double samplingInterval = 1.0;
std::vector<double> ticks {1.2, 2.3, 3.4, 4.5, 6.7};
std::string unit = "ms";
typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type data(boost::extents[2][10][5]);
int value;
for(index i = 0; i != 2; ++i) {
value = 0;
for(index j = 0; j != 10; ++j) {
for(index k = 0; k != 5; ++k) {
data[i][j][k] = value++;
}
}
}
data_array.setData(data);
setDim = data_array.appendSetDimension();
std::vector<std::string> labels = {"label_a", "label_b"};
setDim.labels(labels);
sampledDim = data_array.appendSampledDimension(samplingInterval);
sampledDim.unit(unit);
rangeDim = data_array.appendRangeDimension(ticks);
rangeDim.unit(unit);
std::vector<nix::DataArray> refs;
refs.push_back(data_array);
std::vector<double> position {0.0, 2.0, 3.4};
std::vector<double> extent {0.0, 6.0, 2.3};
std::vector<std::string> units {"none", "ms", "ms"};
position_tag = block.createTag("position tag", "event", position);
position_tag.references(refs);
position_tag.units(units);
segment_tag = block.createTag("region tag", "segment", position);
segment_tag.references(refs);
segment_tag.extent(extent);
segment_tag.units(units);
//setup multiTag
typedef boost::multi_array<double, 2> position_type;
position_type event_positions(boost::extents[2][3]);
position_type event_extents(boost::extents[2][3]);
event_positions[0][0] = 0.0;
event_positions[0][1] = 3.0;
event_positions[0][2] = 3.4;
event_extents[0][0] = 0.0;
event_extents[0][1] = 6.0;
event_extents[0][2] = 2.3;
event_positions[1][0] = 0.0;
event_positions[1][1] = 8.0;
event_positions[1][2] = 2.3;
event_extents[1][0] = 0.0;
event_extents[1][1] = 3.0;
event_extents[1][2] = 2.0;
std::vector<std::string> event_labels = {"event 1", "event 2"};
std::vector<std::string> dim_labels = {"dim 0", "dim 1", "dim 2"};
nix::DataArray event_array = block.createDataArray("positions", "test",
nix::DataType::Double, nix::NDSize({ 0, 0 }));
event_array.setData(event_positions);
nix::SetDimension event_set_dim;
event_set_dim = event_array.appendSetDimension();
event_set_dim.labels(event_labels);
event_set_dim = event_array.appendSetDimension();
event_set_dim.labels(dim_labels);
nix::DataArray extent_array = block.createDataArray("extents", "test",
nix::DataType::Double, nix::NDSize({ 0, 0 }));
extent_array.setData(event_extents);
nix::SetDimension extent_set_dim;
extent_set_dim = extent_array.appendSetDimension();
extent_set_dim.labels(event_labels);
extent_set_dim = extent_array.appendSetDimension();
extent_set_dim.labels(dim_labels);
multi_tag = block.createMultiTag("multi_tag", "events", event_array);
multi_tag.extents(extent_array);
multi_tag.addReference(data_array);
alias_array = block.createDataArray("alias array", "event times",
nix::DataType::Double, nix::NDSize({ 100 }));
std::vector<double> times(100);
for (size_t i = 0; i < 100; i++) {
times[i] = 1.3 * i;
}
alias_array.setData(times, nix::NDSize({ 0 }));
alias_array.unit("ms");
alias_array.label("time");
aliasDim = alias_array.appendAliasRangeDimension();
std::vector<double> segment_time(1, 4.5);
times_tag = block.createTag("stimulus on", "segment", {4.5});
times_tag.extent({100.0});
times_tag.units({"ms"});
times_tag.addReference(alias_array);
// prepare a mtag with multiple valid segments
std::vector<double> segment_starts{1.0, 5.0, 10.0, 15.0, 20.0};
std::vector<double> segment_extents(5, 2.5);
double sampling_interval = 0.1;
std::vector<double> sinus((int)(25 / sampling_interval));
for (size_t i = 0; i < sinus.size(); ++i) {
sinus[i] = sin(i * 0.1 * 6.28);
}
nix::DataArray seg_starts = block.createDataArray("sinus_starts", "test",
nix::DataType::Double,
nix::NDSize(1,segment_starts.size()));
seg_starts.setData(segment_starts);
seg_starts.appendSetDimension();
nix::DataArray seg_extents = block.createDataArray("sinus_extents", "test",
nix::DataType::Double,
nix::NDSize(1,segment_starts.size()));
seg_extents.setData(segment_extents);
seg_extents.appendSetDimension();
nix::DataArray sinus_array = block.createDataArray("sinus", "test", nix::DataType::Double,
nix::NDSize(1, sinus.size()));
sinus_array.setData(sinus);
nix::SampledDimension sd = sinus_array.appendSampledDimension(sampling_interval);
sd.unit("s");
sd.label("time");
mtag2 = block.createMultiTag("sinus_segments", "test", seg_starts);
mtag2.extents(seg_extents);
mtag2.addReference(sinus_array);
pointmtag = block.createMultiTag("sinus_points", "test", seg_starts);
pointmtag.addReference(sinus_array);
}
