WPBDC 2013.1.1

data/ext/WPBDC/bridge.c

@@ -0,0 +1,288 @@
+/*
+ * bridge.c -- Bridges
+ */
+
+// Constants and data structures Perl does not need to know about.
+#include "stdafx.h"
+#include "internal.h"
+
+// TBridge initialization values.  This must align  with declaration!
+// Set contents of a bridge to known-empty.
+void init_bridge(TBridge *bridge)
+{
+	static TBridge constant_init_bridge = INIT_BRIDGE;
+	*bridge = constant_init_bridge;
+}
+
+// Free allocated memory for a bridge and reset it to known-empty.
+void clear_bridge(TBridge *bridge)
+{
+	Safefree(bridge->designer);
+	Safefree(bridge->project_id);
+	Safefree(bridge->joints);
+	Safefree(bridge->members);
+	clear_load_scenario(&bridge->load_scenario);
+	init_bridge(bridge);
+}
+
+// Compare two joint lists (arrays) for functional equality.
+TBool joint_lists_eq(TJoint *a, TJoint *b, unsigned n)
+{
+	unsigned i;
+
+	for (i = 0; i < n; i++) {
+		if (a[i].x != b[i].x || a[i].y != b[i].y)
+			return False;
+	}
+	return True;
+}
+
+TBool x_section_lists_eq(TXSection *a, TXSection *b, unsigned n)
+{
+	return memcmp(a, b,	n * sizeof(TXSection)) == 0;
+}
+
+// Table mapping section to sectio name.
+static char *section_str_table[NSections] = {
+	"Bar",
+	"Tube",
+};
+
+char *section_str(TSection section)
+{
+	return (unsigned)section < NSections ? section_str_table[section] : "<unknown>";
+}
+
+// Compare two member lists (arrays) for functional equality.
+TBool member_lists_eq(TMember *a, TMember *b, unsigned n)
+{
+	unsigned i;
+
+	// Equality comparison must ignore the compression and tension strings.
+	for (i = 0; i < n; i++) {
+		if (a[i].start_joint != b[i].start_joint ||
+			a[i].end_joint != b[i].end_joint ||
+			!x_section_lists_eq(&a[i].x_section, &b[i].x_section, 1))
+
+			return False;
+	}
+
+	return True;
+}
+
+// Make a fresh copy of a bridge.  The bridge
+// can't be erroneous.  If so, the copy just
+// fails quietly.
+void copy_bridge(TBridge *dst, TBridge *src)
+{
+	if (src->error != BridgeNoError)
+		return;
+
+	clear_bridge(dst);
+
+	dst->version = src->version;
+	dst->test_status = src->test_status;
+	dst->scenario_descriptor = src->scenario_descriptor;
+	NewStr(145, dst->designer, src->designer);
+	NewStr(147, dst->project_id, src->project_id);
+	dst->n_design_iterations = src->n_design_iterations;
+	dst->n_joints = src->n_joints;
+	New(150, dst->joints, dst->n_joints + 1, TJoint);
+	memcpy(dst->joints, src->joints, (dst->n_joints + 1) * sizeof(TJoint));
+	dst->n_members = src->n_members;
+	New(160, dst->members, dst->n_members + 1, TMember);
+	memcpy(dst->members, src->members, (dst->n_members + 1) * sizeof(TMember));
+	dst->label_pos = src->label_pos;
+	copy_load_scenario(&dst->load_scenario, &src->load_scenario);
+}
+
+// Compare two bridges for identical geometry and materials.
+TBool bridges_indentical(TBridge *a, TBridge *b)
+{
+	return
+		a->version		== b->version									&&
+		a->scenario_descriptor.index == b->scenario_descriptor.index	&&
+		a->n_joints		== b->n_joints									&&
+		a->n_members	== b->n_members									&&
+		joint_lists_eq(&a->joints[1], &b->joints[1], b->n_joints)		&&
+		member_lists_eq(&a->members[1], &b->members[1],	b->n_members);
+}
+
+// Make a canonical variant of the source bridge.  This is just
+// sorting joints and members into a canonical order.  But we have
+// to keep joint references in members correct.
+void canonicalize(TBridge *dst, TBridge *src)
+{
+	unsigned *new_joint_to_old, *old_joint_to_new;
+	unsigned joint_index, member_index;
+
+	if (src->error != BridgeNoError)
+		return;
+
+	copy_bridge(dst, src);
+
+	Newz(170, new_joint_to_old, dst->n_joints + 1, unsigned);
+	for (joint_index = 1; joint_index <= dst->n_joints; joint_index++)
+		new_joint_to_old[joint_index] = joint_index;
+
+	{	// Indirect insertion sort of joint map so that, when done,
+		// joints[new_joint_to_old[i]] for sort_base + 1 <= i <= n_joints are in ascending order.
+		// Sort_base is first joint after those fixed by the scenario.  We could sort these, too,
+		// but then the canonical bridge won't be usable by the Designer.
+		// Sort order is lexicographic on x and then y.
+		unsigned i, j, t;
+		unsigned sort_base = dst->load_scenario.n_prescribed_joints + 1;
+		
+#define JointGT(A, B)								\
+		(dst->joints[A].x > dst->joints[B].x ||		\
+			(dst->joints[A].x == dst->joints[B].x &&\
+				dst->joints[A].y > dst->joints[B].y))
+
+		for (i = sort_base + 1; i <= dst->n_joints; i++) {
+			t = new_joint_to_old[i];
+			for (j = i; j > sort_base && JointGT(new_joint_to_old[j-1], t); j--)
+				new_joint_to_old[j] = new_joint_to_old[j-1];
+			new_joint_to_old[j] = t;
+		}
+	}
+
+	// Compute inverse map.
+	Newz(180, old_joint_to_new, dst->n_joints + 1, unsigned);
+	for (joint_index = 1; joint_index <= dst->n_joints; joint_index++)
+		old_joint_to_new[new_joint_to_old[joint_index]] = joint_index;
+
+	// Translate joint numbers in members.
+	for (member_index = 1; member_index <= dst->n_members; member_index++) {
+		dst->members[member_index].start_joint = old_joint_to_new[dst->members[member_index].start_joint];
+		dst->members[member_index].end_joint = old_joint_to_new[dst->members[member_index].end_joint];
+	}
+
+	// Now actually move the joints.
+	// Copy from source joints to avoid overlapping moves. Renumber while copying.
+	for (joint_index = 1; joint_index <= dst->n_joints; joint_index++) {
+		dst->joints[joint_index] = src->joints[new_joint_to_old[joint_index]];
+		dst->joints[joint_index].number = joint_index;
+	}
+
+	Safefree(new_joint_to_old);
+	Safefree(old_joint_to_new);
+
+	// Swap joint references so lowest joint number is first.
+	for (member_index = 1; member_index <= dst->n_members; member_index++) {
+		TElementNumber j1 = dst->members[member_index].start_joint;
+		TElementNumber j2 = dst->members[member_index].end_joint;
+		if (j1 > j2) {
+			dst->members[member_index].start_joint = j2;
+			dst->members[member_index].end_joint = j1;
+		}
+	}
+
+	{	// Now do a direct sort of members into a canonical order.
+		// We use lexicographic order on start_joint then end_joint.
+		unsigned i, j;
+		TMember t;
+		
+		for (i = 2; i <= dst->n_members; i++) {
+			t = dst->members[i];
+			for (	j = i; 
+					j > 1 && 
+						(dst->members[j-1].start_joint > t.start_joint ||
+							(dst->members[j-1].start_joint == t.start_joint &&
+								dst->members[j-1].end_joint > t.end_joint));
+					j--)
+				dst->members[j] = dst->members[j-1];
+			dst->members[j] = t;
+		}
+	}
+
+	// And renumber members, too.
+	for (member_index = 1; member_index <= dst->n_members; member_index++)
+		dst->members[member_index].number = member_index;
+
+	// Set error in the canonical bridge if there are geometry problems.
+	// First check for duplicate joints, which will show up as adjacent
+	// in the canonical bridge.
+	for (joint_index = 1; joint_index < dst->n_joints; joint_index++) {
+		if (joint_lists_eq(
+				&dst->joints[joint_index], 
+				&dst->joints[joint_index + 1], 1)) {
+			clear_bridge(dst);
+			dst->error = BridgeDupJoints;
+			return;
+		}
+	}
+
+	// Check for duplicate members, which, again, will show up as adjacent
+	// in canonical bridge.
+	for (member_index = 1; member_index < dst->n_members; member_index++) {
+		if (member_lists_eq(
+				&dst->members[member_index], 
+				&dst->members[member_index + 1], 1)) {
+			clear_bridge(dst);
+			dst->error = BridgeDupMembers;
+			return;
+		}
+	}
+
+	// Finally check for joints lying exactly on members.
+	for (member_index = 1; member_index <= dst->n_members; member_index++) {
+
+		TMember *member = &dst->members[member_index];
+		TJoint *start = &dst->joints[member->start_joint];
+		TJoint *end = &dst->joints[member->end_joint];
+
+		for (joint_index = 1; joint_index <= dst->n_joints; joint_index++) {
+			long A, B;
+			TJoint *joint;
+
+			// First make sure we're not looking at one of the member's ends!
+			if (joint_index == member->start_joint ||
+				joint_index == member->end_joint)
+				continue;
+
+			// Ignore joints that are outside the rectangular extent of the member.
+			joint = &dst->joints[joint_index];
+			if (start->x > joint->x && end->x > joint->x ||
+				start->x < joint->x && end->x < joint->x ||
+				start->y > joint->y && end->y > joint->y ||
+				start->y < joint->y && end->y < joint->y)
+				continue;
+
+			// Check if the joint is on the line struck by the member ends.
+			A = end->y - start->y;
+			B = start->x - end->x;
+			if (A * start->x + B * start->y == A * joint->x + B * joint->y) {
+				clear_bridge(dst);
+				dst->error = BridgeJointOnMember;
+				return;
+			}
+		}
+	}
+}
+
+void print_material(FILE *f,
+					unsigned index,
+					TMaterial *material)
+{
+	unsigned section_index;
+
+	fprintf(f, "[%u] material '%s (%s)':\n", index, material->name, material->short_name);
+	fprintf(f, " elasticity     = %.4f\n", material->E);
+	fprintf(f, " yield strength = %.4f\n", material->Fy);
+	fprintf(f, " density        = %.4f\n", material->density);
+	fprintf(f, " cost:\n");
+	for (section_index = 0; section_index < NSections; section_index++)
+		fprintf(f, "%4s = %f\n", section_str(section_index), material->cost[section_index]);
+}
+
+void print_shape(FILE *f,
+				 unsigned section_index,
+				 unsigned size_index,
+				 TShape *shape)
+{
+	fprintf(f, "[section=%u, size=%u] shape %s:\n", section_index, size_index, shape->name);
+	fprintf(f, " width  = %.4f\n", shape->width);
+	fprintf(f, " area   = %.4f\n", shape->area);
+	fprintf(f, " moment = %.4f\n", shape->moment);
+}
+

data/ext/WPBDC/bridge_cost.c

@@ -0,0 +1,60 @@
+#include "stdafx.h"
+#include "internal.h"
+
+// Compute the complete cost of a bridge.
+TFloat bridge_cost(TBridge *bridge, TGeometry *geometry, TParams *params)
+{
+	unsigned i, member_index;
+	TFloat mtl_cost, connection_cost, product_cost;
+	TXSection used[NMaterials * NSections * MaxNSizes];
+	unsigned n_used = 0;
+	TGeometry local_geometry[1];
+	TParams local_params[1];
+
+	if (bridge->error != BridgeNoError)
+		return 0.00;
+
+	// If caller didn't provide these things, we'll do it ourself.
+	if (!geometry) {
+		geometry = local_geometry;
+		init_geometry(geometry);
+		setup_geometry(geometry, bridge);
+	}
+
+	if (!params) {
+		params = local_params;
+		init_params(params);
+		setup_params(params);
+	}
+
+	// Loop counts number of unique material types for ordering fee.
+	// Loop also totals material cost based on volume, density, and cost per unit weight.
+	mtl_cost = 0.00;
+	for (member_index = 1; member_index <= bridge->n_members; member_index++) {
+	
+		TXSection *xs = &bridge->members[member_index].x_section;
+
+		mtl_cost += 
+			params->materials[xs->material].cost[xs->section] *
+			params->shapes[xs->section][xs->size].area *
+			geometry->length[member_index] *
+			params->materials[xs->material].density;
+
+		// Look for this cross-section in the list of those already used.
+		for (i = 0; i < n_used && !x_section_lists_eq(&used[i], xs, 1); i++)
+			/* skip */;
+		if (i == n_used)
+			// Didn't find this cross-section in table.  Add it.
+			used[n_used++] = *xs;
+	}
+	product_cost = n_used * params->ordering_fee;
+	connection_cost = bridge->n_joints * params->connection_cost;
+	
+	if (geometry == local_geometry)
+		clear_geometry(geometry);
+	if (params == local_params)
+		clear_params(params);
+
+	return 2 * (mtl_cost + connection_cost) + product_cost + bridge->scenario_descriptor.site_cost;
+}
+

data/ext/WPBDC/bridge_hash.c

@@ -0,0 +1,126 @@
+#include "stdafx.h"
+#include "internal.h"
+
+static INLINE int bit_width(unsigned int n)
+{
+	int w = 0;
+	while (n) {
+		n >>= 1;
+		w++;
+	}
+	return w;
+}
+
+// Hash function starts hash value with alternating 1's and 0's.
+// Xors in the significant bits (omitting leading zeros) of the 
+// given vector with each set of signifcant bits separated by a 1,
+// which is "or'ed" in.
+void hashify_vec(unsigned int  *v, unsigned v_len,
+				 unsigned int  *hash, unsigned h_len)
+{
+	unsigned iv, ip;
+
+	assert(v);
+	assert(hash);
+	assert(h_len >= 1);
+
+	for (ip = 0; ip < h_len; ip++)
+		hash[ip] = 0x55555555u;
+
+	ip = 0;
+	for (iv = 0; iv < v_len; iv++) {
+		unsigned int  val = (v[iv] << 1) | 1;
+		unsigned ipw = ip >> 5;
+		unsigned ipo = ip & 0x1f;
+		assert(ipw < h_len);
+		hash[ipw] ^= (val << ipo);
+		if (++ipw >= h_len)
+			ipw = 0;
+		hash[ipw] ^= (val >> (32 - ipo));
+		ip += bit_width(val);
+		if ((ip >> 5) >= h_len)
+			ip -= (h_len << 5);
+	}
+}
+
+char *hex_nibble(int n, char *p)
+{
+	p[0] = "0123456789abcdef"[n & 0xf];
+	p[1] = '\0';
+
+	return p;
+}
+
+char *hex_byte(int b, char *p)
+{
+	hex_nibble(b >> 4, &p[0]);
+	hex_nibble(b, &p[1]);
+
+	return p;
+}
+ 
+char *hex_str(char *s, unsigned n, char *p)
+{
+	unsigned i;
+
+	if (n == 0)
+		n = strlen(s);
+	for (i = 0; i < n; i++)
+		hex_byte(s[i], &p[2 * i]);
+
+	return p;
+}
+
+int hash_bridge(TBridge *bridge, char *hash)
+{
+	unsigned joint_index, member_index, hash_base;
+	TBridge cb[1];
+
+	unsigned v_size = 256;
+	unsigned p = 0;
+	unsigned int *v;
+	unsigned int h[HASH_SIZE / sizeof(unsigned int)];
+
+	New(190, v, v_size, unsigned int);
+
+#define Add(Val)	do {													\
+		if (p >= v_size) {													\
+			v_size *= 2;													\
+			Renew(v, v_size, unsigned int);								    \
+		}																	\
+		v[p++] = (Val);														\
+	} while (0)
+
+	init_bridge(cb);
+	canonicalize(cb, bridge);
+
+	// Canonicalization can fail if bridge has bad geometry.
+	if (cb->error != BridgeNoError)
+		return 1;
+
+	// Scenario
+	Add(cb->scenario_descriptor.index + 512);
+
+	// Start hashing joints after standard ones dictated by scenario.
+	hash_base = cb->load_scenario.n_prescribed_joints + 1;
+	for (joint_index = hash_base; joint_index <= bridge->n_joints; joint_index++) {
+		Add(cb->joints[joint_index].x);
+		Add(cb->joints[joint_index].y);
+	}
+	for (member_index = 1; member_index <= bridge->n_members; member_index++) {
+		Add(cb->members[member_index].start_joint);
+		Add(cb->members[member_index].end_joint);
+		Add(cb->members[member_index].x_section.material);
+		Add(cb->members[member_index].x_section.section);
+		Add(cb->members[member_index].x_section.size);
+	}
+
+	// Can't hashify directly into hash because it might not be aligned.
+	hashify_vec(v, p, h, HASH_SIZE / sizeof(unsigned int));
+	memcpy(hash, h, HASH_SIZE);
+
+	Safefree(v);
+	clear_bridge(cb);
+	return 0;
+}
+