int main(void)
{
int matrix[3][5] = {{ 1, 2, 3, 4, 5},
{ 11, 12, 13, 14,15},
{ 21, 22, 23, 24, 25}
};
void scalar_multiply(int matrix[3][5], int scalar);
void display_matrix(int matrix[3][5]);
printf("Original Matrix:\n");
display_matrix(matrix);
scalar_multiply(matrix, 2);
printf("\nMultiplied by 2:\n");
display_matrix(matrix);
scalar_multiply(matrix, -1);
printf("\nMultiplied by -1:\n");
display_matrix(matrix);
return 0;
}
//Rotate a vector by a given angle about a given unit vector
void rotate_vector(double (&result)[3], double* vect, double* axis, double angle) {
double identity[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
double w_hat[] = {0, *(axis+2), -*(axis+1), -*(axis+2), 0, *(axis+0), *(axis+1), -*(axis+0), 0};
double temp[9], temp2[9], temp3[9];
scalar_multiply(temp, w_hat, 3, 3, sin(angle));
multiply(temp2, w_hat, 3, 3, w_hat, 3);
scalar_multiply(temp3, temp2, 3, 3, 1-cos(angle));
matrix_add(temp2, identity, temp, 3, 3);
matrix_add(temp, temp2, temp3, 3, 3);
multiply(result, temp, 3, 3, vect, 1);
}
Head scalar_multiply(
Head head
, Tail... tail
)
{
if (sizeof...(tail))
head *= scalar_multiply(tail...);
return head;
}
Ray Raytracer::make_reflection_ray(const Vector3d &normal,
const Ray &ray,
const Point3d &intersection)
{
Ray reflection(intersection,
normalize(
vector_subtract(ray.direction(),
scalar_multiply(normal,
2 * dot_product(ray.direction(), normal)))));
return reflection;
}
int hdnode_public_ckd(HDNode *inout, uint32_t i)
{
uint8_t data[1 + 32 + 4];
uint8_t I[32 + 32];
uint8_t fingerprint[32];
curve_point a, b;
bignum256 c;
if (i & 0x80000000) { // private derivation
return 0;
} else { // public derivation
memcpy(data, inout->public_key, 33);
}
write_be(data + 33, i);
sha256_Raw(inout->public_key, 33, fingerprint);
ripemd160(fingerprint, 32, fingerprint);
inout->fingerprint = (fingerprint[0] << 24) + (fingerprint[1] << 16) + (fingerprint[2] << 8) + fingerprint[3];
memset(inout->private_key, 0, 32);
if (!ecdsa_read_pubkey(inout->public_key, &a)) {
return 0;
}
hmac_sha512(inout->chain_code, 32, data, sizeof(data), I);
memcpy(inout->chain_code, I + 32, 32);
bn_read_be(I, &c);
if (!bn_is_less(&c, &order256k1)) { // >= order
return 0;
}
scalar_multiply(&c, &b); // b = c * G
point_add(&a, &b); // b = a + b
#if USE_PUBKEY_VALIDATE
if (!ecdsa_validate_pubkey(&b)) {
return 0;
}
#endif
inout->public_key[0] = 0x02 | (b.y.val[0] & 0x01);
bn_write_be(&b.x, inout->public_key + 1);
inout->depth++;
inout->child_num = i;
return 1;
}
void RPYSolver::orientationSolver(double* output, double phi, double theta, double psi, double yaw1, double pitch1, double roll1, double yaw2, double pitch2, double roll2, int attempt)
{
/**************************************************************************/
//Is the desired orientation possible to attain with the given joint limits?
/**************************************************************************/
double wrist_pitch_limit_max; //Used to express the wrist pitch limit in radians
double wrist_pitch_limit_min; //Used to express the wrist pitch limit in radians
//The wrist pitch limit in radians
wrist_pitch_limit_max=(PI/180.0)*WRIST_PITCH_LIMIT_MAX;
wrist_pitch_limit_min=(PI/180.0)*WRIST_PITCH_LIMIT_MIN;
//The PR2 FK is defined such that pitch is negative upward. Hence, the input pitch values are negated, because the following portion of the code was written assuming that pitch is positive upward.
theta=-theta;
pitch1=-pitch1;
pitch2=-pitch2;
double v1[] = {cos(theta)*cos(phi), cos(theta)*sin(phi), sin(theta)};
double v2[] = {cos(pitch2)*cos(yaw2), cos(pitch2)*sin(yaw2), sin(pitch2)};
double dp_v = dot_product(v1, v2, 3);
double check_flag=dp_v<0;
double check_flag2=fabs(dp_v)>fabs(cos(wrist_pitch_limit_max));
double check_flag3=dp_v>0;
double check_flag4=dp_v>cos(wrist_pitch_limit_min);
if((check_flag && check_flag2) || (check_flag3 && check_flag4)) {
// std::cout << "Impossible." << std::endl;
output[0]=0;
output[1]=0;
output[2]=0;
output[3]=0;
return;
}
/*****************************************************/
//Firstly, all variables are declared and some defined
/*****************************************************/
double hand1[]={0, -0.5, 0, 0, 0.5, 0};
double hand2[]={0, -0.5, 0, 0, 0.5, 0};
double hand1_fo[6];
double hand2_fo[6];
double hand1_vect[3], hand2_vect[3];
double grip1[]={0, 0, 0, 1, 0, 0};
double grip2[]={0, 0, 0, 1, 0, 0};
double grip1_fo[6];
double grip2_fo[6];
double grip1_vect[3], grip2_vect[3];
double indicator1[]={-2.5, 0, 0, -2.5, 0, 1};
double indicator2[]={-2.5, 0, 0, -2.5, 0, 1};
double indicator1_fo[6];
double indicator2_fo[6];
double ind1_vect[3],ind2_vect[3];
double comp1_vect[3], comp2_vect[3], project1_vect[3], project2_vect[3];
double rot1[9], rot2[9], rot3[9];
double temp[6], temp1[9], temp2[9], temp3[9], temp_var, temp_vect[3], temp2_vect[3];
double w[3], w_hat[9];
double rot_world[9], rot_world_trans[9];
double identity[]={1, 0, 0,
0, 1, 0,
0, 0, 1};
double unit_x[3]={1, 0, 0};
double zero_vect[3]={0, 0, 0};
double fo_arm_roll, wrist_pitch, wrist_roll, fs_angle, fe_angle;
double is_orient_possible_flag=1; //Flag returned indicates whether desired orientation is possible
//with wrist limits. 1-possible, 0-impossible
double c_alpha, c_beta, c_gamma, c_delta, c_eps;
/******************************/
//Accepting the input arguments
/******************************/
create_rotation_matrix(rot_world,phi,theta,psi);
transpose(rot_world_trans, rot_world, 3, 3);
//The start and the end orientations in the world frame
rot1[0]=cos(yaw1); rot1[3]=-sin(yaw1); rot1[6]=0;
rot1[1]=sin(yaw1); rot1[4]=cos(yaw1); rot1[7]=0;
rot1[2]=0; rot1[5]=0; rot1[8]=1;
rot2[0]=cos(pitch1); rot2[3]=0; rot2[6]=-sin(pitch1);
rot2[1]=0; rot2[4]=1; rot2[7]=0;
rot2[2]=sin(pitch1); rot2[5]=0; rot2[8]=cos(pitch1);
multiply(rot3,rot1,3,3,rot2,3); //Yaw and pitch rotations
multiply(temp,rot3,3,3,hand1,2);
equate(hand1,temp,3,2);
multiply(temp,rot3,3,3,grip1,2);
equate(grip1,temp,3,2);
w[0]=grip1[3]; //Unit vector along grip
w[1]=grip1[4];
w[2]=grip1[5];
w_hat[0]=0; w_hat[3]=-w[2]; w_hat[6]=w[1];
w_hat[1]=w[2]; w_hat[4]=0; w_hat[7]=-w[0];
w_hat[2]=-w[1]; w_hat[5]=w[0]; w_hat[8]=0;
scalar_multiply(temp1,w_hat,3,3,sin(roll1));
multiply(temp2,w_hat,3,3,w_hat,3);
scalar_multiply(temp3,temp2,3,3,1-cos(roll1));
matrix_add(temp2,temp1,temp3,3,3);
matrix_add(rot1,identity, temp2,3,3);
multiply(temp1,rot1,3,3,hand1,2);
equate(hand1,temp1,3,2);
rot1[0]=cos(yaw2); rot1[3]=-sin(yaw2); rot1[6]=0;
rot1[1]=sin(yaw2); rot1[4]=cos(yaw2); rot1[7]=0;
rot1[2]=0; rot1[5]=0; rot1[8]=1;
rot2[0]=cos(pitch2); rot2[3]=0; rot2[6]=-sin(pitch2);
rot2[1]=0; rot2[4]=1; rot2[7]=0;
rot2[2]=sin(pitch2); rot2[5]=0; rot2[8]=cos(pitch2);
multiply(rot3,rot1,3,3,rot2,3); //Yaw and pitch rotations
multiply(temp,rot3,3,3,hand2,2);
equate(hand2,temp,3,2);
multiply(temp,rot3,3,3,grip2,2);
equate(grip2,temp,3,2);
w[0]=grip2[3]; //Unit vector along grip
w[1]=grip2[4];
w[2]=grip2[5];
w_hat[0]=0; w_hat[3]=-w[2]; w_hat[6]=w[1];
w_hat[1]=w[2]; w_hat[4]=0; w_hat[7]=-w[0];
w_hat[2]=-w[1]; w_hat[5]=w[0]; w_hat[8]=0;
scalar_multiply(temp1,w_hat,3,3,sin(roll2));
multiply(temp2,w_hat,3,3,w_hat,3);
scalar_multiply(temp3,temp2,3,3,1-cos(roll2));
matrix_add(temp2,temp1,temp3,3,3);
matrix_add(rot1,identity,temp2,3,3);
multiply(temp1,rot1,3,3,hand2,2);
equate(hand2,temp1,3,2);
//The start and the end orientations in the forearm frame
multiply(hand1_fo,rot_world_trans,3,3,hand1,2);
multiply(hand2_fo,rot_world_trans,3,3,hand2,2);
multiply(grip1_fo,rot_world_trans,3,3,grip1,2);
multiply(grip2_fo,rot_world_trans,3,3,grip2,2);
grip1_vect[0]=grip1_fo[3];
grip1_vect[1]=grip1_fo[4];
grip1_vect[2]=grip1_fo[5];
temp_var=dot_product(grip1_vect, unit_x, 3);
scalar_multiply(comp1_vect, unit_x,3,1,temp_var);
subtract(project1_vect,grip1_vect,comp1_vect,3,1);
grip2_vect[0]=grip2_fo[3];
grip2_vect[1]=grip2_fo[4];
grip2_vect[2]=grip2_fo[5];
temp_var=dot_product(grip2_vect, unit_x, 3);
scalar_multiply(comp2_vect, unit_x,3,1,temp_var);
subtract(project2_vect,grip2_vect,comp2_vect,3,1);
ind1_vect[0]=indicator1[3]-indicator1[0];
ind1_vect[1]=indicator1[4]-indicator1[1];
ind1_vect[2]=indicator1[5]-indicator1[2];
ind2_vect[0]=indicator2[3]-indicator2[0];
ind2_vect[1]=indicator2[4]-indicator2[1];
ind2_vect[2]=indicator2[5]-indicator2[2];
if(!check_equality(grip1_vect, comp1_vect, 3)) {
c_delta=dot_product(ind1_vect, project1_vect, 3)/vect_norm(project1_vect,3);
fs_angle=acos(c_delta);
cross_product(temp_vect, ind1_vect, project1_vect);
if(vect_divide(temp_vect, unit_x, 3)<0) {
fs_angle=-fs_angle;
}
rot1[0]=1; rot1[3]=0; rot1[6]=0;
rot1[1]=0; rot1[4]=cos(fs_angle); rot1[7]=-sin(fs_angle);
rot1[2]=0; rot1[5]=sin(fs_angle); rot1[8]=cos(fs_angle);
multiply(temp, rot1, 3,3, indicator1, 2);
equate(indicator1_fo, temp, 3, 2);
}
else {
equate(indicator1_fo, indicator1, 3,2);
}
if(!check_equality(grip2_vect, comp2_vect, 3)) {
c_eps=dot_product(ind2_vect, project2_vect, 3)/vect_norm(project2_vect, 3);
fe_angle=acos(c_eps);
cross_product(temp_vect, ind2_vect, project2_vect);
if(vect_divide(temp_vect, unit_x, 3)<0) {
fe_angle=-fe_angle;
}
rot1[0]=1; rot1[3]=0; rot1[6]=0;
rot1[1]=0; rot1[4]=cos(fe_angle); rot1[7]=-sin(fe_angle);
rot1[2]=0; rot1[5]=sin(fe_angle); rot1[8]=cos(fe_angle);
multiply(temp, rot1, 3,3, indicator2, 2);
equate(indicator2_fo, temp, 3, 2);
}
else {
equate(indicator2_fo, indicator2, 3,2);
}
/*********************************/
//Forearm roll is calculated now
/*********************************/
ind1_vect[0]=indicator1_fo[3]-indicator1_fo[0];
ind1_vect[1]=indicator1_fo[4]-indicator1_fo[1];
ind1_vect[2]=indicator1_fo[5]-indicator1_fo[2];
ind2_vect[0]=indicator2_fo[3]-indicator2_fo[0];
ind2_vect[1]=indicator2_fo[4]-indicator2_fo[1];
ind2_vect[2]=indicator2_fo[5]-indicator2_fo[2];
c_gamma=dot_product(ind1_vect, ind2_vect, 3);
cross_product(temp_vect, ind1_vect, ind2_vect);
if(vect_divide(temp_vect, unit_x, 3)>0) {
fo_arm_roll=acos(c_gamma);
}
else {
fo_arm_roll=-acos(c_gamma);
}
//In the second attempt try rotating the other way around to the same orientation
if(attempt == 2) {fo_arm_roll = -(2*PI - fo_arm_roll);}
rot1[0]=1; rot1[3]=0; rot1[6]=0;
rot1[1]=0; rot1[4]=cos(fo_arm_roll); rot1[7]=-sin(fo_arm_roll);
rot1[2]=0; rot1[5]=sin(fo_arm_roll); rot1[8]=cos(fo_arm_roll);
multiply(temp1,rot1,3,3,hand1_fo,2);
equate(hand1_fo,temp1,3,2);
multiply(temp1,rot1,3,3,grip1_fo,2);
equate(grip1_fo,temp1,3,2);
/*********************************/
//Wrist pitch is calculated now
/*********************************/
grip1_vect[0]=grip1_fo[3];
grip1_vect[1]=grip1_fo[4];
grip1_vect[2]=grip1_fo[5];
grip2_vect[0]=grip2_fo[3];
grip2_vect[1]=grip2_fo[4];
grip2_vect[2]=grip2_fo[5];
cross_product(temp_vect, grip1_vect, grip2_vect);
if(!check_equality(temp_vect, zero_vect, 3)) {
c_alpha=dot_product(grip1_vect, grip2_vect, 3);
cross_product(temp2_vect,ind2_vect,temp_vect);
if(vect_divide(temp2_vect, unit_x, 3)>0) {
wrist_pitch=-acos(c_alpha);
temp_vect[0]=-temp_vect[0];
temp_vect[1]=-temp_vect[1];
temp_vect[2]=-temp_vect[2];
}
else {
wrist_pitch=acos(c_alpha);
}
scalar_multiply(w, temp_vect, 3,1,1/vect_norm(temp_vect, 3));
w_hat[0]=0; w_hat[3]=-w[2]; w_hat[6]=w[1];
w_hat[1]=w[2]; w_hat[4]=0; w_hat[7]=-w[0];
w_hat[2]=-w[1]; w_hat[5]=w[0]; w_hat[8]=0;
scalar_multiply(temp1,w_hat,3,3,sin(wrist_pitch));
multiply(temp2,w_hat,3,3,w_hat,3);
scalar_multiply(temp3,temp2,3,3,1-cos(wrist_pitch));
matrix_add(temp2,temp1,temp3,3,3);
matrix_add(rot1,identity, temp2,3,3);
multiply(temp1,rot1,3,3,hand1_fo,2);
equate(hand1_fo,temp1,3,2);
multiply(temp1,rot1,3,3,grip1_fo,2);
equate(grip1_fo,temp1,3,2);
}
else {
wrist_pitch=0;
}
/**Somehow the wrist_roll calculations from within this code don't seem to be right.
This problem has been temporarily solved by invoking FK from environment_robarm3d.cpp**/
/*********************************/
//Wrist roll is calculated now
/*********************************/
wrist_roll=0;
hand1_vect[0]=hand1_fo[3]-hand1_fo[0];
hand1_vect[1]=hand1_fo[4]-hand1_fo[1];
hand1_vect[2]=hand1_fo[5]-hand1_fo[2];
hand2_vect[0]=hand2_fo[3]-hand2_fo[0];
hand2_vect[1]=hand2_fo[4]-hand2_fo[1];
hand2_vect[2]=hand2_fo[5]-hand2_fo[2];
grip1_vect[0]=grip1_fo[3];
grip1_vect[1]=grip1_fo[4];
grip1_vect[2]=grip1_fo[5];
c_beta=dot_product(hand1_vect, hand2_vect, 3);
cross_product(temp_vect, hand1_vect, hand2_vect);
if(!check_equality(temp_vect, zero_vect, 3)) {
if(vect_divide(temp_vect, grip1_vect, 3)>0) {
wrist_roll=acos(c_beta);
}
else {
wrist_roll=-acos(c_beta);
}
}
//The output
output[0]=is_orient_possible_flag;
output[1]=fo_arm_roll;
output[2]=wrist_pitch;
output[3]=wrist_roll;
}
void Estimator::run_estimator(const vector_t& accel, const vector_t& gyro, const uint64_t& imu_time)
{
_current_state.now_us = imu_time;
if (last_time == 0 || _current_state.now_us <= last_time)
{
last_time = _current_state.now_us;
return;
}
float dt = (_current_state.now_us - last_time) * 1e-6f;
last_time = _current_state.now_us;
// Crank up the gains for the first few seconds for quick convergence
if (imu_time < (uint64_t)params->get_param_int(Params::PARAM_INIT_TIME)*1000)
{
kp = params->get_param_float(Params::PARAM_FILTER_KP)*10.0f;
ki = params->get_param_float(Params::PARAM_FILTER_KI)*10.0f;
}
else
{
kp = params->get_param_float(Params::PARAM_FILTER_KP);
ki = params->get_param_float(Params::PARAM_FILTER_KI);
}
// Run LPF to reject a lot of noise
run_LPF(accel, gyro);
// add in accelerometer
float a_sqrd_norm = _accel_LPF.x*_accel_LPF.x + _accel_LPF.y*_accel_LPF.y + _accel_LPF.z*_accel_LPF.z;
if (use_acc && a_sqrd_norm < 1.15f*1.15f*9.80665f*9.80665f && a_sqrd_norm > 0.85f*0.85f*9.80665f*9.80665f)
{
// Get error estimated by accelerometer measurement
vector_t a = vector_normalize(_accel_LPF);
// Get the quaternion from accelerometer (low-frequency measure q)
// (Not in either paper)
quaternion_t q_acc_inv = quaternion_inverse(quat_from_two_vectors(a, g));
// Get the error quaternion between observer and low-freq q
// Below Eq. 45 Mahoney Paper
q_tilde = quaternion_multiply(q_acc_inv, q_hat);
// Correction Term of Eq. 47a and 47b Mahoney Paper
// w_acc = 2*s_tilde*v_tilde
w_acc.x = -2.0f*q_tilde.w*q_tilde.x;
w_acc.y = -2.0f*q_tilde.w*q_tilde.y;
w_acc.z = 0.0f; // Don't correct z, because it's unobservable from the accelerometer
// integrate biases from accelerometer feedback
// (eq 47b Mahoney Paper, using correction term w_acc found above)
b.x -= ki*w_acc.x*dt;
b.y -= ki*w_acc.y*dt;
b.z = 0.0; // Don't integrate z bias, because it's unobservable
}
else
{
w_acc.x = 0.0f;
w_acc.y = 0.0f;
w_acc.z = 0.0f;
}
// Pull out Gyro measurements
if (quad_int)
{
// Quadratic Integration (Eq. 14 Casey Paper)
// this integration step adds 12 us on the STM32F10x chips
wbar = vector_add(vector_add(scalar_multiply(-1.0f/12.0f,w2), scalar_multiply(8.0f/12.0f,w1)),
scalar_multiply(5.0f/12.0f,_gyro_LPF));
w2 = w1;
w1 = _gyro_LPF;
}
else
{
wbar = _gyro_LPF;
}
// Build the composite omega vector for kinematic propagation
// This the stuff inside the p function in eq. 47a - Mahoney Paper
wfinal = vector_add(vector_sub(wbar, b), scalar_multiply(kp, w_acc));
// Propagate Dynamics (only if we've moved)
float sqrd_norm_w = sqrd_norm(wfinal);
if (sqrd_norm_w > 0.0f)
{
float p = wfinal.x;
float q = wfinal.y;
float r = wfinal.z;
if (mat_exp)
{
// Matrix Exponential Approximation (From Attitude Representation and Kinematic
// Propagation for Low-Cost UAVs by Robert T. Casey)
// (Eq. 12 Casey Paper)
// This adds 90 us on STM32F10x chips
float norm_w = sqrtf(sqrd_norm_w);
quaternion_t qhat_np1;
float t1 = cosf((norm_w*dt)/2.0f);
float t2 = 1.0f/norm_w * sinf((norm_w*dt)/2.0f);
qhat_np1.w = t1*q_hat.w + t2*( - p*q_hat.x - q*q_hat.y - r*q_hat.z);
qhat_np1.x = t1*q_hat.x + t2*(p*q_hat.w + r*q_hat.y - q*q_hat.z);
qhat_np1.y = t1*q_hat.y + t2*(q*q_hat.w - r*q_hat.x + p*q_hat.z);
qhat_np1.z = t1*q_hat.z + t2*(r*q_hat.w + q*q_hat.x - p*q_hat.y);
q_hat = quaternion_normalize(qhat_np1);
}
else
{
// Euler Integration
// (Eq. 47a Mahoney Paper), but this is pretty straight-forward
quaternion_t qdot = {0.5f * ( - p*q_hat.x - q*q_hat.y - r*q_hat.z),
0.5f * ( p*q_hat.w + r*q_hat.y - q*q_hat.z),
0.5f * ( q*q_hat.w - r*q_hat.x + p*q_hat.z),
0.5f * ( r*q_hat.w + q*q_hat.x - p*q_hat.y)
};
q_hat.w += qdot.w*dt;
q_hat.x += qdot.x*dt;
q_hat.y += qdot.y*dt;
q_hat.z += qdot.z*dt;
q_hat = quaternion_normalize(q_hat);
}
}
// Save attitude estimate
_current_state.q = q_hat;
// Extract Euler Angles for controller
euler_from_quat(_current_state.q, &_current_state.euler.x, &_current_state.euler.y, &_current_state.euler.z);
// Save off adjust gyro measurements with estimated biases for control
_current_state.omega = vector_sub(_gyro_LPF, b);
}
Color Raytracer::trace(Scene *scene, Ray ray, int depth)
{
if (depth >= m_max_depth)
{
return scene->background();
}
Intersection *intersection = get_closest_intersection(scene, ray);
// If this ray hits nothing, return the background color
if (intersection == nullptr)
{
return scene->background();
}
// local illumination
Color rv = m_phong_shader.shade(scene, intersection);
float kr = intersection->intersected_shape()->reflective_constant();
float kt = intersection->intersected_shape()->transmissive_constant();
// spawn reflection ray
if (kr > 0)
{
Ray reflection = make_reflection_ray(intersection->normal(), ray,
intersection->intersection_point());
rv += trace(scene, reflection, depth + 1) * kr;
}
// spawn transmission ray
if (kt > 0)
{
float alpha;
bool insideShape =
(dot_product(negate_vector(ray.direction()), intersection->normal()) < 0);
if (insideShape)
{
intersection->set_normal(negate_vector(intersection->normal()));
alpha = intersection->intersected_shape()->refraction_index();
}
else
{
alpha = 1.0 / intersection->intersected_shape()->refraction_index();
}
float cosine = dot_product(negate_vector(ray.direction()), intersection->normal());
float discriminant = 1.0 + ( (alpha * alpha) *
((cosine * cosine) - 1.0) );
bool total_internal_reflection = (discriminant < 0);
if (total_internal_reflection)
{
// use the reflection ray with the kt value
Ray reflection = make_reflection_ray(intersection->normal(), ray,
intersection->intersection_point());
rv += trace(scene, reflection, depth + 1) * kt;
}
else
{
// spawn a transmission ray
Ray transmission(intersection->intersection_point(),
normalize(
vector_add(scalar_multiply(ray.direction(), alpha),
scalar_multiply(intersection->normal(),
(alpha * cosine) -
sqrt(discriminant)))));
rv += trace(scene, transmission, depth + 1) * kt;
}
}
delete intersection;
return rv;
}
int main(void)
{
int a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int b[] = {4, 6, 8, 2, 4, 3, 5, 8};
int c[8];
int size = sizeof(a) / sizeof(a[0]);
int v1[] = {1, 2, 3};
int v2[] = {3, 4, 7};
int vsize = sizeof(v1) / sizeof(v1[0]);
int v3[sizeof(v1) / sizeof(v1[0])];
int product;
/* reverse an array */
printf("Array a:\n");
print_array(a, size);
reverse_array(a, size);
printf("Array a reversed:\n");
print_array(a, size);
printf("\n");
/* add two arrays into a third array */
printf("Array b:\n");
print_array(b, size);
add_arrays(a, b, c, size);
printf("Array c (sum of array a and array b):\n");
print_array(c, size);
printf("\n");
/* multiply each element by 10 */
scalar_multiply(c, size, 10);
printf("All values of c multiplied by 10:\n");
print_array(c, size);
printf("\n");
/* multiply two arrays (dot product) */
printf("Array v1:");
print_array(v1, vsize);
printf("Array v2:");
print_array(v2, vsize);
product = dot_product(v1, v2, vsize);
printf("The dot product of v1 * v2 is %i\n", product);
printf("\n");
/* multiply two arrays (cross product) */
printf("Array v1:");
print_array(v1, vsize);
printf("Array v2:");
print_array(v2, vsize);
cross_product(v1, v2, v3);
printf("The cross product of v1 x v2 is:");
print_array(v3, 3);
printf("\n");
/* more tests */
test1();
test2();
printf("\n");
return 0;
}
