To get neighboring vertices I first tried:
gg = GridGraph[{10, 10, 10, 10}];
VertexList[NeighborhoodGraph[gg, 1, 1]] // AbsoluteTiming
{5.539308, {1, 2, 11, 101, 1001}}
But that is really slow. This is much faster and still uses the new Graph package:
Union[VertexInComponent[gg, 1, 1],...
The solution is easy enough, but not at all easy to discover. I wasted a lot of time this afternoon because I didn't remember that NeighborhoodGraph wants to recompute the layout apparently for no good reason ... This is just not user friendly!
@rm-rf The fact that you used a custom neighborhood graph function also shows how bad a behaviour this is. It seems many people waste time with reimplementing the function.
@Szabolcs, I did. it is slow. I also found a problem with the Uploader
The uploader failed with these error (so I had to do an old fashioned screen shot for this)
Basically, the uploader failed to snap shot the cells I selected. I am on Linux btw, and using a trial version of Mathematica 9 for evaluation on Linux
When I select the cell, this is how the uploader screen looks
You can see, it did not pick the equations typed. Here is how the cell looks like
So, there is some problem somewhere.
Link`Java::argx1: Method named setRequestEntity defined in class org.apache.commons.httpclient.methods.PostMethod was called with an incorrect number or type of arguments. The argument was $Failed.
@Nasser I know, the uploader palette does not work with the trial version. Unfortunately Export is disabled in the trial version and the uploader relies on it (or rather on ExportString).
Lee un poco acerca de los hábitos nocturnos antes de la existencia de la luz eléctrica. Por alguna razón quedaron olvidados. La gente no siempre durmió de la manera en que ahora se considera "sano"
I wonder about the life-styles of the inhabitants of ancient civilizations. As a particular case, if we consider the era of Sumer, what are the significant diversities compared to rural life today?
@belisarius Even if I can manage with a couple of lettuce salads a day, that would suck. Eating is nice, as well as sleeping
and the act of reproducing
Godzilla gave us positive reinforcement for those human needs. Now we have fat overpopulation. But for some reason, we also have anorexic people and sleep-anorexic people like you and me. We shouldn't exist
I was just wondering if you know what the logic is in having And evaluate its arguments when one does not yield either True or False. That is, And["foo", Print["x"]] prints "x". I'm sure there's a good reason for this and I've probably even relied on this behavior before, but I'm struck by the fact that I don't know why it's designed that way.
@rm-rf I'm not sure what you mean. It does not evaluate all arguments, e.g. And[False, Print["x"]] does not print, which I'm sure you know. I guess it makes sense for And to try to find out if any of the terms will be False so that it can return an answer. I guess I'm wondering if this is a design choice or if Andmust behave this way to adhere to formality.
Yes, I understand that it is in order. I am wondering if it would be a valid design choice to have And simply sit unevaluated if the first term was neither True nor False.
It's lunch time here and I should think about this more anyway so I don't ask stupid questions. I'll talk later. Thank you.
I need some quick advice ... I need a uni/multimodality test on a 2D distribution. I have a histogram to start with. It's a bit wiggly at small scales.
@Rojo Yes, it would, and at times that might be useful. I got started thinking about this as I recalled Simon Woods' interesting use of And and Or here:
I cannot write the code without any loops, but I have pared it down to a single While loop, making extensive use of short-circuiting to bail out of the expression at the appropriate point. Whether you consider this cleaner than nested For loops is a matter of taste. I personally find it easier to...
To explain the difficulty I am having a bit better, take a look at this figure:
Only the orange cells can have non-zero probabilities, and the orange region is a bit disconnected. This is why it's a bit difficult to define and test "multimodal" here. Actually in my case it's going to be typically bimodal.
Despite the gaps, despite the fact that I have several tiny orange islands, 'neighbouring' island should really count as connected.
@Mr.Wizard My next statement was just noting that returning unevaluated if the first argument doesn't evaluate to True/False would not return False for And[foo, False]
@Rojo Actually, I want to test if there are two islands within that orange island. Look at this figure:
There's a function defined on the orange region only. Red is high, orange is low values. I need to find out if there are two islands of high (red) values, or if there's a single one. But the region the function is defined on (previous orange figure) is disconnected itself.
I typically either have one red peak which can go anywhere, including the two extremes of the crescent, or two red peaks which are typically located at the extremes.
@Rojo Something like that. If this didn't go to 25 and 50, but to a very large number along both axis, then that would be much better. But I can't possible compute such a large problem, and I need to verify some theoretical calculations for this tiny version
I'm just going to blur the whole thing with the approximate radius and do some image analysis
To get neighboring vertices I first tried:
gg = GridGraph[{10, 10, 10, 10}];
VertexList[NeighborhoodGraph[gg, 1, 1]] // AbsoluteTiming
{5.539308, {1, 2, 11, 101, 1001}}
But that is really slow. This is much faster and still uses the new Graph package:
Union[VertexInComponent[gg, 1, 1],...
I wonder about the life-styles of the inhabitants of ancient civilizations. As a particular case, if we consider the era of Sumer, what are the significant diversities compared to rural life today?
