void
vlib_clear_combined_counters (vlib_combined_counter_main_t * cm)
{
uword i, j;
vlib_mini_counter_t *my_minis;
for (i = 0; i < vec_len (cm->minis); i++)
{
my_minis = cm->minis[i];
for (j = 0; j < vec_len (my_minis); j++)
{
cm->maxi[j].packets += my_minis[j].packets;
cm->maxi[j].bytes += my_minis[j].bytes;
my_minis[j].packets = 0;
my_minis[j].bytes = 0;
}
}
j = vec_len (cm->maxi);
if (j > 0)
vec_validate (cm->value_at_last_clear, j - 1);
for (i = 0; i < j; i++)
{
vlib_counter_t *c = vec_elt_at_index (cm->value_at_last_clear, i);
c[0] = cm->maxi[i];
}
}
static void do_emit_data(Vector *inits, int size, int off, int depth) {
SAVE;
for (int i = 0; i < vec_len(inits) && 0 < size; i++) {
Node *node = vec_get(inits, i);
Node *v = node->initval;
emit_padding(node, off);
if (node->totype->bitsize > 0) {
assert(node->totype->bitoff == 0);
long data = eval_intexpr(v, NULL);
Type *totype = node->totype;
for (i++ ; i < vec_len(inits); i++) {
node = vec_get(inits, i);
if (node->totype->bitsize <= 0) {
break;
}
v = node->initval;
totype = node->totype;
data |= ((((long)1 << totype->bitsize) - 1) & eval_intexpr(v, NULL)) << totype->bitoff;
}
emit_data_primtype(totype, &(Node){ AST_LITERAL, totype, .ival = data }, depth);
off += totype->size;
size -= totype->size;
if (i == vec_len(inits))
break;
} else {
int
test1 (void)
{
clib_time_t clib_time;
void *h_mem = clib_mem_alloc (2ULL << 30);
void *h;
uword *objects = 0;
int i;
f64 before, after;
clib_time_init (&clib_time);
vec_validate (objects, 2000000 - 1);
h = mheap_alloc (h_mem, (uword) (2 << 30));
before = clib_time_now (&clib_time);
for (i = 0; i < vec_len (objects); i++)
{
h = mheap_get_aligned (h, 24 /* size */ ,
64 /* align */ ,
16 /* align at offset */ , &objects[i]);
}
after = clib_time_now (&clib_time);
fformat (stdout, "alloc: %u objects in %.2f seconds, %.2f objects/second\n",
vec_len (objects), (after - before),
((f64) vec_len (objects)) / (after - before));
return 0;
}
/* Take each x, y, and z and divide by the length for each
* Hint: newX = x / vec.len(v)
*/
vector_t vec_normalize(vector_t v)
{
vector_t vec;
vec.x = v.x / vec_len(v);
vec.y = v.y / vec_len(v);
vec.z = v.z / vec_len(v);
return vec;
}
/* Take each x, y, and z and divide by the length for each
* Hint: newX = x / vec.len(v)
*/
vector_t vec_normalize(vector_t v)
{
vector_t res;
res.x = v.x / vec_len(v);
res.y = v.y / vec_len(v);
res.z = v.z / vec_len(v);
return res;
}
static void fields(node_t * sym)
{
int follow[] = {INT, CONST, '}', IF, 0};
node_t *sty = SYM_TYPE(sym);
if (!first_decl(token)) {
error("expect type name or qualifiers");
return;
}
struct vector *v = vec_new();
do {
node_t *basety = specifiers(NULL, NULL);
for (;;) {
node_t *field = new_field();
if (token->id == ':') {
bitfield(field);
FIELD_TYPE(field) = basety;
} else {
node_t *ty = NULL;
struct token *id = NULL;
declarator(&ty, &id, NULL);
attach_type(&ty, basety);
if (token->id == ':')
bitfield(field);
FIELD_TYPE(field) = ty;
if (id) {
for (int i = 0; i < vec_len(v); i++) {
node_t *f = vec_at(v, i);
if (FIELD_NAME(f) &&
!strcmp(FIELD_NAME(f), id->name)) {
errorf(id->src,
"redefinition of '%s'",
id->name);
break;
}
}
FIELD_NAME(field) = id->name;
AST_SRC(field) = id->src;
}
}
vec_push(v, field);
if (token->id != ',')
break;
expect(',');
ensure_field(field, vec_len(v), false);
}
match(';', follow);
ensure_field(vec_tail(v), vec_len(v),
isstruct(sty) && !first_decl(token));
} while (first_decl(token));
TYPE_FIELDS(sty) = (node_t **) vtoa(v);
set_typesize(sty);
}
static clib_error_t *
show_errors (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
vlib_error_main_t *em = &vm->error_main;
vlib_node_t *n;
u32 code, i, ni;
u64 c;
int index = 0;
int verbose = 0;
u64 *sums = 0;
if (unformat (input, "verbose %d", &verbose))
;
else if (unformat (input, "verbose"))
verbose = 1;
vec_validate (sums, vec_len (em->counters));
if (verbose)
vlib_cli_output (vm, "%=10s%=40s%=20s%=6s", "Count", "Node", "Reason",
"Index");
else
vlib_cli_output (vm, "%=10s%=40s%=6s", "Count", "Node", "Reason");
/* *INDENT-OFF* */
foreach_vlib_main(({
em = &this_vlib_main->error_main;
if (verbose)
vlib_cli_output(vm, "Thread %u (%v):", index,
vlib_worker_threads[index].name);
for (ni = 0; ni < vec_len (this_vlib_main->node_main.nodes); ni++)
{
n = vlib_get_node (this_vlib_main, ni);
for (code = 0; code < n->n_errors; code++)
{
i = n->error_heap_index + code;
c = em->counters[i];
if (i < vec_len (em->counters_last_clear))
c -= em->counters_last_clear[i];
sums[i] += c;
if (c == 0 && verbose < 2)
continue;
if (verbose)
vlib_cli_output (vm, "%10Ld%=40v%=20s%=6d", c, n->name,
em->error_strings_heap[i], i);
else
vlib_cli_output (vm, "%10d%=40v%s", c, n->name,
em->error_strings_heap[i]);
}
}
index++;
}));
int
main (int argc, char *argv[])
{
word i, n = atoi (argv[1]);
word run_foo = argc > 2;
bar_t b = { limit:10 };
if (run_foo)
{
f64 time_limit;
time_limit = atof (argv[2]);
vec_resize (foos, n);
for (i = 0; i < n; i++)
{
foos[i].time_requested = time_limit * random_f64 ();
foos[i].time_called = 1e100;
}
foo_base_time = unix_time_now ();
for (i = 0; i < n; i++)
timer_call (foo, i, foos[i].time_requested);
}
else
timer_call (bar, (any) & b, random_f64 ());
while (vec_len (timers) > 0)
os_sched_yield ();
if (vec_len (foos) > 0)
{
f64 min = 1e100, max = -min;
f64 ave = 0, rms = 0;
for (i = 0; i < n; i++)
{
f64 dt = foos[i].time_requested - foos[i].time_called;
if (dt < min)
min = dt;
if (dt > max)
max = dt;
ave += dt;
rms += dt * dt;
}
ave /= n;
rms = sqrt (rms / n - ave * ave);
fformat (stdout, "error min %g max %g ave %g +- %g\n", min, max, ave,
rms);
}
fformat (stdout, "%d function calls, ave. timer delay %g secs\n",
ave_delay_count, ave_delay / ave_delay_count);
return 0;
}
/* Reserves given number of error codes for given node. */
void
vlib_register_errors (vlib_main_t * vm,
u32 node_index, u32 n_errors, char *error_strings[])
{
vlib_error_main_t *em = &vm->error_main;
vlib_node_t *n = vlib_get_node (vm, node_index);
uword l;
ASSERT (os_get_cpu_number () == 0);
/* Free up any previous error strings. */
if (n->n_errors > 0)
heap_dealloc (em->error_strings_heap, n->error_heap_handle);
n->n_errors = n_errors;
n->error_strings = error_strings;
if (n_errors == 0)
return;
n->error_heap_index =
heap_alloc (em->error_strings_heap, n_errors, n->error_heap_handle);
l = vec_len (em->error_strings_heap);
clib_memcpy (vec_elt_at_index (em->error_strings_heap, n->error_heap_index),
error_strings, n_errors * sizeof (error_strings[0]));
/* Allocate a counter/elog type for each error. */
vec_validate (em->counters, l - 1);
vec_validate (vm->error_elog_event_types, l - 1);
/* Zero counters for re-registrations of errors. */
if (n->error_heap_index + n_errors <= vec_len (em->counters_last_clear))
clib_memcpy (em->counters + n->error_heap_index,
em->counters_last_clear + n->error_heap_index,
n_errors * sizeof (em->counters[0]));
else
memset (em->counters + n->error_heap_index,
0, n_errors * sizeof (em->counters[0]));
{
elog_event_type_t t;
uword i;
memset (&t, 0, sizeof (t));
for (i = 0; i < n_errors; i++)
{
t.format = (char *) format (0, "%v %s: %%d",
n->name, error_strings[i]);
vm->error_elog_event_types[n->error_heap_index + i] = t;
}
}
}
static void
dump_closure (test_main_t * tm, char *s, u8 ** orig)
{
int i, j;
fformat (stdout, "--------- %s --------------\n", s);
for (i = 0; i < vec_len (orig); i++)
{
for (j = 0; j < vec_len (orig); j++)
if (orig[i][j])
{
fformat (stdout, "%s <before> %s\n", items[i], items[j]);
}
}
}
void
efp_charge_octupole_grad(double q1, const double *oct2, const vec_t *dr,
vec_t *force, vec_t *add1, vec_t *add2)
{
double r = vec_len(dr);
double r3 = r * r * r;
double r7 = r3 * r3 * r;
double r9 = r3 * r3 * r3;
double t1x = q1 / r7 * octupole_sum_xyz(oct2, dr, 0);
double t1y = q1 / r7 * octupole_sum_xyz(oct2, dr, 1);
double t1z = q1 / r7 * octupole_sum_xyz(oct2, dr, 2);
double g = 7.0 * q1 / r9 * octupole_sum(oct2, dr);
force->x = -g * dr->x + t1x;
force->y = -g * dr->y + t1y;
force->z = -g * dr->z + t1z;
add1->x = 0.0;
add1->y = 0.0;
add1->z = 0.0;
add2->x = t1y * dr->z - t1z * dr->y;
add2->y = t1z * dr->x - t1x * dr->z;
add2->z = t1x * dr->y - t1y * dr->x;
}
static void
vl_unmap_shmem_internal (u8 is_client)
{
svm_region_t *rp;
int i;
api_main_t *am = &api_main;
if (!svm_get_root_rp ())
return;
for (i = 0; i < vec_len (am->mapped_shmem_regions); i++)
{
rp = am->mapped_shmem_regions[i];
is_client ? svm_region_unmap_client (rp) : svm_region_unmap (rp);
}
vec_free (am->mapped_shmem_regions);
am->shmem_hdr = 0;
is_client ? svm_region_exit_client () : svm_region_exit ();
/* $$$ more careful cleanup, valgrind run... */
vec_free (am->msg_handlers);
vec_free (am->msg_endian_handlers);
vec_free (am->msg_print_handlers);
}
static clib_error_t *
sendmsg_helper (mc_socket_main_t * msm,
int socket,
struct sockaddr_in * tx_addr,
u32 buffer_index)
{
vlib_main_t * vm = msm->mc_main.vlib_main;
struct msghdr h;
word n_bytes, n_bytes_tx, n_retries;
memset (&h, 0, sizeof (h));
h.msg_name = tx_addr;
h.msg_namelen = sizeof (tx_addr[0]);
if (msm->iovecs)
_vec_len (msm->iovecs) = 0;
n_bytes = append_buffer_index_to_iovec (vm, buffer_index, &msm->iovecs);
ASSERT (n_bytes <= msm->mc_main.transport.max_packet_size);
if (n_bytes > msm->mc_main.transport.max_packet_size)
clib_error ("sending packet larger than interace MTU %d bytes", n_bytes);
h.msg_iov = msm->iovecs;
h.msg_iovlen = vec_len (msm->iovecs);
n_retries = 0;
while ((n_bytes_tx = sendmsg (socket, &h, /* flags */ 0)) != n_bytes
&& errno == EAGAIN)
n_retries++;
if (n_bytes_tx != n_bytes)
{
clib_unix_warning ("sendmsg");
return 0;
}
if (n_retries)
{
ELOG_TYPE_DECLARE (e) = {
.format = "sendmsg-helper: %d retries",
.format_args = "i4",
};
struct { u32 retries; } * ed = 0;
ed = ELOG_DATA (&vm->elog_main, e);
ed->retries = n_retries;
}
return 0;
}
static clib_error_t *
tx_buffer (void * transport, mc_transport_type_t type, u32 buffer_index)
{
mc_socket_main_t *msm = (mc_socket_main_t *)transport;
vlib_main_t * vm = msm->mc_main.vlib_main;
mc_multicast_socket_t * ms = &msm->multicast_sockets[type];
clib_error_t * error;
error = sendmsg_helper (msm, ms->socket, &ms->tx_addr, buffer_index);
if (type != MC_TRANSPORT_USER_REQUEST_TO_RELAY)
vlib_buffer_free_one (vm, buffer_index);
return error;
}
void cnat_port_free_v2 (
cnat_portmap_v2_t *pm,
int index,
port_pair_t pair_type,
u16 base_port,
u16 static_port_range)
{
cnat_portmap_v2_t *my_pm;
uword bit;
/* check for valid portmap */
if (PREDICT_FALSE(index > vec_len(pm))) {
spp_printf(CNAT_INVALID_INDEX_TO_FREE_PORT, 0, 0);
return;
}
my_pm = pm + index;
bit = port2bit(base_port);
#if DEBUG > 0
if(clib_bitmap_get_no_check(my_pm->bm, bit))
ASSERT(clib_bitmap_get_no_check(my_pm->bm, bit) == 0);
#endif
cgn_clib_bitmap_set_no_check(my_pm->bm, bit);
my_pm->inuse -= 1;
if(base_port >= static_port_range) {
/* Clear the full flag. we can have a new dynamic session now */
my_pm->dyn_full = 0;
}
return;
}
u8 *
format_dpdk_flow (u8 * s, va_list * args)
{
u32 dev_instance = va_arg (*args, u32);
u32 flow_index = va_arg (*args, u32);
uword private_data = va_arg (*args, uword);
dpdk_main_t *dm = &dpdk_main;
dpdk_device_t *xd = vec_elt_at_index (dm->devices, dev_instance);
dpdk_flow_entry_t *fe;
if (flow_index == ~0)
{
s = format (s, "%-25s: %U\n", "supported flow actions",
format_flow_actions, xd->supported_flow_actions);
s = format (s, "%-25s: %d\n", "last DPDK error type",
xd->last_flow_error.type);
s = format (s, "%-25s: %s\n", "last DPDK error message",
xd->last_flow_error.message ? xd->last_flow_error.message :
"n/a");
return s;
}
if (private_data >= vec_len (xd->flow_entries))
return format (s, "unknown flow");
fe = vec_elt_at_index (xd->flow_entries, private_data);
s = format (s, "mark %u", fe->mark);
return s;
}
static int
flowprobe_template_add_del (u32 domain_id, u16 src_port,
flowprobe_record_t flags,
vnet_flow_data_callback_t * flow_data_callback,
vnet_flow_rewrite_callback_t * rewrite_callback,
bool is_add, u16 * template_id)
{
flow_report_main_t *frm = &flow_report_main;
vnet_flow_report_add_del_args_t a = {
.rewrite_callback = rewrite_callback,
.flow_data_callback = flow_data_callback,
.is_add = is_add,
.domain_id = domain_id,
.src_port = src_port,
.opaque.as_uword = flags,
};
return vnet_flow_report_add_del (frm, &a, template_id);
}
static void
flowprobe_expired_timer_callback (u32 * expired_timers)
{
vlib_main_t *vm = vlib_get_main ();
flowprobe_main_t *fm = &flowprobe_main;
u32 my_cpu_number = vm->thread_index;
int i;
u32 poolindex;
for (i = 0; i < vec_len (expired_timers); i++)
{
poolindex = expired_timers[i] & 0x7FFFFFFF;
vec_add1 (fm->expired_passive_per_worker[my_cpu_number], poolindex);
}
}
void cpp_eval(char *buf) {
stream_stash(make_file_string(buf));
Vector *toplevels = read_toplevels();
for (int i = 0; i < vec_len(toplevels); i++)
emit_toplevel(vec_get(toplevels, i));
stream_unstash();
}
void
efp_dipole_dipole_grad(const vec_t *d1, const vec_t *d2, const vec_t *dr,
vec_t *force, vec_t *add1, vec_t *add2)
{
double r = vec_len(dr);
double r3 = r * r * r;
double r5 = r3 * r * r;
double r7 = r5 * r * r;
double d1dr = vec_dot(d1, dr);
double d2dr = vec_dot(d2, dr);
double t1 = 3.0 / r5;
double t2 = t1 * vec_dot(d1, d2) - 15.0 / r7 * d1dr * d2dr;
force->x = t2 * dr->x + t1 * (d2dr * d1->x + d1dr * d2->x);
force->y = t2 * dr->y + t1 * (d2dr * d1->y + d1dr * d2->y);
force->z = t2 * dr->z + t1 * (d2dr * d1->z + d1dr * d2->z);
add1->x = d1->y * (d2->z / r3 - t1 * dr->z * d2dr) -
d1->z * (d2->y / r3 - t1 * dr->y * d2dr);
add1->y = d1->z * (d2->x / r3 - t1 * dr->x * d2dr) -
d1->x * (d2->z / r3 - t1 * dr->z * d2dr);
add1->z = d1->x * (d2->y / r3 - t1 * dr->y * d2dr) -
d1->y * (d2->x / r3 - t1 * dr->x * d2dr);
add2->x = d2->y * (d1->z / r3 - t1 * dr->z * d1dr) -
d2->z * (d1->y / r3 - t1 * dr->y * d1dr);
add2->y = d2->z * (d1->x / r3 - t1 * dr->x * d1dr) -
d2->x * (d1->z / r3 - t1 * dr->z * d1dr);
add2->z = d2->x * (d1->y / r3 - t1 * dr->y * d1dr) -
d2->y * (d1->x / r3 - t1 * dr->x * d1dr);
}
double
efp_charge_charge_energy(double q1, double q2, const vec_t *dr)
{
double r = vec_len(dr);
return q1 * q2 / r;
}
int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which)
{
vl_api_trace_t *tp;
int i;
switch(which)
{
case VL_API_TRACE_TX:
tp = am->tx_trace;
break;
case VL_API_TRACE_RX:
tp = am->rx_trace;
break;
default:
/* duh? */
return -1;
}
/* Configured? */
if (!tp || tp->nitems == 0)
return -1;
tp->curindex = 0;
tp->wrapped = 0;
for (i = 0; i < vec_len(tp->traces); i++) {
vec_free(tp->traces[i]);
}
vec_free(tp->traces);
return 0;
}
int64_t decode(void *buffer, size_t size, int64_t sum)
{
unsigned int i;
C(table_t) foobarcontainer;
FooBar(vec_t) list;
FooBar(table_t) foobar;
Bar(struct_t) bar;
Foo(struct_t) foo;
foobarcontainer = C(as_root(buffer));
sum += C(initialized(foobarcontainer));
sum += StringLen(C(location(foobarcontainer)));
sum += C(fruit(foobarcontainer));
list = C(list(foobarcontainer));
for (i = 0; i < FooBar(vec_len(list)); ++i) {
foobar = FooBar(vec_at(list, i));
sum += StringLen(FooBar(name(foobar)));
sum += FooBar(postfix(foobar));
sum += (int64_t)FooBar(rating(foobar));
bar = FooBar(sibling(foobar));
sum += (int64_t)Bar(ratio(bar));
sum += Bar(size(bar));
sum += Bar(time(bar));
foo = Bar(parent(bar));
sum += Foo(count(foo));
sum += Foo(id(foo));
sum += Foo(length(foo));
sum += Foo(prefix(foo));
}
return sum + 2 * sum;
}
/* Construct a unit vector v2 in direction of input vector v1 */
void vec_unit(
vec_t *v1, /* Input vector */
vec_t *v2) /* output unit vec */
{
double mult = 1 / vec_len(v1);
vec_scale(mult, v1, v2);
}
double
efp_quadrupole_quadrupole_energy(const double *quad1, const double *quad2, const vec_t *dr)
{
double r = vec_len(dr);
double r2 = r * r;
double r5 = r2 * r2 * r;
double r7 = r5 * r2;
double r9 = r7 * r2;
double q1dr = quadrupole_sum(quad1, dr);
double q2dr = quadrupole_sum(quad2, dr);
double q1q2 = 0.0;
double q1q2dr = 0.0;
for (size_t a = 0; a < 3; a++) {
double t1 = 0.0;
double t2 = 0.0;
for (size_t b = 0; b < 3; b++) {
size_t idx = quad_idx(a, b);
t1 += quad1[idx] * vec_get(dr, b);
t2 += quad2[idx] * vec_get(dr, b);
q1q2 += quad1[idx] * quad2[idx];
}
q1q2dr += t1 * t2;
}
return (2.0 / r5 * q1q2 - 20.0 / r7 * q1q2dr + 35.0 / r9 * q1dr * q2dr) / 3.0;
}
vec_t vec_normalize(vec_t a){
if (vec_zero(a)){
return a;
}else{
return vec_scale(a,1.0/vec_len(a));
}
}
void
efp_charge_quadrupole_grad(double q1, const double *quad2, const vec_t *dr,
vec_t *force, vec_t *add1, vec_t *add2)
{
double r = vec_len(dr);
double r2 = r * r;
double r5 = r2 * r2 * r;
double r7 = r5 * r2;
double t1x = q1 / r5 * -2.0 * (dr->x * quad2[quad_idx(0, 0)] +
dr->y * quad2[quad_idx(0, 1)] +
dr->z * quad2[quad_idx(0, 2)]);
double t1y = q1 / r5 * -2.0 * (dr->x * quad2[quad_idx(1, 0)] +
dr->y * quad2[quad_idx(1, 1)] +
dr->z * quad2[quad_idx(1, 2)]);
double t1z = q1 / r5 * -2.0 * (dr->x * quad2[quad_idx(2, 0)] +
dr->y * quad2[quad_idx(2, 1)] +
dr->z * quad2[quad_idx(2, 2)]);
double g = 5.0 * q1 / r7 * quadrupole_sum(quad2, dr);
force->x = g * dr->x + t1x;
force->y = g * dr->y + t1y;
force->z = g * dr->z + t1z;
add1->x = 0.0;
add1->y = 0.0;
add1->z = 0.0;
add2->x = t1z * dr->y - t1y * dr->z;
add2->y = t1x * dr->z - t1z * dr->x;
add2->z = t1y * dr->x - t1x * dr->y;
}
void
vlib_unix_error_report (vlib_main_t * vm, clib_error_t * error)
{
unix_main_t *um = &unix_main;
if (um->flags & UNIX_FLAG_INTERACTIVE || error == 0)
return;
{
char save;
u8 *msg;
u32 msg_len;
msg = error->what;
msg_len = vec_len (msg);
/* Null Terminate. */
save = msg[msg_len - 1];
msg[msg_len - 1] = 0;
syslog (LOG_ERR | LOG_DAEMON, "%s", msg);
msg[msg_len - 1] = save;
}
}
static vnet_config_t *
find_config_with_features (vlib_main_t * vm,
vnet_config_main_t * cm,
vnet_config_feature_t * feature_vector)
{
u32 last_node_index = ~0;
vnet_config_feature_t * f;
u32 * config_string;
uword * p;
vnet_config_t * c;
config_string = cm->config_string_temp;
cm->config_string_temp = 0;
if (config_string)
_vec_len (config_string) = 0;
vec_foreach (f, feature_vector)
{
/* Connect node graph. */
f->next_index = add_next (vm, cm, last_node_index, f->node_index);
last_node_index = f->node_index;
/* Store next index in config string. */
vec_add1 (config_string, f->next_index);
/* Store feature config. */
vec_add (config_string, f->feature_config, vec_len (f->feature_config));
}
//
// normalize a vector
//
void normalize(Vector *u) {
float p;
p = vec_len(*u);
(*u).x = (*u).x / p;
(*u).y = (*u).y / p;
(*u).z = (*u).z / p;
}
vec_t vec_norm(vec_t a){
float len = vec_len(a);
if(len == 0.0f){
return vec_new(1.0f,0.0f,0.0f,0.0f);
}else{
return vec_scale(1.0f/len,a);
}
}
double
efp_charge_dipole_energy(double q1, const vec_t *d2, const vec_t *dr)
{
double r = vec_len(dr);
double r3 = r * r * r;
return -q1 / r3 * vec_dot(d2, dr);
}
