Go buy another set, select matched globe, return the set.
Go buy another set, select matched globe, return the set.
This ended up looking best (there is no perfection with the mixed weights)...
D B F A C E
As in...
...Jim Thompson
-- | James E.Thompson | mens | | Analog Innovations | et |
Exploiting symmetry (iff I have understood your notation) I'd expect this to be closer:
B/C A A
D E F
The frame may have inherent balance flaws too.
It isn't possible to predict which of B/C or in which oerientation will give the best result. You didn't specify how the thing hangs unloaded.
-- Regards, Martin Brown
order some better attachment method.
else when a globe fails you'll have the same fun all over again.
-- For a good time: install ntp --- news://freenews.netfront.net/ - complaints: news@netfront.net ---
Globe =/= Bulb ...Jim Thompson
-- | James E.Thompson | mens | | Analog Innovations | et |
"Jim Thompson" schreef in bericht news: snipped-for-privacy@4ax.com...
Real solder, or that lead free fairy crap?
-- Anyone wanting to run for any political office in the US should have to have a DD214, and a honorable discharge.
I have some real solder, Kester "44" 63% SN .040 Dia. #58 Core,
1 Lb. Boxes if you want to buy it.
Thanks, but I still have a few rolls of 63/37 Ersin Multicore in several sizes. At my age, t should last me the rest of my life. I probably have 20 pounds of various alloys. I'm sure others on the group could use some. :)
-- Anyone wanting to run for any political office in the US should have to have a DD214, and a honorable discharge.
No takers? (sigh)
Hacked the following together this morning while "on hold" with the Dell tech support guy. It's not pretty but it *should* work. It claims: "One solution: [ 1.400] 26.200 31.600 28.400 32.800 26.000 35.600 " Of course, flip the chandelier over and you've got *another*! :>
[I'd be curious as to whether this *does* reflect reality! :> ]Code follows. Neglecting initialization and syntactic cruft, the algorithm -- "solve()" -- is just a couple dozen lines of code. Evaluates twice as many permutations as necessary (I got lazy) but only 120 of the 720 you'd otherwise expect to encounter.
[Note, also handles "any" number of Globes]-----8Infinity, optimum);
print("One solution: "); show(best, order); }
# Do the actual work! Echoes of bygone LISPs... :> # recursion depth limited by len weights; solve( weights: list of Weight, # weights to be processed points: list of Point, # points onto which they should map center: Point, # weighted center of mass for previously processed points order: list of Weight, # ordered list of previously processed weights best: real, # best score thus far optimum: list of Weight # optimum order for best score ):( real, # new score list of Weight # new optimum order ) { if (weights == nil) { score := center.hypot(); if ( score < best ) { best = score; optimum = order; }
return (best, optimum); }
processed: list of Weight = nil; # weights examined thus far
Apoint := hd points; points = tl points;
while (weights != nil) { Aweight := hd weights; weights = tl weights;
newcenter := center.offset(Apoint.scale(Aweight)); neworder := Aweight :: order;
# assemble list of weights exclusive of Aweight copy := weights; check := processed; while (copy != nil) { # brain-damaged list operators! :< check = hd copy :: check; copy = tl copy; }
(best, optimum) = solve(check, points, newcenter, neworder, best, optimum);
processed = Aweight :: processed; }
return (best, optimum); }
# utility subroutine to show result snapshot show(score: real, order: list of Weight) { # XXX score should be adjusted to reflect total Globe weight print("[%6.3f] ", score); while (order != nil) { print("%6.3f ", hd order); order = tl order; } print("\n"); }
Robert Baer suggested...
This ended up looking best (there is no perfection with the mixed weights)...
D B F A C E
As in...
...Jim Thompson
-- | James E.Thompson | mens | | Analog Innovations | et |
I think my solution is E B C A D F (score 1.400) Robert's solution is B D A C E F (score 5.196) Your solution is C E A B D F (score 2.821)
[the "score" is a measure of how far off center the center of mass lies -- of course, it assumes masses are points on a plane, the chandelier itself is statically balanced and has no mass, etc.]
I'm sure your technique is the way to go, but I'm not going to touch it... SWMBO is happy, thus I'm happy ;-) ...Jim Thompson
-- | James E.Thompson | mens | | Analog Innovations | et |
Should she be unhappy with the outcome, you can point out that the *cause* of the problem is the glass globes! And, that *removing* them -- leaving bare bulbs -- would probably give a more level result!
*Or*, suggest that a chandelier of *twice* the diameter won't appear to list as much!Wanna bet she says "Just leave it the way it is"? :>
No takers? (sigh)
Hacked the following together this morning while "on hold" with the Dell tech support guy. It's not pretty but it *should* work. It claims: "One solution: [ 1.400] 26.200 31.600 28.400 32.800 26.000 35.600 " Of course, flip the chandelier over and you've got *another*! :>
[I'd be curious as to whether this *does* reflect reality! :> ]Code follows. Neglecting initialization and syntactic cruft, the algorithm -- "solve()" -- is just a couple dozen lines of code. Evaluates twice as many permutations as necessary (I got lazy) but only 120 of the 720 you'd otherwise expect to encounter.
[Note, also handles "any" number of Globes]-----8Infinity, optimum);
print("One solution: "); show(best, order); }
# Do the actual work! Echoes of bygone LISPs... :> # recursion depth limited by len weights; solve( weights: list of Weight, # weights to be processed points: list of Point, # points onto which they should map center: Point, # weighted center of mass for previously processed points order: list of Weight, # ordered list of previously processed weights best: real, # best score thus far optimum: list of Weight # optimum order for best score ):( real, # new score list of Weight # new optimum order ) { if (weights == nil) { score := center.hypot(); if ( score < best ) { best = score; optimum = order; }
return (best, optimum); }
processed: list of Weight = nil; # weights examined thus far
Apoint := hd points; points = tl points;
while (weights != nil) { Aweight := hd weights; weights = tl weights;
newcenter := center.offset(Apoint.scale(Aweight)); neworder := Aweight :: order;
# assemble list of weights exclusive of Aweight copy := weights; check := processed; while (copy != nil) { # brain-damaged list operators! :< check = hd copy :: check; copy = tl copy; }
(best, optimum) = solve(check, points, newcenter, neworder, best, optimum);
processed = Aweight :: processed; }
return (best, optimum); }
# utility subroutine to show result snapshot show(score: real, order: list of Weight) { # XXX score should be adjusted to reflect total Globe weight print("[%6.3f] ", score); while (order != nil) { print("%6.3f ", hd order); order = tl order; } print("\n"); }
Don, Nice doodling while bored! For what environment is this written? Scott
No takers? (sigh)
Hacked the following together this morning while "on hold" with the Dell tech support guy. It's not pretty but it *should* work. It claims: "One solution: [ 1.400] 26.200 31.600 28.400 32.800 26.000 35.600 " Of course, flip the chandelier over and you've got *another*! :>
[I'd be curious as to whether this *does* reflect reality! :> ]Code follows. Neglecting initialization and syntactic cruft, the algorithm -- "solve()" -- is just a couple dozen lines of code. Evaluates twice as many permutations as necessary (I got lazy) but only 120 of the 720 you'd otherwise expect to encounter.
[Note, also handles "any" number of Globes]-----8Infinity, optimum);
print("One solution: "); show(best, order); }
# Do the actual work! Echoes of bygone LISPs... :> # recursion depth limited by len weights; solve( weights: list of Weight, # weights to be processed points: list of Point, # points onto which they should map center: Point, # weighted center of mass for previously processed points order: list of Weight, # ordered list of previously processed weights best: real, # best score thus far optimum: list of Weight # optimum order for best score ):( real, # new score list of Weight # new optimum order ) { if (weights == nil) { score := center.hypot(); if ( score < best ) { best = score; optimum = order; }
return (best, optimum); }
processed: list of Weight = nil; # weights examined thus far
Apoint := hd points; points = tl points;
while (weights != nil) { Aweight := hd weights; weights = tl weights;
newcenter := center.offset(Apoint.scale(Aweight)); neworder := Aweight :: order;
# assemble list of weights exclusive of Aweight copy := weights; check := processed; while (copy != nil) { # brain-damaged list operators! :< check = hd copy :: check; copy = tl copy; }
(best, optimum) = solve(check, points, newcenter, neworder, best, optimum);
processed = Aweight :: processed; }
return (best, optimum); }
# utility subroutine to show result snapshot show(score: real, order: list of Weight) { # XXX score should be adjusted to reflect total Globe weight print("[%6.3f] ", score); while (order != nil) { print("%6.3f ", hd order); order = tl order; } print("\n"); }
Don, Nice doodling while bored! For what environment is this written? Scott
I can't understand why it takes 33 minutes for someone who already *has* all of my contact information, works for a "hi tech" company *IN* a "customer support role" (third party, no less -- i.e., low cost being a prime concern!) to click a few boxes to arrange for a CD to be shipped to me...
(sigh)
Code is written in Limbo. Runs under Inferno (OS). Free download at
I'm adopting it as a "scripting language" for some projects so like to throw "quickie" problems at it to see how effectively I can use it to hack together solutions. Balancing glass globes sounded like a "quickie problem"! :>
--don
Sorry, that should be vitanuova not vitanuovo
ElectronDepot website is not affiliated with any of the manufacturers or service providers discussed here. All logos and trade names are the property of their respective owners.