There are various improvements that could be made to optimise this, but it’s difficult to know what can be changed without known what it’s for or how it’s meant to be used. I’m not even sure some of the changes I made to this version are suitable for what you need. But I’m sure you can use this to get you started anyway.

function Detonation(name, lat, lon, yieldValue) {
    var self = this; // Keep a reference to this object availale
    var gz = new GLatLng(lat, lon);

    // Use _yeild because yeild is a reserved keyword in JavaScript 1.7
    var scale, _yield;
    
    // Use a setter function to recalculate the scale when yield is set
    this.__defineSetter__("yield", function(value) {
	    _yield = value;
        scale = Math.pow(_yield, 1/3);
	} );

    this.__defineGetter__("yield", function() {
        return _yield;
    } );
    this.yield = yieldValue;

    this.name = name;
    
    // Use getters here so that these values can't be changed externally
    // If you need them to be settable externally, use __defineSetter__ to
    // define setter functions for lat and lon that recalculate gz when set
    this.__defineGetter__("lat", function() { return lat; };
    this.__defineGetter__("lon", function() { return lon; };
    this.__defineGetter__("gz", function() { return gz; };
    
    // Use getters for each of these so the value is recalculated
    // based on the current scale value
    this.overpressure = {
        get p30() { return 0.108 * scale; },
        get p15() { return 0.153 * scale; },
        get p10() { return 0.185 * scale; },
        get  p5() { return 0.281 * scale; },
        get  p1() { return 0.725 * scale; }
    };

    // Similarly, use getters for these properties so their values are calculated
    // based on the current values when needed
    this.psi30 = {
        get radius() { return self.overpressure.p30 },
        overlay: {
            get points() { return makePoints(self.gz, self.overpressure.p30) }
        }
    };
    this.psi15 = {
        get radius() { return self.overpressure.p15 },
        overlay: {
            get points() { return makePoints(self.gz, self.overpressure.p15) }
        }
    };
    this.therm20 = {
        get radius() { thermDist(20, self.yield , 0.33, conditions.visibility) },
        overlay: {
            get points() { return makePoints(self.gz, self.psi15.radius * scale) }
        }
    };
    // ...and so on...
}

Detonation1 makes small changes internal to Detonation, but the code which uses it (det.whatever) should remain unchanged.

However, it only addresses your first of your requests:

function Detonation1(name,lat,lon,yld)
{
  var pow = (1/3), scale = Math.pow(yld,pow);

  // arbitrary values so I could test
  var conditions = { visibility: 1.0 };
  function makePoints (a,b)    { return [a,b]; }
  function thermDist  (a,b,c,d){ return (a*b*c*d); }
  function GLatLng    (lat,lon){ return [lat,lon]; }

  this.name = name;
  this.lon  = lon;
  this.lat  = lat;
  this.yld  = yld;
  this.gz   = new GLatLng(lat,lon);

  this.overpressure = {
    p30 : 0.108 * scale,
    p15 : 0.153 * scale,
    p10 : 0.185 * scale,
    p5 : 0.281 * scale,
    p1 : 0.725 * scale
  };
  this.psi30 = {
    radius: this.overpressure.p30,
    overlay : {
      points: makePoints(this.gz, pow)
    }
  };
  this.psi15 = {
    radius: this.overpressure.p15,
    overlay : {
      points: makePoints(this.gz, pow)
    }
  };
  // split this up so you don't do double thermDist calcs
  this.therm20 = {
    radius: thermDist(20,this.yld,pow,conditions.visibility)
  };
  this.therm20.overlay = {
      points: makePoints(this.gz, this.therm20.radius)
  };
  // ...and so on...
}

Detonation2 causes somes changes externally (ie, det.yield = 20 becomes det.yield(20) and similar)

However, you do get 1) automatic recalculation and 2) only calculated when needed.

function Detonation2(name,lat,lon,yld)
{                  // D (this) is what gets returned as your instance
  var D   = this,  // D.some_name functions/properties available to instance
      pow = (1/3), // just a guess. saw 1/3 and 0.33 in a few places
      __s = {};   // data structure for "private" state info

  // arbitrary values so I could test
  var conditions = { visibility: 1.0 };
  function makePoints (a,b)    { return [a,b]; }
  function thermDist  (a,b,c,d){ return (a*b*c*d); }
  function GLatLng    (lat,lon){ return [lat,lon]; }

  // functions set values if passed arguments, else return current value
  // det.yield = 20 becomes det.yld(20)
  // and det.name = 'boom' becomes det.name('boom')
  D.name  = function(n){ return __get_set('name', n); };
  D.lat   = function(l){ return __get_set('lat', l); };
  D.lon   = function(l){ return __get_set('lon', l); };
  D.yld   = function(y){ return __get_set('yld', y); };
  // D.gz = function(){ return __get_set(GLatLng(D.lat, D.lon)); }; // once
  D.gz    = function(){ return new GLatLng(D.lat, D.lon); };        // always new
  D.scale = function(){ return Math.pow(D.yld(), pow); };

  // base getter/setter function for D.name() and other convenience functions
  function __get_set(key,val){
    if (val){ __s[key] = val; } // set to val, if we get one
    return __s[key];            // return current (old or new) value of key
  };

  // set values based on constructor arguments
  D.name(name);
  D.lat(lat);
  D.lon(lon);
  D.yld(yld);

  D.overpressure = {
    p30: function(){ return 0.108 * D.scale(); },
    p15: function(){ return 0.153 * D.scale(); },
    p10: function(){ return 0.185 * D.scale(); },
    p5:  function(){ return 0.281 * D.scale(); },
    p1:  function(){ return 0.725 * D.scale(); }
  };

  D.psi30 = {
    radius: function(){ return D.overpressure.p30(); },
    overlay: {
      points: function(){
	return makePoints(D.gz(), D.overpressure.p30());
      }
    }
  };

  D.psi15 = {
    radius: function(){ return D.overpressure.p15(); },
    overlay: {
      points: function(){
	return makePoints(D.gz(), D.overpressure.p15());
      }
    }
  };

  // split D.therm20 assignment so you don't run thermDist() twice
  D.therm20 = {
    radius: function(){
      return thermDist(20, D.yld(), pow, conditions.visibility);
    }
  };

  D.therm20.overlay = {
    points: function(){
      return makePoints(D.gz(), D.therm20.radius()); // thermDist() results
    }
  };

  // ...and so on...

  return D; // D.properties are available to instance (result of new Detonation)
}

You said you wanted something to poke at, so I went a bit heavy on the comments.

Just reading the example from Adam van den Hoven and it’s along the lines of what I was going to suggest. Even after my refactoring, it’s clear there are still patterns in the properties and function names (and their calculations) that could surely be reduced to a more abstract or basic formula.

Anyway, thanks for the mental exercise and, of course, your CSS and standards work.

P.S. “pre” tag doesn’t work. Sorry, but I just can’t go back and replace spaces w/ nbsb;

(Also, I think pre is allowed in comments even if it isn’t listed as accepted. Someone try it and we’ll see. If not, sorry! I’ll get it on the list.)

window.Detination = (function(){
  function makeOverPressure(scale){
    var OP_MULT = {
      30 : 0.108,
      15 : 0.153,
      10 : 0.185,
      5 : 0.281,
      1 : 0.725,
    }, res = {};
    for( mult in OP_MULT ){
      res[mult] = OP_MULT[mult] * scale;
    }
    return res;
  }
  function makeThermalDistances( yield, visibility ){
    var TD_MULT = {
      20 : 0.33
    }, res = {};
    for( mult in TD_MULT ){
      res[mult] = thermDist( mult, yield, TD_MULT[mult], visibility);
    }
    return res;
  }
  function makeOverlays(distance, center) {
    var res = {};
    for( dist in distance ){
      res[dist] = {
        radius: distance[dist],
        overlay{
          points: makePoints(center, distance[dist])
        }
      }
    }
    return res;
  }
  return function (name,lat,lon,yield){
    var scale = Math.pow(yield,1/3),
    gz = new GLatLng(lat,lon),
    op = makeOverPressure(scale),
    td = makeThermalDistances( yield, conditions.visibility);
    return {
      psi: makeDistances( op ),
      thermal: makeDistances( td )
    }
  }
}){};

Gaak! nbsp to get the indenting.

First of all, Detination uses a variation on Crockfords power constructor so don’t call it with new (but it should work regardless). Second the object it creates has two members, psi and therm. These each have a number of numerically identified members each of which contain the radius and points. You would do the following:

foo = Detenation( 'example', 50, 120, 200 );
foo.psi[10].radius;
foo.psi[10].overlay.points;
foo.therm[20].overlay.points;

I’ll leave it up to the reader to add the other useful bits in (like the name, yield, etc).

This has a number of advantages. First of all the global scope is kept pristine. Second, those things that are fixed (the different PSI levels, for example) and the functions that use them are only created once. Third its easy to add levels, simply add members to the OP_MULT and TD_MULT constants.

But there is a simple solution: the value of D that satisfies the equation. What can be simpler than that?

Maybe a few comments at this point will make such problems easier in the future.

There is a simple numerical solution but no ALGEBRAIC solution. And your brute-force method is exactly how such equations are solved, that is to say, by numerical approximation. Now there are some mathematical tricks to improve the efficiency of arriving at a solution. Two simple methods come to mind.

1. g(D) = Q-f(D). At what value of D does g(D) = 0? Trial and error. (Extra points if you can efficiently estimate the next guess. The pros use the slope g’(D) to improve their aim. And if you can’t calculate the slope algebraically, you can estimate it numerically.)

2. D approximately = f(D). At what point does D=f(D)? This is a helpful trick that you can use sometimes. If you know the approximate range of values of the various parameters, you may be able to rewrite the equation in a way such that f(D) does not depend much on D. Then you can iterate and get the value in a hurry.

In your previous example, if D/V << 1 and both are positive, then as a first approximation maybe you can ignore the exponential. Then D^2=3.07FY(1+1.4ED/V)/Q, where E is that nasty exponential. You can solve that for D algebraically to get your approximation. Make a first guess, find the value of E, plug all the numbers into the equation to get your next guess. Plug that value back into E to get the next guess. Repeat until satisfied. If D/V is not sufficiently small, it might not work, as you will find out very quickly.

In both cases, you have to watch out for the special cases Q=0 and V=0. (The function is undefined at those values!) If you are iterating and encounter those values (or cross those values), then obviously there is trouble.

function Detonation(name, lat, lon, yield) {
____this.name = name;
____this.lat = lat;
____this.lon = lon;
____this.gz = new GLatLng(lat, lon);
____this.yield = yield;
____recalculate(); // cheaper than doing setThis(); setThat(); all of which will call recalculate()
}
Detonation.prototype.setYield = function (yield) {
____this.yield = yield;
____recalculate();
};
Detonation.prototype.recalculate = function () {
____function makeDestruction() {
________var result = {};
________for (var i = 0; i < arguments.length; i++) {
____________var radius = arguments[i].factor * scale;
____________result[arguments[i].psi] = {
________________radius: radius,
________________overlay: { points: makePoints(this.gz, radius) }
____________};
________}
________return result;
____}
____function makeTemperature() {
________var result = {};
________for (var i = 0; i < arguments.length; i++) {
____________var radius = thermDist(arguments[i].celsius, this.yield, arguments[i].factor, conditions.visibility);
____________result[arguments[i].celsius] = {
________________radius: radius,
________________overlay: { points: makePoints(this.gz, radius) }
____________}
________}
________return result;
____}
____var scale = Math.pow(yield, 1/3);
____this.destructionAtPsi = makeDestruction.call(this, // need ".call(this," to preserve "this" in inner function
________{psi: 30, factor: 0.108},
________{psi: 15, factor: 0.153},
________{psi: 10, factor: 0.185},
________{psi: 5, factor: 0.281},
________{psi: 1, factor: 0.725}
____);
____this.temperature = makeTemperature.call(this,
________{celsius: 20, factor: 0.33},
________...
____);
};

Can we please get a markup engine that DOESN’T SCREW UP CODE IN CODE TAGS AAAAAAAAAAAARGH.

Sorry, just had to vent.

Anyway, the idea here is you use inner functions to calculate the main bits. When you want to access stuff, it’s like:

var det = new Detonation("blah", 0, 0, 42);
var radius = det.destructionAtPsi[30].radius;

// iterate through overpressure values
for (var overpressure in det.destructionAtPsi) {
    var overlay = det.destructionAtPsi[overpressure].overlay;
}

This way you only define your PSI values and other factors once.

Anyway, the code is:

function Detonation(name, lat, lon, yield) {
    this.name = name;
    this.lat = lat;
    this.lon = lon;
    this.gz = new GLatLng(lat, lon);
    this.yield = yield;
    recalculate();  // cheaper than doing setThis(); setThat(); all of which will call recalculate()
}

Detonation.prototype.setYield = function (yield) {
    this.yield = yield;
    recalculate();
};

Detonation.prototype.recalculate = function () {

    function makeDestruction() {
        var result = {};
        for (var i = 0; i < arguments.length; i++) {
            var radius = arguments[i].factor * scale;
            result[arguments[i].psi] = {
                radius: radius,
                overlay: { points: makePoints(this.gz, radius) }
            };
        }
        return result;
    }

    function makeTemperature() {
        var result = {};
        for (var i = 0; i < arguments.length; i++) {
            var radius = thermDist(arguments[i].celsius, this.yield, arguments[i].factor, conditions.visibility);
            result[arguments[i].celsius] = {
                radius: radius,
                overlay: { points: makePoints(this.gz, radius) }
            }
        }
        return result;
    }

    var scale = Math.pow(yield, 1/3);
    this.destructionAtPsi = makeDestruction.call(this,  // need ".call(this," to preserve "this" in inner function
        {psi: 30, factor: 0.108},
        {psi: 15, factor: 0.153},
        {psi: 10, factor: 0.185},
        {psi: 5, factor: 0.281},
        {psi: 1, factor: 0.725}
    );
    this.temperature = makeTemperature.call(this,
        {celsius: 20, factor: 0.33},
        ...
    );
};

function Detonation(name, lat, lon, yield) {
	var gz = new GLatLng(lat, lon);
	this.name = name;
	this.lon = lon;
	this.lat = lat;
	this.gz = gz;
	this.setYield(yield);
}

Detonation.prototype = {
	pressures: {
		p30: 0.108,
		p15: 0.153,
		p10: 0.185,
		p5: 0.281,
		p1: 0.725
	},
	setYield: function(yld) {
		this.yield = yld;
		this.scale = Math.pow(yld, 1 / 3);
	},
	overpressure: function(psi) {
		return this.pressures[psi] * this.scale;
	},
	getPressure: function(pres) {
		var p = this.overpressure(pres);
		return {
			radius: p,
			overlay: {
				points: makePoints(this.gz, p)
			}
		}
	},
	psi30: function() {
		return this.getPressure('p30');
	},
	psi15: function() {
		return this.getPressure('p15');
	},
	therm20: function() {
		return {
			radius: thermDist(20, this.yield, 0.33, conditions.visibility),
			overlay: {
				points: makePoints(this.gz, thermDist(20, this.yield, 0.33, conditions.visibility))
			}
		}
	}
}

Sorry if the formatting didn’t come through, I tried a few tags and combinations and couldn’t get it to look right in the preview.

function Detonation(name,lat,lon,yield) {

	this.name = name;
	this.lon = lon;
	this.lat = lat;
	this.yield = yield;

	this.getScale = function() {
		return Math.pow(this.yield, 1/3);
	};

	this.getGZ = function() {
		return new GLatLng(this.lat, this.lon);
	};

	this.overpressure = {
		p30 : function() {
			return 0.108 * this.getScale();
		},
		p15 : function() {
			return 0.153 * this.getScale();
		},
		p10 : function() {
			return 0.185 * this.getScale();
		},
		p5 : function() {
			return 0.281 * this.getScale();
		},
		p1 : function() {
			return 0.725 * this.getScale();
		}
	};

	this.psi30 = {
		radius: function() {
			return this.overpressure.p30()
		},
		overlay : {
			points: function() {
				return makePoints(this.getGZ(), this.overpressure.p30());
			}
		}
	};

	this.psi15 = {
		radius: function() {
			return this.overpressure.p15()
		},
		overlay : {
			points: function() {
				return makePoints(this.getGZ(), this.overpressure.p15());
			}
		}
	};

	this.therm20 = {
		radius: function() {
			return thermDist(20, this.yield, 0.33, conditions.visibility),
		},
		overlay : {
			points: function() {
				return makePoints(
					this.gz,
					thermDist(20, this.yield, 0.33, conditions.visibility)
				)
			}
		};
		// ...and so on...
	}

This also takes care of issue #1 in that you set your radii calculations once and refer to them as needed.

I assume this is exactly the kind of comment Eric loves to hear (no offense Bruce i appreciate your comment nonetheless). I am in the same shoes as Eric and appreciate Eric’s calls for help very much. So much to learn here if you are able to understand the comments. Great!

Or I’d hit it with a hammer and curse.

1) If you’re essentially calculating the radius measurements when you’re creating the this.overpressure object, you should be able to refer specifically to the “this.overpressure.p30″. So in this.psi30, you can simply write “radius: this.overpressure.p30″. You can do the same 2 lines down, specifying “points: makePoints(this.gz, this.overpressure.p30)”. As you say, if you’ve referred to it once, you don’t need to recalculate.

2) For this, you can’t really restructure your existing code to do it, you’ll need to change the structure of the Detonation obj. Here’s why…. As of the moment, when you create your object, you’re doing all of these calculations and wiring the results of the calculations into your Detonation object. To dynamically recalculate (like if you were to set a new yield), you’d have to create a new function that does all of the (needed) recalculations again. At this point, you’d then want to rewrite your code so when you create a new object, you also call this new function (so you don’t have 2 pieces of code that do the same thing, in multiple places.. it’s easier to maintain, etc.).

However, a better solution (though you may not be able to… I’m only looking at an abbreviated version), would be to simply store the 4 or so parameters you pass to the Detonation object (name, lat, lon, yield). You then write functions that automatically create these values for you only when you ask for them. That way, you can set a new yield, and not waste any time recalculating then… you could wait to recalculate the values only when you need to.

The ideal solution is probably somewhere inbetween…. where you store the 4 parameters, as well creating a function to re-calculate the radius measurements each time… since you use those so often, it’d be more efficient (as you said in #1) to calculate them just once.

I know you said you’d like to look at code, and this is just a high-level overview, but let us know what kinda changes you can make, and we can try to get to code.