static bool find_third_point(int num_points, const double (*points)[3], int a, int b, int* p_c) { const double* x1 = points[a]; const double* x2 = points[b]; double x2x1[3] = {x2[0] - x1[0], x2[1] - x1[1], x2[2] - x1[2]}; double ns_x2x1 = norm_squared(x2x1); int bi = -1; double max_dist = 0.0; for (int i = 0;i<num_points;i++) { if (i == a || i == b) continue; const double* x0 = points[i]; double x1x0[3] = {x1[0] - x0[0], x1[1] - x0[1], x1[2] - x0[2]}; double dot = dot_product(x1x0, x2x1); double dist = (norm_squared(x1x0) * ns_x2x1 - dot*dot) / ns_x2x1; if (dist > max_dist) { max_dist = dist; bi = i; } } *p_c = bi; return max_dist > TOLERANCE; }
/// normalization inline __host__ __device__ float normalize() { float l = sqrtf(norm_squared()); float f = 1.f / l; x *= f; y *= f; z *= f; return l; }
/// normalization float normalize() { float l = sqrtf(norm_squared()); float f = 1.f / l; x *= f; y *= f; z *= f; return l; }
/// normalization inline __host__ __device__ float safe_normalize(const float eps = 1e-10f) { float l = sqrtf(norm_squared()); if(l > eps){ float f = 1.f / l; x *= f; y *= f; z *= f; return l; } else { x = 1.f; y = 0.f; z = 0.f; return 0.f; } }
inline double skew_x( VerdictVector& q1, VerdictVector& q2, VerdictVector& q3, VerdictVector& qw1, VerdictVector& qw2, VerdictVector& qw3 ) { double normsq1, normsq2, kappa; VerdictVector u1, u2, u3; VerdictVector x1, x2, x3; inverse(qw1,qw2,qw3,u1,u2,u3); product(q1,q2,q3,u1,u2,u3,x1,x2,x3); inverse(x1,x2,x3,u1,u2,u3); normsq1 = norm_squared(x1,x2,x3); normsq2 = norm_squared(u1,u2,u3); kappa = sqrt( normsq1 * normsq2 ); double skew = 0; if ( kappa > VERDICT_DBL_MIN ) skew = 3/kappa; return skew; }
static void calculate_plane_normal(const double (*points)[3], int a, int b, int c, double* plane_normal) { double u[3] = { points[b][0] - points[a][0], points[b][1] - points[a][1], points[b][2] - points[a][2] }; double v[3] = { points[c][0] - points[a][0], points[c][1] - points[a][1], points[c][2] - points[a][2] }; cross_product(u, v, plane_normal); double norm = sqrt(norm_squared(plane_normal)); plane_normal[0] /= norm; plane_normal[1] /= norm; plane_normal[2] /= norm; }
void PitchFlockViewer::plot_bend () { const size_t I = synth().size; const size_t X = Rectangle::width(); const size_t Y = Rectangle::height(); const float * restrict power = get_power(); const float * restrict energy = get_energy(); const float * restrict bend = synth().get_bend(); float * restrict red = m_bend_image.red; float * restrict green = m_bend_image.green; float * restrict blue = m_bend_image.blue; float energy_gain = m_energy_gain.update(max(get_energy())); float power_gain = m_power_gain.update(max(get_power())); float bend_variance = norm_squared(synth().get_bend()) / I; float bend_gain = m_bend_gain.update(bend_variance); float min_freq = min(synth().get_freq()); float max_freq = max(synth().get_freq()); float pitch_scale = 1 / log(max_freq / min_freq); if (m_image_mutex.try_lock()) { for (size_t i = 0; i < I; ++i) { float m = energy_gain * energy[i]; float e = power_gain * power[i]; float b = atanf(0.5f * bend_gain * bend[i]) / M_PI + 0.5f; float p = static_cast<float>(i) / I + pitch_scale * log(1 + bend[i]); BilinearInterpolate lin(b * X, X, p * Y, Y); lin.imax(red, e); lin.imax(green, m); lin.imax(blue, 1); } m_image_mutex.unlock(); } }
static int initial_simplex(int num_points, const double (*points)[3], int* initial_vertices) { int min_index[3] = {0}; int max_index[3] = {0}; if (!calc_max_extent(num_points, points, min_index, max_index)) return -1; int bi = -1; double max_dist = 0.0; for (int i = 0;i<3;i++) { int a = min_index[i], b = max_index[i]; double delta[3] = { points[a][0] - points[b][0], points[a][1] - points[b][1], points[a][2] - points[b][2] }; double dist = norm_squared(delta); if (dist > max_dist) { bi = i; max_dist = dist; } } //first two points are (a, b) int a = min_index[bi], b = max_index[bi], c = -1, d = -1; if (!find_third_point(num_points, points, a, b, &c)) return -2; if (!find_fourth_point(num_points, points, a, b, c, &d)) return -3; initial_vertices[0] = a; initial_vertices[1] = b; initial_vertices[2] = c; initial_vertices[3] = d; return 0; }
/// norm inline __host__ __device__ float norm() const { return sqrtf(norm_squared()); }
/// normalization inline __host__ __device__ Vec3 normalized() const { return (*this) * (1.f/sqrtf(norm_squared())); }
OMEGA_H_INLINE Real norm(Vector<n> v) { return sqrt(norm_squared(v)); }
/// norm float norm() const { return sqrtf(norm_squared()); }
/// normalization Vec3 normalized() const { return (*this) * (1.f/sqrtf(norm_squared())); }
INLINE Real squared_metric_length(Vector<dim> v, DummyIsoMetric) { return norm_squared(v); }
double norm( const std::vector<double>& v ) { return sqrt( norm_squared( v ) ); }