« first day (1872 days earlier)      last day (2602 days later) » 

halirutan
halirutan
12:31 AM
@Mr.Wizard This seems almost useless for users on our side. MichealE2 has only one gold-badge, belisarius has 2, Szabolcs has none..
(Oh, I haven't seen that there were several tabs of badges. That increases Michaels gold tag badges to two if I'm not mistaken).
Anyway, it seems like a really high burden just to edit the list of duplicates.
 
 
2 hours later…
Mr.Wizard
Mr.Wizard
2:41 AM
@halirutan Forgive me, but I'm actually being selfish here. Previously it was not possible for moderators to mark a duplicate pointing to more than one original. Regular users could, because if different users voted for different originals that was done automatically. Moderators (or gold tag badge users) have a binding vote and therefore the first vote cast closes the question, marking only one original. Now moderators can edit that list as desired.
This also means that if later another duplicate is found it can be added to the list.
 
halirutan
halirutan
@Mr.Wizard No harm done as you are doing most of the dirty work anyway.
I just wondered, looking at the votes e.g. on math.SE, how many users really can take advantage of this.
 
Mr.Wizard
Mr.Wizard
@halirutan I think one must admit that Stack Exchange still takes Stack Overflow as the model for all sites, and bases functionality on what works there foremost.
 
 
1 hour later…
Rojo
Rojo
3:53 AM
@Mr.Wizard Thanks! :)
 
 
2 hours later…
yode
yode
5:45 AM
@xslittlegrass Excuse me for "much easier to read than the Chinese".So you mean you can understand totally the usage of Unevaluated here?
@xslittlegrass The English presentations always longer than Chinese..Sometimes it is not a good news to me. :)
 
 
5 hours later…
xzczd
xzczd
10:50 AM
I think the code under "Honorable Mention
George Varnavides: “Symmetry in Chaos” (128 characters)" is incorrect?:
c=Conjugate[#];func=c& won't define a function same as Conjugate[#]&
 
xzczd
xzczd
11:09 AM
Oh no, it's correct… but why? Auto-compilation?
 
xzczd
xzczd
11:29 AM
Very interesting……
This is related to a very subtle behavior of CompilationOptions -> {"InlineExternalDefinitions" -> True} 
a = #;
Compile[{c}, Nest[a &, c, 10],
  CompilationOptions -> {"InlineExternalDefinitions" -> True}] // CompilePrint
can be compiled. 
a = #;
Compile[{c}, a &@c,
  CompilationOptions -> {"InlineExternalDefinitions" -> True}] // CompilePrint
can't be compiled
i.e. the a in a& will be inlined only if a& is the first argument of Nest/NestList
 
halirutan
halirutan
12:05 PM
@xzczd precedence baby :)
 
xzczd
xzczd
12:26 PM
@halirutan Precedence?
 
halirutan
halirutan
@xzczd I think bringing a pure function into this example is more confusing. It seems it doesn't work when the inlined symbol is used as a head of a function. Look at this slightly simpler example: 
a = Sqrt;
Compile[{c}, a[c],
  CompilationOptions -> {"InlineExternalDefinitions" ->
     True}] // CompilePrint
Doesn't work, but the equivalent Nest version works.
 
xzczd
xzczd
Yeah, I think this should be considered as a not-well-known behavior of "InlineExternalDefinitions" ->True
 
halirutan
halirutan
@xzczd What I mean is that one might confuse that the part before the ; is separated and you just define func=(c&)
It leaves c unevaluated, but when you apply something to it, it of course evaluates to the earlier defininition of c=Conjugate[#] making it a correct pure function.
@xzczd Often, I inline things into compile making it a pure function.
 
J dane
J dane
Hi guys i don't know if this is a correct room for this question here: http://dsp.stackexchange.com/questions/38111/correct-method-for-up-sampling-cross-power-spectrum-for-sub-pixel-motion-estimat

anyone care to have a look?
 
halirutan
halirutan
@xzczd In your case, you could use Function but it might look confusing: 
a = #;
Function[x,
   Compile[{c}, x &@c,
    CompilationOptions -> {"InlineExternalDefinitions" -> True}]
   ][a] // CompilePrint
 
xzczd
xzczd
12:35 PM
@halirutan Well, But c=Conjugate[#];c&@I won't evaluate to -I
I mean, usually, in this case, we need c=Conjugate[#];Evaluate[c]&@I or something similar to make it work as expected
This isn't needed for a auto-compiled Nest/NestList
This is the part I found interesting
 
halirutan
halirutan
@xzczd But we don't know how exactly it is inlined. So it is not unusual that it works.
What if they do a verbatim replacement like this: 
c = Conjugate[#]; With[{c = c}, func = c &]
internally.
 
xzczd
xzczd
They didn't do that, because 
a = b;
Compile[{c}, Nest[Function[b, a], c, 10],
  CompilationOptions -> {"InlineExternalDefinitions" -> True}] // CompilePrint
isn't compiled :)
@halirutan This behavior is really new to me. I thought "InlineExternalDefinitions" -> True only works for compilable numbers and pure functions.
 
halirutan
halirutan
@xzczd This would be exactly where With cannot be used because it respects scope. Look here, doesn't work either: 
With[{a = b}, Function[b, a]]
 
xzczd
xzczd
Oh……then 
a = #;
Compile[{c}, a &[c],
  CompilationOptions -> {"InlineExternalDefinitions" -> True}] // CompilePrint
How about this?
@halirutan They only do the replacement for Nest/NestList? :D
 
halirutan
halirutan
@xzczd No, look at this :)
Use {a &, a &[c]} inside your compile and see that a is really replaced in the first case.
@xzczd So the bottom line is: When you want to apply the body of a pure function to a value inside Compile like in your example, you cannot simply write f[x], you need to call Nest[f,x,1] :)
@xzczd This btw, seems not to catch it all. As far as I can see, OwnValues of symbols are inlined. 
expr = Nest[Sqrt, c, 10];
Compile[{c}, expr,
  CompilationOptions -> {"InlineExternalDefinitions" ->
     True}] // CompilePrint
works perfectly.
And it's not a number or a pure function, but a general expression in c.
 
xzczd
xzczd
12:56 PM
@halirutan Quite interesting…
Oh seems that Compile is more subtle than I thought…
Maybe I should consider posting a relevant question in the main site.
 
halirutan
halirutan
@xzczd Yes, there seem to be some subtleties that one isn't aware of.
Although, I'm not sure one can really answer the questions without internal knowledge.
@Jdane Well, your question is about Matlab, not Mathematica. People tend to be picky about this tiny detail :)
 
J dane
J dane
@halirutan ah I see, now I really felt helpless, god.
 
halirutan
halirutan
@Jdane I mean, the underlying problem is very interesting, but well studied. You could restate your question to make it fit here, but I guess a Mathematica solution wont help you.
 
J dane
J dane
@halirutan alright I try to shift the context, thanks! :)
 
halirutan
halirutan
@Jdane Maybe two comments: Always include sample images and make your code executable with them.
People don't know what you are dealing with and image registration can be hard.
2. Why do you upscale the data to get subpixel accuracy? Isn't it better to interpolate the data and search for the maximum?
 
J dane
J dane
1:12 PM
@halirutan Scaled it up so that I could get sub-pixel accuracy, because the motion is within sub-pixel scale. From the up-sampled data, I'll interpolate again to get the approximation
 
halirutan
halirutan
@Jdane Look, how is upscaling done? Right, the data is interpolated to calculate the new pixels.
You can just interpolate the data and work with the interpolating functions and you have infinite upscaling..
 
J dane
J dane
@halirutan by adding zeros around the actual data. Hers's an example: stackoverflow.com/questions/13501502/matlab-padarray-function
 
halirutan
halirutan
@Jdane Oh, you're upscaling in the frequency domain. Haven't seen that.
 
J dane
J dane
@halirutan Yep, up-scaling in frequency domain is much more efficient than in spatial domain
@halirutan I followed this step from a paper, but I not quite sure I followed it correctly. Is it possible for you to have a look at the paper? It's all mathematical.
 
halirutan
halirutan
@Jdane Uhh, it's Saturday. I guess I have to refuse for now. Why don't you include the sample images and the link to the paper in the question?
 
J dane
J dane
1:30 PM
@halirutan Haha I guess I'll hope for the best. Here's the link to the paper: mega.nz/#!zsdCDZAJ!a-5iu3fBHCdzOLGOahWWX4ydGaNa1UVlKFXbTiH3x88
@halirutan start from section 3 will be fine :)
Thanksssss!!!!
sorry here's the link in case your changed your mind mega.nz/#!PoklnaJR!hj_Bejha6owN1TyyxodM-F-OGvjdZYlyJImNapALXLA
;)
 
Szabolcs
Szabolcs
2:13 PM
I have a large binary image (~ 3000x4000). I want to partition it into small blocks (e.g., 2x2, 3x3 blocks), and replace each block by a single pixel. It should be black if there was at least one black pixel in the block, and white otherwise. What is a fast way of doing it?
Compile helps a lot. My mistake was to try to work with images directly instead of extracting the data. cf = Compile[{{arr, _Integer, 2}, {n, _Integer, 0}}, Map[Min, Partition[arr, {n, n}], {2}]]. Just make sure that the array dimensions are divisible by n.
 
 
1 hour later…
Szabolcs
Szabolcs
3:35 PM
 
yode
yode
3:48 PM
@Szabolcs A beautiful landscape painting in the last frame..The code will be spread?
 
Szabolcs
Szabolcs
Sure, why not?
I want to improve it a bit first.
 
yode
yode
@Szabolcs Same to your code but concise..
 
Szabolcs
Szabolcs
@yode For large arrays BlockMap is slower, but for smaller ones it is considerably faster than my compiled function. I wonder why. Thanks for the tip!
 
 
2 hours later…
yode
yode
5:33 PM
@Szabolcs But this test show the compile seem to take a little effect?
I have to say the compile is a big hole in Mathemtica..
 
MMM
MMM
5:53 PM
eqn = {x''[t] + w^2*x[t] == 0, y[t] == x'[t]}; w = 1;
sol = DSolve[eqn, {x[t], y[t]}, t];
xt[t_] = Flatten[x[t] /. sol /. {C[1] -> 1, C[2] -> 1}][[1]];
yt[t_] = Flatten[y[t] /. sol /. {C[1] -> 1, C[2] -> 1}][[1]];
yx[x_] = yt[InverseFunction[Function[{a}, xt[a]]][x]];
Plot[yx[x], {x, -0.5, 0.5}, AspectRatio -> Automatic,
PlotRange -> All]
Show[ParametricPlot[
Evaluate[{x[t], y[t]} /. First[sol] /. {C[1] -> 1, C[2] -> 1}], {t,
0, 10}],
Plot[yx[x], {x, -0.5, 0.5}, AspectRatio -> Automatic,
PlotStyle -> Red]]
 
halirutan
halirutan
6:03 PM
@Szabolcs Consider the following approach: 
cf1d = Compile[{{line, _Integer, 1}},
   Map[Min, Partition[line, 2]],
   CompilationTarget -> "C", RuntimeAttributes -> {Listable},
   Parallelization -> True
   ];
step[data_] := Transpose[cf1d[Transpose[cf1d[data]]]]
If your operator is separable, you can run it on each line and with the help of compiles parallilization, calculate each line in parallel. Then, you just transpose the result and do it again.
With n=2 fixed for this example, I get the following 
link = "https://static.pexels.com/photos/94616/pexels-photo-94616.jpeg";
img = ImageResize[Binarize[ColorConvert[Import[link], "Grayscale"]], 2^12 {1, 1}];
data = ImageData[img, "Bit"];
Your version: 
cf = Compile[{{arr, _Integer, 2}, {n, _Integer, 0}},
   Map[Min, Partition[arr, {n, n}], {2}]];
Nest[cf[#, 2] &, data, 5]; // AbsoluteTiming
Has a runtime of 0.928225 seconds 
Nest[step, data, 5]; // AbsoluteTiming
has a runtime of 0.320285 seconds.
I expect a simple nested loop in C, parallelized with OpenMP will be even faster.
 

« first day (1872 days earlier)      last day (2602 days later) »