t_cylinder *get_cylinder(int fd)
{
int r;
char *line;
t_cylinder *c;
c = new_cylinder(NULL, 0, NULL, NULL);
while ((r = get_next_line(fd, &line)) > 0 && ft_strcmp(line, "----------"))
{
if (!ft_strcmp("p1:", line))
c->center = get_vector(fd);
if (!ft_strcmp("p2:", line))
c->upper = get_vector(fd);
if (!ft_strcmp("radius:", line))
{
r = get_next_line(fd, &line);
c->radius = ft_atodouble(&line);
}
if (!ft_strcmp("color:", line))
c->color = get_color(fd);
if (!ft_strcmp("axis:", line))
c->axis = normalize(get_vector(fd));
}
if (r == -1)
exit(-1);
return (c);
}
/// Evaluates a expression using these templates.
///
/// An expression is a query on the current templates to fetch a particular
/// value. The value is always returned as a string, as this is how templates
/// are internally stored.
///
/// \param expression The expression to evaluate. This should not include any
/// of the delimiters used in the user input, as otherwise the expression
/// will not be evaluated properly.
///
/// \return The result of the expression evaluation as a string.
///
/// \throw text::syntax_error If there is any problem while evaluating the
/// expression.
std::string
text::templates_def::evaluate(const std::string& expression) const
{
const std::string::size_type paren_open = expression.find('(');
if (paren_open == std::string::npos) {
return get_variable(expression);
} else {
const std::string::size_type paren_close = expression.find(
')', paren_open);
if (paren_close == std::string::npos)
throw text::syntax_error(F("Expected ')' in expression '%s')") %
expression);
if (paren_close != expression.length() - 1)
throw text::syntax_error(F("Unexpected text found after ')' in "
"expression '%s'") % expression);
const std::string arg0 = expression.substr(0, paren_open);
const std::string arg1 = expression.substr(
paren_open + 1, paren_close - paren_open - 1);
if (arg0 == "defined") {
return exists(arg1) ? "true" : "false";
} else if (arg0 == "length") {
return F("%s") % get_vector(arg1).size();
} else {
return get_vector(arg0, arg1);
}
}
}
t_camera *get_camera(int fd)
{
int r;
t_camera *c;
char *line;
t_vect *diff_btw;
t_vect *look_at;
c = new_camera(NULL, NULL, NULL, NULL);
while ((r = get_next_line(fd, &line)) > 0 && ft_strcmp(line, "----------"))
{
if (!ft_strcmp("pos:", line))
c->campos = get_vector(fd);
if (!ft_strcmp("dir:", line))
look_at = get_vector(fd);
}
if (r == -1)
exit(-1);
diff_btw = new_vector(c->campos->x - look_at->x,
c->campos->y - look_at->y,
c->campos->z - look_at->z);
c->camdir = normalize(negative(diff_btw));
c->camright = normalize(cross_product(new_vector(0, 1, 0), c->camdir));
c->camdown = cross_product(c->camright, c->camdir);
return (c);
}
void sphere_to_rect_collision(object * ball, object * box) {
matrix faces = *(box->mat);
struct point p1, p2, p3, int_pt;
vector nml, ray_dir, plane_pt, ray_pt, int_vec, v1, v2;
int i;
double t;
/*
* Calculate time at which ray from radius of circle intersects
* with triangle face. Make sure that time is within correct range.
*/
for (i = 6; i < faces.width; i += 3) {
p1.x = faces.mat[i - 2][0];
p1.y = faces.mat[i - 2][1];
p1.z = faces.mat[i - 2][2];
p2.x = faces.mat[i - 1][0];
p2.y = faces.mat[i - 1][1];
p2.z = faces.mat[i - 1][2];
p3.x = faces.mat[i][0];
p3.y = faces.mat[i][1];
p3.z = faces.mat[i][2];
v1 = get_vector(p1, p2);
v2 = get_vector(p3, p2);
nml = cross_product(v1, v2);
normalize(&nml);
ray_dir = nml;
ray_dir.x *= -1;
ray_dir.y *= -1;
ray_dir.z *= -1;
plane_pt.x = p1.x;
plane_pt.y = p1.y;
plane_pt.z = p1.z;
ray_pt.x = ball->x;
ray_pt.y = ball->y;
ray_pt.z = ball->z;
t = (dot_product(nml, plane_pt) - dot_product(nml, ray_pt)) / (dot_product(nml, ray_dir));
int_vec.x = t * ray_dir.x;
int_vec.y = t * ray_dir.y;
int_vec.z = t * ray_dir.z;
if(t < 0 || magnitude(int_vec) > ball->r)
continue;
ball->vx *= -1;
ball->vy *= -1;
ball->vz *= -1;
break;
}
return;
}
static int get_test_vector(const char *file, uint8_t buf[], int max_len)
{
int octets;
int i;
int sum;
FILE *infile;
if ((infile = fopen(file, "r")) == NULL)
{
fprintf(stderr, " Failed to open '%s'\n", file);
exit(2);
}
octets = 0;
while ((i = get_vector(infile, buf + octets)) > 0)
octets += i;
fclose(infile);
/* The last octet is a sumcheck, so the real data octets are one less than
the total we have */
octets--;
/* Test the checksum */
for (sum = i = 0; i < octets; i++)
sum += buf[i];
if (sum%255 != (int) buf[i])
{
fprintf(stderr, " Sumcheck failed in '%s' - %x %x\n", file, sum%255, buf[i]);
exit(2);
}
return octets;
}
void move()
{
set_vector(trans * get_vector());
character::move();
if(!get_position().is_inside(paint::rect(-5, -5, 805, 605)))
set_active(false);
}
static btTransform get_transform(ErlNifEnv *env, const ERL_NIF_TERM arg) {
double x,y,z,w;
const ERL_NIF_TERM *tuple;
int arity;
enif_get_tuple(env, arg, &arity, &tuple);
return btTransform(get_quaternion(env,tuple[0]),get_vector(env,tuple[1]));
}
void black_line() {
L_velocity = VELOCITY_MAX;
R_velocity = VELOCITY_MAX;
get_vector();
lcd_cursor(1,1);
lcd_string("Straight");
forward();
if (Center_white_line > THRESHOLD) {
if (Left_white_line > THRESHOLD)
L_velocity = VELOCITY_MIN;
else if (Right_white_line > THRESHOLD)
R_velocity = VELOCITY_MIN;
}
else {
if (Left_white_line > THRESHOLD)
L_velocity = 20;
else if (Right_white_line > THRESHOLD)
R_velocity = 20;
}
velocity(L_velocity, R_velocity);
if (Center_white_line < THRESHOLD && Left_white_line < THRESHOLD && Right_white_line < THRESHOLD) {
forward();
stop();
}
}
inline Vec3f GameTerrain::calc_normal(int x, int y, unsigned char *data, int width, int height, int pitch)
{
Vec3f vectors[9];
for (int yy = 0; yy < 3; yy++)
{
for (int xx = 0; xx < 3; xx++)
{
vectors[xx+yy*3] = get_vector(x, y, xx-1, yy-1, data, width, height, pitch);
}
}
Vec3f normals[8] =
{
Vec3f::cross(vectors[1], vectors[0]),
Vec3f::cross(vectors[2], vectors[1]),
Vec3f::cross(vectors[5], vectors[2]),
Vec3f::cross(vectors[8], vectors[5]),
Vec3f::cross(vectors[7], vectors[8]),
Vec3f::cross(vectors[6], vectors[7]),
Vec3f::cross(vectors[3], vectors[6]),
Vec3f::cross(vectors[0], vectors[3])
};
for (int i = 0; i < 8; i++)
normals[i].normalize();
Vec3f normal(0.0f, 0.0f, 0.0f);
for (int i = 0; i < 8; i++)
normal += normals[i];
normal /= 8.0f;
normal.normalize();
return normal;
}
void solve_triangle_eq_omp()
{
char *results_file = "solve_triangle_eq_omp.txt";
FILE *res;
if((res=fopen(results_file, "w"))==NULL)
{
printf("Can't open file %s.\n", results_file);
exit(1);
}
for(int i = 10; i < ROW; i*=10)
{
double **A = get_matrix(i,i);
double *X = get_vector(i,i);
double start = omp_get_wtime();
#pragma omp parallel for collapse(2)
for (int s=i-1; s>=0; s--)
{
X[s] = A[s][i]/A[s][s];
for (int k=s-1;k>=0; k--)
A[k][i] -= A[k][s] * X[s];
}
double end = omp_get_wtime();
fprintf(res, "%lf\n", end-start);
free(X);
for(int s = 0; s < i; s++)
free(A[s]);
free(A);
}
fclose(res);
}
static ERL_NIF_TERM btDynamicsWorld_setGravity(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
((btDynamicsWorld*)unwrap_pointer(
env,
btDynamicsWorld_resource,
argv[0]
))->setGravity(get_vector(env,argv[1]));
return enif_make_atom(env, "ok");
}
float cosin_sim_freq_eval(char *message, int length) {
int n = 1;
int combinations = pow(26, n);
float vector[combinations + 1];
for (int i = 0; i < combinations; i++) { vector[i] = 0.0; }
get_vector(message, length, vector, combinations + 1);
return cosin_sim(english, vector, combinations + 1);
}
//----------------------------------------------------------------------
//
// add entrypoints to the database and name vectors
//
static bool add_entry_points( linput_t *li )
{
ea_t ea;
ea = get_vector( NMI_VECTOR_START_ADDRESS );
add_entry( ea, ea, "NMI_routine", true );
name_vector( NMI_VECTOR_START_ADDRESS, "NMI_vector" );
ea = get_vector( RESET_VECTOR_START_ADDRESS );
add_entry( ea, ea, "RESET_routine", true );
name_vector( RESET_VECTOR_START_ADDRESS, "RESET_vector" );
ea = get_vector( IRQ_VECTOR_START_ADDRESS );
add_entry( ea, ea, "IRQ_routine", true );
name_vector( IRQ_VECTOR_START_ADDRESS, "IRQ_vector" );
return true;
}
VariantBuilder& VariantBuilder::set_genotypes(const VariantBuilderMultiSampleVector<int32_t>& genotypes_for_all_samples) {
// Since the user has chosen to pass by lvalue, make a copy before encoding the genotypes
auto encoded_genotypes = genotypes_for_all_samples;
Genotype::encode_genotypes(encoded_genotypes);
// We've made a copy, so we can move the copy into the storage layer
m_individual_region.bulk_set_genotype_field(m_individual_region.gt_index(), move(encoded_genotypes.get_vector()));
return *this;
}
//----------------------------------------------------------------------
//
// set entrypoint, minEA, maxEA, start_cs and filetype
//
static void set_ida_export_data( void )
{
// set entrypoint
inf.startIP = inf.beginEA = get_vector( RESET_VECTOR_START_ADDRESS );
// set minEA, maxEA, etc.
inf.start_cs = 0;
inf.minEA = RAM_START_ADDRESS;
inf.maxEA = ROM_START_ADDRESS + ROM_SIZE;
}
static ERL_NIF_TERM new_btRigidBodyConstructionInfo(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
double mass;
btVector3 inertia = get_vector(env,argv[3]);
enif_get_double(env, argv[0], &mass);
return wrap_pointer(env,btRigidBodyConstructionInfo_resource, new btRigidBody::btRigidBodyConstructionInfo(
mass,
(btMotionState*)unwrap_pointer(env,btMotionState_resource,argv[1]),
(btCollisionShape*)unwrap_pointer(env,btCollisionShape_resource,argv[2]),
inertia
));
}
bool MeshImporter::is_flat_face(unsigned int *nind, COLLADAFW::MeshVertexData& nor, int count)
{
float a[3], b[3];
get_vector(a, nor, *nind, 3);
normalize_v3(a);
nind++;
for (int i = 1; i < count; i++, nind++) {
get_vector(b, nor, *nind, 3);
normalize_v3(b);
float dp = dot_v3v3(a, b);
if (dp < 0.99999f || dp > 1.00001f)
return false;
}
return true;
}
void solve_triangle_eq_mkl()
{
char *results_file = "solve_triangle_eq_mkl.txt";
FILE *res;
if((res=fopen(results_file, "w"))==NULL)
{
printf("Can't open file %s.\n", results_file);
exit(1);
}
for(int i = 10; i < ROW; i*=10)
{
double *A = get_vector(i*i,i);
double *X = get_vector(i,i);
double start = omp_get_wtime();
cblas_dtrsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit, i, A, i, X, 1);
double end = omp_get_wtime();
fprintf(res, "%lf\n", end-start);
free(X);free(A);
}
fclose(res);
}
int main(int argc, char *argv[]){
srand (time(NULL));
int i, j, z;
int tamanio = 400;
float* vectorA;
float* vectorB;
int resultado = 0;
double startwtime, endwtime;
int myrank, size;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
vectorA = get_vector(tamanio);
vectorB = get_vector(tamanio);
if(tamanio <= 15) { //Mostramos hasta vectores de 15 elementos
print_vector ( vectorA, tamanio);
print_vector ( vectorB, tamanio);
}
startwtime = MPI_Wtime();
for(i = 0; i < tamanio; i++)//cada elemento del vector
{
resultado += vectorA[i]*vectorB[i];
}
endwtime = MPI_Wtime();
printf("Tiempo de ejecucion: %f, usando %d+1 maquinas\n", endwtime - startwtime, size - 1);
printf("\nEl resultado del producto escalar de los vectores es: %d\n\n", resultado);
MPI_Finalize();
return 0;
}
int if_intersection () {
get_vector();
if (Center_white_line > THRESHOLD && Left_white_line > THRESHOLD && Right_white_line > THRESHOLD) {
forward();
//velocity(VELOCITY_MIN, VELOCITY_MIN);
lcd_cursor(1,1);
lcd_string("Intersection");
stop();
return 1;
}
return 0;
}
void cmdBoot(char *buf)
{
int n = get_arg(buf); //引数の数.
int adr = 0;
int vect= 0;
if(n != 0) {
adr = arg_hex[0];
}
vect = get_vector(adr);
printf("reset vect=0x%x\n",vect);
UsbBootTarget(vect,1);
}
inline bool line3<T>::is_point_on_line(const vec3<T>& point) const
{
/*the point is on the line if there exists some t such that
start + getVector()*t==point =>
getVector()*t==point-start =>
getVector().normalize()==(point-start).normalize()
we also need to account for a negative T, however
*/
vec3<T> vec1(get_vector().normalize());
vec3<T> vec2((point - start).normalize());
bool onInfiniteLine = equals(vec1, vec2) || equals(vec1, -vec2);
return onInfiniteLine;
}
/**
* @brief Generates an initial cluster of atoms for starting simulation
*
* @param at Atom array
* @param dat Common data for simulation
* @param from first atom of the list on which to work
* @param to last atom of the list on which to work
* @param mode Building mode : -1 sets coordinates to 9999.9 (infinity), 0 sets all atom at the origin, 1 sets atom at a random position (with constraints)
*/
void build_cluster(ATOM at[], DATA *dat, uint32_t from, uint32_t to, int32_t mode)
{
uint32_t i = 0 ;
// fprintf(stdout,"Entered in build cluster : from %d to %d mode %d\n",from,to,mode);
// fflush(stdout);
if (mode==-1) //infinite initialisation mode
{
for (i=from; i<to; i++)
at[i].x=at[i].y=at[i].z=9999.9;
}
else if (mode==0) //zero everywhere : all at origin
{
for (i=from; i<to; i++)
at[i].x=at[i].y=at[i].z=0.0;
}
else if (mode==1) //random mode
{
double randvec[3] = {0.0} ;
// double rtot=0.0;
//
// for (i=0; i<dat->natom; i++)
// rtot += at[i].ljp.sig;
//
// rtot /= (double)dat->natom;
// rtot = (double)dat->natom*4.0*3.14159*X3(rtot)/3.0;
// dat->inid = pow(3.0*rtot/(4.0*3.14159),0.333);
dat->inid = dat->natom/8.0;
for (i=from; i<to; i++)
{
// fprintf(stdout,"loop %d\n",i);
// fflush(stdout);
do
{
get_vector(dat,-1,randvec);
at[i].x = dat->inid*randvec[0];
at[i].y = dat->inid*randvec[1];
at[i].z = dat->inid*randvec[2];
}
while( (X2(at[i].x)+X2(at[i].y)+X2(at[i].z))>X2(dat->inid) || no_conflict(at,i) != NO_CONFLICT );
}
}
}
void MeshImporter::read_vertices(COLLADAFW::Mesh *mesh, Mesh *me)
{
// vertices
COLLADAFW::MeshVertexData& pos = mesh->getPositions();
int stride = pos.getStride(0);
if (stride == 0) stride = 3;
me->totvert = mesh->getPositions().getFloatValues()->getCount() / stride;
me->mvert = (MVert *)CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, me->totvert);
MVert *mvert;
int i;
for (i = 0, mvert = me->mvert; i < me->totvert; i++, mvert++) {
get_vector(mvert->co, pos, i, stride);
}
}
void turn_bot(char ch) {
get_vector();
velocity(VELOCITY_MIN,VELOCITY_MIN);
/*
if (ch == 'l') {
velocity(VELOCITY_MAX,VELOCITY_MIN);
_delay_ms(2000);
}
else if (ch == 'r') {
velocity(VELOCITY_MIN,VELOCITY_MAX);
_delay_ms(2000);
}
*/
stop();
_delay_ms(1000);
if (ch == 'l')
left_degrees(90);
else
right_degrees(90);
/*
while (1) {
get_vector();
lcd_cursor(1,1);
lcd_string("LorR ");
L_velocity = VELOCITY_MIN;
R_velocity = VELOCITY_MIN;
if (Center_white_line > THRESHOLD) {
if (Left_white_line > THRESHOLD)
L_velocity = VELOCITY_MIN;
else if (Right_white_line > THRESHOLD)
R_velocity = VELOCITY_MIN;
}
else {
if (Left_white_line > THRESHOLD)
L_velocity = 20;
else if (Right_white_line > THRESHOLD)
R_velocity = 20;
}
velocity(L_velocity, R_velocity);
if (Center_white_line > THRESHOLD && Left_white_line < THRESHOLD && Right_white_line < THRESHOLD) {
break;
}
}
*/
}
static void remove_used(t_map *map)
{
size_t i;
void *tmp;
tmp = map->working_list;
map->working_list = map->list;
map->list = tmp;
map->list->len = 0;
i = 0;
while (i < map->working_list->len)
{
tmp = get_vector(*(map->working_list), i);
if (!in_vector(*(map->solution), tmp))
add_vector(map->list, tmp);
++i;
}
}
/// Indexes a vector and gets the value.
///
/// \param name The name of the vector to index.
/// \param index_name The name of a variable representing the index to use.
/// This must be convertible to a natural.
///
/// \return The value of the vector at the given index.
///
/// \throw text::syntax_error If the vector does not existor if the index is out
/// of range.
const std::string&
text::templates_def::get_vector(const std::string& name,
const std::string& index_name) const
{
const strings_vector& vector = get_vector(name);
const std::string& index_str = get_variable(index_name);
std::size_t index;
try {
index = text::to_type< std::size_t >(index_str);
} catch (const text::syntax_error& e) {
throw text::syntax_error(F("Index '%s' not an integer, value '%s'") %
index_name % index_str);
}
if (index >= vector.size())
throw text::syntax_error(F("Index '%s' out of range at position '%s'") %
index_name % index);
return vector[index];
}
int damier(t_vector3 eye, t_vector3 cam, t_best best)
{
double x;
double z;
translate(&eye, best.obj.p, 1);
rot_inv(&eye, best.obj.r);
rot_inv(&cam, best.obj.r);
scale(&cam, best.obj.s);
best.inter = get_vector(cam, eye, best.k);
translate(&(best.inter), best.obj.p, -1);
if (best.inter.x < 0)
best.inter.x -= 40;
if (best.inter.z < 0)
best.inter.z -= 40;
x = (int)(abs(best.inter.x) % 80);
z = (int)(abs(best.inter.z) % 80);
if ((z <= 40 && x <= 40) || (z > 40 && x > 40))
return (0xFFFFFF00);
else
return (0x00000000);
return (best.color);
}
t_cylinder *get_cylinder(int fd)
{
int r;
char *line;
t_vect *center;
double radius;
t_color *color;
while ((r = get_next_line(fd, &line)) > 0 && ft_strcmp(line, "----------"))
{
if (!ft_strcmp("pos:", line))
center = get_vector(fd);
if (!ft_strcmp("radius:", line))
{
r = get_next_line(fd, &line);
radius = ft_atodouble(&line);
}
if (!ft_strcmp("color:", line))
color = get_color(fd);
}
if (r == -1)
exit(-1);
return (new_cylinder(center, radius, color));
}
void FadeCurve::process(AudioBus *bus, nframes_t nframes)
{
if (is_bypassed()) {
return;
}
audio_sample_t* mixdown[bus->get_channel_count()];
int outputRate = audiodevice().get_sample_rate();
uint framesToProcess = nframes;
TimeRef trackStartLocation, trackEndLocation, mix_pos;
TimeRef fadeRange = TimeRef(get_range());
TimeRef transportLocation = m_session->get_transport_location();
TimeRef upperRange = transportLocation + TimeRef(framesToProcess, outputRate);
if (m_type == FadeIn) {
trackStartLocation = m_clip->get_track_start_location();
} else {
trackStartLocation = m_clip->get_track_end_location() - fadeRange;
}
trackEndLocation = trackStartLocation + fadeRange;
if ( (trackStartLocation < upperRange) && (trackEndLocation > transportLocation) ) {
if (transportLocation < trackStartLocation) {
// Using to_frame() for both the m_trackStartLocation and transportLocation seems to round
// better then using (m_trackStartLocation - transportLocation).to_frame()
// TODO : find out why!
uint offset = (trackStartLocation).to_frame(outputRate) - transportLocation.to_frame(outputRate);
mix_pos = TimeRef();
// printf("offset %d\n", offset);
for (int chan=0; chan<bus->get_channel_count(); ++chan) {
audio_sample_t* buf = bus->get_buffer(chan, framesToProcess);
mixdown[chan] = buf + offset;
}
framesToProcess = framesToProcess - offset;
} else {
mix_pos = (transportLocation - trackStartLocation);
for (int chan=0; chan<bus->get_channel_count(); ++chan) {
mixdown[chan] = bus->get_buffer(chan, framesToProcess);
}
}
if (trackEndLocation < upperRange) {
// Using to_frame() for both the upperRange and m_trackEndLocation seems to round
// better then using (upperRange - m_trackEndLocation).to_frame()
// TODO : find out why!
framesToProcess -= upperRange.to_frame(outputRate) - trackEndLocation.to_frame(outputRate);
// printf("if (m_trackEndLocation < upperRange): framesToProcess %d\n", framesToProcess);
}
} else {
return;
}
upperRange = mix_pos + TimeRef(framesToProcess, outputRate);
get_vector(mix_pos.universal_frame(), upperRange.universal_frame(), m_session->gainbuffer, framesToProcess);
for (int chan=0; chan<bus->get_channel_count(); ++chan) {
for (nframes_t frame = 0; frame < framesToProcess; ++frame) {
mixdown[chan][frame] *= m_session->gainbuffer[frame];
}
}
}
