WPBDC 2013.1.1

data/ext/WPBDC/loading.c

@@ -0,0 +1,128 @@
+#include "stdafx.h"
+#include "internal.h"
+
+// Loading ---------------------------------------------------------------------
+
+// Initialize a loading.
+void init_loading(TLoading *loading)
+{
+	memset(loading, 0, sizeof(*loading));
+}
+
+// Free storage for a loading and re-initialize it.
+void clear_loading(TLoading *loading)
+{
+	unsigned i;
+
+	for (i = 1; i <= loading->n_load_instances; i++)
+		Safefree(loading->load_instances[i].point_load);
+	Safefree(loading->load_instances);
+	init_loading(loading);
+}
+
+// Fill in a loading with information from a bridge, its geometry, and
+// analysis parameters.
+void setup_loading(TLoading *loading,	
+				   TBridge *bridge, 
+				   TGeometry *geometry,
+				   TParams *params)
+{
+	unsigned joint_index, member_index, load_instance_index;
+	TGeometry local_geometry[1];
+	TParams local_params[1];
+	TLoadCase *lc;
+	unsigned n_equations = 2 * bridge->n_joints;
+
+	clear_loading(loading);
+
+	// If caller didn't provide these things, we'll do it ourselves.
+	if (!geometry) {
+		geometry = local_geometry;
+		init_geometry(geometry);
+		setup_geometry(geometry, bridge);
+	}
+
+	if (!params) {
+		params = local_params;
+		init_params(params);
+		setup_params(params);
+	}
+
+	loading->n_load_instances = bridge->load_scenario.n_loaded_joints + 1;
+	Newz(240, loading->load_instances, loading->n_load_instances + 1, TLoadInstance);
+	for (load_instance_index = 1; load_instance_index <= loading->n_load_instances; load_instance_index++) {
+		Newz(250, loading->load_instances[load_instance_index].point_load, n_equations + 1, TFloat);
+	}
+
+	// Apply self-weight.
+
+	for (member_index = 1; member_index <= bridge->n_members; member_index++) {
+
+		TMember *member = &bridge->members[member_index];
+
+		TFloat dead_load = 	params->dead_load_factor *	
+		// half weight of member
+		params->shapes[member->x_section.section][member->x_section.size].area *
+		geometry->length[member_index] *
+		params->materials[member->x_section.material].density * 9.8066 / 2.0 / 1000.0;
+
+		unsigned dof1 = 2 * member->start_joint;
+		unsigned dof2 = 2 * member->end_joint;
+
+		for (load_instance_index = 1; load_instance_index <= loading->n_load_instances; load_instance_index++) {
+			TLoadInstance *load_instance = &loading->load_instances[load_instance_index];
+			load_instance->point_load[dof1] -= dead_load;
+			load_instance->point_load[dof2] -= dead_load;
+		}
+	}
+
+	// Get access to the right load case.
+
+	lc = &params->load_cases[bridge->load_scenario.load_case];
+
+	// Apply dead load.
+
+	for (joint_index = 1; joint_index <= bridge->load_scenario.n_loaded_joints; joint_index++) {
+		unsigned dof= 2 * joint_index;
+		for (load_instance_index = 1; load_instance_index <= loading->n_load_instances; load_instance_index++) {
+
+			TFloat load = lc->point_dead_load;
+
+			// Account for ends of deck.
+			if (joint_index == 1 || joint_index == bridge->load_scenario.n_loaded_joints)
+				load /= 2;
+			loading->load_instances[load_instance_index].point_load[dof] -= load;
+		}
+	}
+
+	// Apply live load.
+
+	for (load_instance_index = 2; load_instance_index <= loading->n_load_instances - 1; load_instance_index++) {
+		TLoadInstance *load_instance = &loading->load_instances[load_instance_index];
+		unsigned dof_front = 2 * load_instance_index;
+		unsigned dof_rear = dof_front - 2;
+		load_instance->point_load[dof_front] -= params->live_load_factor * lc->front_axle_load;
+		load_instance->point_load[dof_rear]  -= params->live_load_factor * lc->rear_axle_load;
+	}
+
+#ifdef TEST_PRINT
+	for (load_instance_index = 1; load_instance_index <= loading->n_load_instances; load_instance_index++) {
+		TLoadInstance *load_instance = &loading->load_instances[load_instance_index];
+		printf("\nPoint Loads Load Case %d\n", load_instance_index);
+		printf("Jnt #      X           Y\n");
+		printf("----- ----------- -----------\n");
+		for (joint_index = 1; joint_index <= bridge->n_joints; joint_index++) {
+			printf("%5d %11.5lf %11.5lf\n", 
+				joint_index,
+				load_instance->point_load[2 * joint_index - 1],
+				load_instance->point_load[2 * joint_index]);
+		}
+	}
+#endif;
+
+	if (geometry == local_geometry)
+		clear_geometry(geometry);
+	if (params == local_params)
+		clear_params(params);
+}
+

data/ext/WPBDC/params.c

@@ -0,0 +1,166 @@
+#include "stdafx.h"
+#include "internal.h"
+
+/*
+
+  Copied from internal.h...
+
+#define NLoadCases 4
+
+typedef load_case_t {
+	TFloat point_dead_load;					// Dead load due to roadway.
+	TFloat front_axle_load;					// Live load due to front axle.
+	TFloat rear_axle_load;					// Live load due to rear axle.
+} TLoadCase;
+
+// Parameters of analysis.
+typedef struct params_t {
+	TFloat dead_load_factor;				// Dead load safety factor.
+	TFloat live_load_factor;				// Live load safety factor.
+	TFloat compression_resistance_factor;	// Compression loading safety factor.
+	TFloat tension_resistance_factor;		// Tension loading safety factor.
+	TLoadCase load_cases[NLoadCases];		// Load cases.
+	TFloat connection_cost;					// Cost of connecting members at a joint.
+	TFloat ordering_fee;					// Fee per cross-section used.
+	TMaterial materials[NMaterials];		// Descriptions of available materials.
+	unsigned n_sizes[NSections];			// Number of sizes available by section.
+	TShape *shapes[NSections];				// Shape descriptions by section and size.
+} TParams;
+
+*/
+
+#define DEAD_LOAD_FACTOR	1.25
+
+// Constant part of the analysis parameters block.  Rest has to be calculated.
+// This is similar to the BD_VERSION==0x400, but the cost factors have changed.
+static TParams constant_params = INIT_CONSTANT_PARAMS;
+
+// Table mapping section to the number of available sizes of that section.
+static unsigned constant_n_sizes[NSections] = {
+	NBarSizes,
+	NTubeSizes,
+};
+
+unsigned n_sizes(TSection section)
+{
+	return (unsigned)section < NSections ? constant_n_sizes[section] : 0;
+}
+
+// Initialize a parameter block.
+void init_params(TParams *params)
+{
+	memset(params, 0, sizeof(*params));
+}
+
+// Free storage allocated to a parameter block and re-initialize it.
+void clear_params(TParams *params)
+{
+	unsigned section_index, size_index;
+
+	for (section_index = 0; section_index < NSections; section_index++) {
+		for (size_index = 0; size_index < params->n_sizes[section_index]; size_index++) 
+			Safefree(params->shapes[section_index][size_index].name);
+		Safefree(params->shapes[section_index]);
+	}
+	init_params(params);
+}
+
+// Square a float.
+static __inline TFloat sqr(TFloat x) 
+{
+	return x * x;
+}
+
+// Compute fourth power of a float.
+static __inline TFloat p4(TFloat x)
+{
+	return sqr(sqr(x));
+}
+
+// Fill in a parameter block.
+void setup_params (TParams *params)
+{
+	unsigned section_index, size_index;
+	char buf[256];
+	int width, tube_thickness;
+
+    /* From Steve, 15 Nov 2004. Last year these were computed. */
+    static int width_tbl[33] = {
+        30,35,40,45,50,55,60,65,70,75,80,				/* 0 to 10 */
+        90,100,110,120,130,140,150,160,170,180,190,200, /* 11 to 22 */
+        220,240,260,280,300,                            /* 23 to 27 */
+        320,340,360,400,500                             /* 28 to 32 */
+    };
+
+    assert(STATIC_ARRAY_SIZE(width_tbl) == NBarSizes && NBarSizes == NTubeSizes);
+
+	*params = constant_params;
+	memcpy(params->n_sizes, constant_n_sizes, sizeof(constant_n_sizes));
+	for (section_index = 0; section_index < NSections; section_index++) {
+
+		Newz(200, params->shapes[section_index], params->n_sizes[section_index], TShape);
+
+		for (size_index = 0; size_index < params->n_sizes[section_index]; size_index++) {
+
+			switch (section_index) {
+
+			case Bar:
+                width = width_tbl[size_index];
+				params->shapes[section_index][size_index].width = width;
+				params->shapes[section_index][size_index].area = sqr(width) * 1e-6;
+				params->shapes[section_index][size_index].moment = p4(width) / 12 * 1e-12;
+				sprintf(buf, "%dx%d", width, width);
+				NewStr(203, params->shapes[section_index][size_index].name, buf);
+				break;
+
+			case Tube:
+                width = width_tbl[size_index];
+				tube_thickness = width / 20;
+				if (tube_thickness < 2)
+					tube_thickness = 2;
+				params->shapes[section_index][size_index].width = width;
+				params->shapes[section_index][size_index].area = ( sqr(width) - sqr(width - 2 * tube_thickness) ) * 1e-6;
+				params->shapes[section_index][size_index].moment = ( p4(width) - p4(width -  2 * tube_thickness) ) / 12 * 1e-12;
+				sprintf(buf, "%dx%dx%d", width, width, tube_thickness);
+				NewStr(206, params->shapes[section_index][size_index].name, buf);
+				break;
+
+			default:
+				fprintf(stderr, "init_params: unhandled section\n");
+				exit(1);
+				break;
+			}
+		}
+	}
+}
+
+void print_load_case(FILE *f, unsigned index, TLoadCase *load_case)
+{
+	fprintf(f, "[%u] load case '%s':\n", index, load_case->name);
+	fprintf(f, " point_dead_load = %.4f\n", load_case->point_dead_load);
+	fprintf(f, " front_axle_load = %.4f\n", load_case->front_axle_load);
+	fprintf(f, " rear_axle_load  = %.4f\n", load_case->rear_axle_load);
+}
+
+void print_params(FILE *f, TParams *params) 
+{
+	unsigned material_index,
+		section_index,
+		size_index,
+		load_case_index;
+
+	fprintf(f, "parameters:\n");
+	fprintf(f, " dead_load_factor              = %.4f\n", params->dead_load_factor);
+	fprintf(f, " live_load_factor              = %.4f\n", params->live_load_factor);
+	fprintf(f, " compression_resistance_factor = %.4f\n", params->compression_resistance_factor);
+	fprintf(f, " tension_resistance_factor     = %.4f\n", params->tension_resistance_factor);
+	for (load_case_index = 0; load_case_index < NLoadCases; load_case_index++)
+		print_load_case(f, load_case_index, &params->load_cases[load_case_index]);
+	fprintf(f, " connection_cost               = %.4f\n", params->connection_cost);
+	fprintf(f, " ordering_fee                  = %.4f\n", params->ordering_fee);
+	for (material_index = 0; material_index < NMaterials; material_index++)
+		print_material(f, material_index, &params->materials[material_index]);
+	for (section_index = 0; section_index < NSections; section_index++)
+		for (size_index = 0; size_index < params->n_sizes[section_index]; size_index++)
+			print_shape(f, section_index, size_index, &params->shapes[section_index][size_index]);
+}

data/ext/WPBDC/proto.h

@@ -0,0 +1,98 @@
+/* analysis.c */
+void init_analysis(TAnalysis *anal);
+void clear_analysis(TAnalysis *anal);
+void setup_analysis(TAnalysis *anal, TBridge *bridge, TGeometry *geometry, TLoading *loading, TParams *params);
+void do_analyze(STRING *bridge_as_string, TAnalysis *analysis, TBridge *bridge, TGeometry *geometry, TLoading *loading, TParams *params, struct analysis_result_t *result);
+char *analysis_to_html(TAnalysis *analysis, TBridge *bridge, TGeometry *geometry, TLoading *loading, TParams *params, struct analysis_result_t *result);
+void print_analysis(FILE *f, TAnalysis *anal, TBridge *bridge, TGeometry *geometry, TLoading *loading, TParams *params);
+/* bridge.c */
+void init_bridge(TBridge *bridge);
+void clear_bridge(TBridge *bridge);
+TBool joint_lists_eq(TJoint *a, TJoint *b, unsigned n);
+TBool x_section_lists_eq(TXSection *a, TXSection *b, unsigned n);
+char *section_str(TSection section);
+TBool member_lists_eq(TMember *a, TMember *b, unsigned n);
+void copy_bridge(TBridge *dst, TBridge *src);
+TBool bridges_indentical(TBridge *a, TBridge *b);
+void canonicalize(TBridge *dst, TBridge *src);
+void print_material(FILE *f, unsigned index, TMaterial *material);
+void print_shape(FILE *f, unsigned section_index, unsigned size_index, TShape *shape);
+/* bridge_cost.c */
+int lookup_scenario_descriptor(TScenarioDescriptor *desc, char *id);
+TFloat bridge_cost(TBridge *bridge, TGeometry *geometry, TParams *params);
+int test_scenario_table(void);
+/* bridge_hash.c */
+void hashify_vec(unsigned *v, unsigned v_len, unsigned *hash, unsigned h_len);
+char *hex_nibble(int n, char *p);
+char *hex_byte(int b, char *p);
+char *hex_str(char *s, unsigned n, char *p);
+int hash_bridge(TBridge *bridge, char *hash);
+/* bridge_parser.c */
+char *get_line(char *buf, char **next);
+char *parse_string(char *buf, char *str);
+void basic_string(char *dst, char *src);
+char *parse_comma(char *buf);
+unsigned scan_unsigned(char *str, unsigned width, char **next);
+int scan_int(char *str, unsigned width, char **next);
+TTestStatus lookup_test_status_tag(const char *str);
+char *get_to_delim(char *str, char **next);
+void endecrypt_in_place(char *buf, int size);
+void parse_bridge(TBridge *bridge, STRING *str);
+void parse_unpacked_bridge_destructive(TBridge *bridge, char *str);
+void parse_packed_bridge_destructive(TBridge *bridge, char *str);
+char *unparse_bridge(TBridge *bridge);
+char *unparse_packed_bridge(TBridge *bridge);
+char *unparse_unpacked_bridge(TBridge *bridge);
+void pack_bridge(STRING *in_str, STRING *out_str, TBool decrypt_p, TBool encrypt_p);
+void unpack_bridge(STRING *in_str, STRING *out_str, TBool decrypt_p, TBool encrypt_p);
+/* bridge_random.c */
+void randomly_permute_unsigned(unsigned *v, unsigned n);
+void randomly_permute_members(TMember *v, unsigned n);
+void sample(unsigned *s, unsigned sn, unsigned m, unsigned n);
+void perturb(TBridge *dst, TBridge *src, unsigned seed, unsigned n_joints, unsigned n_members);
+int fix_failure(TBridge *dst, TBridge *src, TParams *params);
+int induce_failure(TBridge *dst, TBridge *src, unsigned seed);
+void vary(TBridge *dst, TBridge *src, unsigned seed);
+/* bridge_sketch.c */
+void do_sketch(TBridge *bridge, TAnalysis *analysis, int width, int height, COMPRESSED_IMAGE *compressed_image);
+/* geometry.c */
+void init_geometry(TGeometry *geometry);
+void clear_geometry(TGeometry *geometry);
+void setup_geometry(TGeometry *geometry, TBridge *bridge);
+/* judge.c */
+void endecrypt(STRING *bridge_as_string);
+void analyze(STRING *bridge_as_string, struct analysis_result_t *result);
+int compare(STRING *bridge_as_string_a, STRING *bridge_as_string_b);
+char *variant(STRING *bridge_as_string, int seed);
+char *failed_variant(STRING *bridge_as_string, int seed);
+char *perturbation(STRING *bridge_as_string, int seed, int n_joints, int n_members);
+void sketch(STRING *bridge_as_string, int width, int height, COMPRESSED_IMAGE *compressed_image, struct analysis_result_t *result);
+char *analysis_table(STRING *bridge_as_string);
+/* loading.c */
+void init_loading(TLoading *loading);
+void clear_loading(TLoading *loading);
+void setup_loading(TLoading *loading, TBridge *bridge, TGeometry *geometry, TParams *params);
+/* params.c */
+unsigned n_sizes(TSection section);
+void init_params(TParams *params);
+void clear_params(TParams *params);
+void setup_params(TParams *params);
+void print_load_case(FILE *f, unsigned index, TLoadCase *load_case);
+void print_params(FILE *f, TParams *params);
+/* scenario.c */
+void init_load_scenario(TLoadScenario *load_scenario);
+void clear_load_scenario(TLoadScenario *load_scenario);
+void setup_load_scenario(TLoadScenario *load_scenario, unsigned scenario_index);
+void copy_load_scenario(TLoadScenario *dst, TLoadScenario *src);
+/* sketch.c */
+void init_image(IMAGE *image);
+void clear_image(IMAGE *image);
+void setup_image(IMAGE *image, UNSIGNED width, UNSIGNED height, RGB_TRIPLE *color);
+void set_viewport(IMAGE *image, UNSIGNED x_left, UNSIGNED x_right, UNSIGNED y_bottom, UNSIGNED y_top);
+void draw_line_raw(IMAGE *image, UNSIGNED x1, UNSIGNED y1, UNSIGNED x2, UNSIGNED y2, RGB_TRIPLE *color);
+void draw_rect_raw(IMAGE *image, UNSIGNED x1, UNSIGNED y1, UNSIGNED x2, UNSIGNED y2, RGB_TRIPLE *color);
+void clip_segment(FLOAT *x1p, FLOAT *y1p, FLOAT *x2p, FLOAT *y2p, FLOAT x_left, FLOAT x_right, FLOAT y_bottom, FLOAT y_top, int *segment_survives_p);
+void draw_line(IMAGE *image, FLOAT x1, FLOAT y1, FLOAT x2, FLOAT y2, RGB_TRIPLE *color);
+void init_compressed_image(COMPRESSED_IMAGE *compressed_image);
+void clear_compressed_image(COMPRESSED_IMAGE *compressed_image);
+int compress_image(IMAGE *image, COMPRESSED_IMAGE *compressed_image);

data/ext/WPBDC/rc4.c

@@ -0,0 +1,62 @@
+#include "rc4.h"
+
+void init_rc4(TRC4State *state)
+{
+	int x;
+
+	state->x = state->y = 0;
+
+    // Set up permutation.
+    for (x = 0; x < 256; x++)
+        state->buf[x] = x;
+}
+
+void clear_rc4(TRC4State *state)
+{
+	init_rc4(state);
+}
+
+void setup_rc4(TRC4State *state, char *key, int keylen)
+{
+    unsigned tmp;
+    int x, y;
+
+	  // use only first 256 characters of key 
+    if (keylen > 256) 
+		    keylen = 256;
+
+    for (x = y = 0; x < 256; x++) {
+        y = (y + state->buf[x] + key[x % keylen]) & 255;
+        tmp = state->buf[x]; 
+		    state->buf[x] = state->buf[y]; 
+		    state->buf[y] = tmp;
+    }
+    state->x = x;
+    state->y = y;
+
+	// DEBUG: Temporary while Steve fixes bug.
+	// Removed 1 December 2003
+	// state->y = 0;
+}
+
+unsigned endecrypt_rc4(unsigned char *buf, unsigned len, TRC4State *state)
+{
+   int x, y; 
+   unsigned char *s, tmp;
+   unsigned n;
+
+   x = state->x;
+   y = state->y;
+   s = state->buf;
+   n = len;
+   while (n--) {
+      x = (x + 1) & 255;
+      y = (y + s[x]) & 255;
+      tmp = s[x]; s[x] = s[y]; s[y] = tmp;
+      tmp = (s[x] + s[y]) & 255;
+      *buf++ ^= s[tmp];
+   }
+   state->x = x;
+   state->y = y;
+   return len;
+}

data/ext/WPBDC/rc4.h

@@ -0,0 +1,19 @@
+#ifndef _RC4_H
+#define _RC4_H
+
+/*
+ * rc4.h -- Declarations for a simple rc4 encryption/decryption implementation.
+ * The code was inspired by libtomcrypt.  See www.libtomcrypt.org.
+ */
+typedef struct TRC4State_t {
+	int x, y;
+	unsigned char buf[256];
+} TRC4State;
+
+/* rc4.c */
+void init_rc4(TRC4State *state);
+void clear_rc4(TRC4State *state);
+void setup_rc4(TRC4State *state, char *key, int keylen);
+unsigned endecrypt_rc4(unsigned char *buf, unsigned len, TRC4State *state);
+
+#endif

data/ext/WPBDC/rc4_key.c

@@ -0,0 +1,2 @@
+// Password provided by Steve 1 December 2003 (phone con)
+char RC4_Key[] = "QuenchHollow";

data/ext/WPBDC/rubydefs.h

@@ -0,0 +1,75 @@
+#ifndef _RUBYDEFS_H
+#define _RUBYDEFS_H
+
+#if !defined(STAND_ALONE)
+
+#include <ruby.h>
+
+// For safety, generate a compile error if we try to call
+// one of the underlying C allocators.
+#undef	malloc
+#define	malloc	@oops@
+#undef	calloc
+#define	calloc	@oops@
+#undef	realloc
+#define	realloc	@oops@
+#undef	strdup
+#define	strdup	@oops@
+#undef	free
+#define	free	@oops@
+
+#define New(x,v,n,t)									\
+	do {												\
+	    v = ALLOC_N(t, n);                              \
+	} while (0)
+
+#define Newz(x,v,n,t)									\
+	do {												\
+	    v = ALLOC_N(t, n);                              \
+        MEMZERO(v, t, n);                               \
+	} while (0)
+
+#define Renew(v,n,t)									\
+	do {												\
+	    v = REALLOC_N(v, t, n);                         \
+	} while (0)
+
+#define Safefree(p)										\
+	do {												\
+		xfree(p);										\
+	} while (0)
+
+#else
+
+#define New(x,v,n,t)									\
+	do {												\
+		if ( !(v = (t*)malloc((n)*sizeof(t))) ) {		\
+			fprintf(stderr, "out of memory (%d)\n", x);	\
+			exit(1);									\
+		}												\
+	} while (0)
+
+#define Newz(x,v,n,t)									\
+	do {												\
+		if ( !(v = (t*)calloc(n, sizeof(t))) ) {		\
+			fprintf(stderr, "out of memory (%d)\n", x);	\
+			exit(1);									\
+		}												\
+	} while (0)
+
+#define Renew(v,n,t)									\
+	do {												\
+		if ( !(v = (t*)realloc(v, (n)*sizeof(t))) ) {	\
+			fprintf(stderr, "out of memory in Renew\n");\
+			exit(1);									\
+		}												\
+	} while (0)
+
+#define Safefree(p)										\
+	do {												\
+		free(p);										\
+	} while (0)
+
+#endif
+
+#endif