Hot answers tagged

16

dat = {0.71, 0.685, 0.16, 0.82, 0.73, 0.44, 0.89, 0.02, 0.47, 0.65}; Module[{t = 0}, Split[dat, (t += #) <= 1 || (t = 0) &] ] {{0.71, 0.685}, {0.16, 0.82, 0.73}, {0.44, 0.89}, {0.02, 0.47, 0.65}} Credit to Simon Woods for getting me to think about using Or in applications like this. Performance I decided to make an attempt at a higher ...


14

This is a good example of why one should never blindly trust the numerical results of systems like Mathematica, without thinking about numerical methods that these systems use. Mathematica won't ever make numerical analysis courses obsolete. Most interpolation methods use piecewise polynomials, and assume slowly varying smooth functions. Your data has ...


9

I think it's possible to find the shape automatically, but I can't say how reliable this will be. If you can post more sample images, I can try to improve this. Using your image: img = Import["http://i.stack.imgur.com/kL6cd.jpg"]; I would use watershed segmentation to find the particle. The idea is this: Imagine the image gradient strength as a 3d ...


8

edit (30 Jan 2016) : one error corrected, rotation (§4) added,result slightly higher (1.3%) I propose the following solution : 1) interactively mark the frontier of the object by points 2) interactively mark the center of the object 3) use polar coordinates (r,theta) with the origin at the center. Thus r[theta] is symetric around a angle theta0, ...


7

Assume that you have your lists of unique resistor values (resistors) and of unique capacitor values (capacitors). For now, I generate two such lists as follows: resistors = Flatten@ Outer[ Times, PowerRange[1, 10000], {100, 110, 120, 130, 150, 160, 180, 200, 220, 240, 270, 300, 330, 360, 390, 430, 470, 510, 560, 620, 680, 750, 820, ...


6

Yes, they are equivalent. _ is a pattern that matches any expression. x_ is the same thing, with a name, x. The pattern name can be used in two ways. The most common way is to refer to it on the right hand side of the definition or rule. For example, f[x_] := x^2. If we are not using the matched expression in the right hand side, there's no reason to ...


6

The problem is that during the evaluation process it attempts to numerically integrate using the symbol a. That is the source of the warning message. However, if you persist (and ignore the warning), ArgMin will eventually switch over to using numerical values and output the correct value. ArgMin[{NIntegrate[(Tanh[x] - Erf[x/a])^2, {x, -5, 5}], 0.5 ...


5

I do not know how to extract that information from an InterpolatingFunction object, but perhaps you could make your own Piecewise function using InterpolatingPolynomial: pts = RandomReal[{-10, 10}, {10, 2}]; piecewise = Piecewise[ {InterpolatingPolynomial[#, x], #[[1, 1]] <= x < #[[2, 1]]} & /@ Partition[SortBy[First][pts], 2, 1] ] ...


5

We can transfer the phase function from Matlab to Mathematica: phase[vec_List] := Module[{phi, df, len, i}, phi = Arg @ vec; df = Differences @ phi; len = Length @ phi; i = Flatten @ Position[df, x_ /; Abs[x] > 3.5]; Do[phi = phi - (2 Pi*Sign[df[[j]]]*UnitStep[# - (j + 1)] & /@ Range[len]), {j, i}]; phi] data = ...


4

If test is a list of numbers, your code works fine: f[x_] := (If[x > 0, x*n1, 0]) test = {1, 2, 3, -1}; f /@ test (* {n1, 2 n1, 3 n1, 0} *) If you import test from an Excel file, Mathematica might give you a 2D array (Excel sheets are like matrices). You can use Flatten to convert it to a flat list, or alternatively use Part with All (please check ...


4

f[x_]:= Exp[10*x^2] D[f[x], x] /. f[x] :> HoldForm@f[x] Update B[t_, T_] := 1/a*(1 - E^(-a*(T - t))); A[t_, T_] := 1/a^2*(a*b - 1/2*sigma^2)*(B[t, T] - T + t) - (sigma^2*(B[t, T])^2)/(4*a); P[t_, T_, r_] := Exp[A[t, T] - B[t, T]*r]; D[P[t, T, r], {r, 1}] /. B[t, T] -> HoldForm[B[t, T]] /. P[t, T, r] -> HoldForm[P[t, T, r]] gives the ...


4

The sequence $f[k]$ you are looking for is Sloane's A038664. There is Mathematica code given there by Harvey P. Dale. With[{d=Differences[Prime[Range[50000]]]}, Flatten[Table[Position[d, 2n, 1, 1], {n, 50}]]] which returns {2,4,9,24,34,46,30,...}.


4

I couldn't figure out a quick way to import the data how you had your paste formatted (with curly brackets for each element, but no outer curly brackets) so I reformatted it and repasted it. data = Import["http://pastebin.com/raw/V8807EsY", "Table"]; You say you'd like to average the duplicate points, so using Mean in combination with GatherBy should ...


4

f[x_, y_] := Module[{new}, If[Total[new = Append[x, y]] >= 1, Sow[new]; {}, new]] Reap[Fold[f, {}, dat]][[2, 1]]


4

Here's my take at making a function as fast as possible. main = Module[{idxs = sub[Accumulate@#]}, Internal`PartitionRagged[#, idxs]] &; sub = Compile[{{list, _Real, 1}}, Block[{i, l = Length[list], ref = 1., bag = Internal`Bag[{0}]}, For[i = 1, i <= l, i++, If[list[[i]] >= ref || i == l, Internal`StuffBag[bag, i]; ref = ...


4

Internal`PartitionRagged uses Accumulate internally to generate a list of positions from the sub-list lengths, then MapThread and Take to extract the corresponding elements from the array. You can check the internal definition with Needs["GeneralUtilities`"]; PrintDefinitions[Internal`PartitionRagged] The reason for pointing this out is that answers which ...


3

Reduce[expr, x, Reals] will be your friend here, but it can take a bit of work to parse its result. Here's a solution that should work for any expression, not just polynomials (at least for the small set of examples I tried). RealInverse[a_. x_^q_Integer?Positive + b_., x_] /; FreeQ[{a, b}, x] := Surd[(x-b)/a, q] RealInverse[expr_, x_] := Module[{y, ...


3

SeedRandom[1]; pts = RandomReal[{-10, 10}, {10, 2}]; Clear[if, ip] If the InterpolationOrder is set to Length[pts] - 1 then the InterpolatingFunction is the InterpolatingPolynomial if[x_] = Interpolation[pts, InterpolationOrder -> Length[pts] - 1][x]; ip[x_] = InterpolatingPolynomial[pts, x] // HornerForm (* -18.7844 + x (6.55948 + x ...


3

Some of these could be implemented differently, of course, but I've gone the way of making all of them pure functions (in the Mathematica sense). Every single one takes a Sequence of arguments as the inputs, but some of them accept function names as inputs first, and the projection function accepts an integer for which argument is chosen (I have chosen to ...


3

Your code can be transformed in a function definition as follows: find[img_] := Module[{centerOne, bin, components}, centerOne = ImageTransformation[src, img, {200, 200}, DataRange -> Full, PlotRange -> {{0, 1}, {0, 1}}]; bin = Dilation[EdgeDetect[centerOne], 3]; components = ComponentMeasurements[ bin, ...


3

I think this is only a dislay issue: If you set x=3231.432 you also get 3231.42 as a return. However, if you evaluate, say, x-3000 the missing digit (2) will appear again. I guess Mathematica only displays five significant figures (per default). Hope this helps.


3

Default is another way to specify optional arguments, which allows for this: Default[f, 2] = Sequence[1, 2, 3] f[x_, y_.] := {x, y} f[1, 2] {1, 2} f[1] {1, 1, 2, 3}


3

If you wish to find a formula for a set of data, you could use the FindFormulafunction: values = {{0.3, 360}, {0.4, 315}, {0.5, 280}, {0.6, 250}, {0.7, 225}, {0.8, 200}, {0.9, 180}, {1.0, 165}, {1.1, 150}, {1.2, 135}, {1.3, 125}, {1.4, 115}, {1.5, 105}, {1.6, 97}, {1.7, 93}, {1.8, 88}, {1.9, 85}, {2.0, 84}}; ...


2

f[x_, y_] := {x, y} f[x_] := {x, Sequence[1, 2, 3]}


2

In general, when you see a function prototype with a formal argument of the form oneflag_ : 0, it means the actual argument can be of any type (or more precisely have any head), but if it is omitted, then the value 0 will be used. Look up Optional in the documentation.


2

You need to make sure there are no active definitions on the constituent parameters. You can do this with ClearAll as E.Doroskevic proposes, though I imagine you will not want to clear all Global` definitions. You can Block the Symbols in use as described in Scoping in assigning a derivative. To make this convenient I propose using the function localSet ...


2

One problem you're having is that because Manipulate localizes its variables, while the symbols in par are global (in the "Global`" context), the letters a, b, c inside the Manipulate do not refer to the variables in par. Your workaround seems reasonable. There's also the option LocalizeVariables, which can be set to False to make the Manipulate parameters ...


2

f[n_] = 351 n^(-0.7); f /@ {2, 9, 22} (* {216.066, 75.3941, 40.3284} *) Or, using a pure function 351 #^(-0.7) & /@ {2, 9, 22} (* {216.066, 75.3941, 40.3284} *) In WolframAlpha use the pure function WolframAlpha["351 #^(-0.7)&/@{2,9,22}"]


2

You can use Outer along with Map. Map[LCM[37, Sequence @@ #] &, Outer[List, list1, list2], {2}] (* {{370, 370, 1110, 2590}, {555, 1110, 1110, 7770}, {185, 370, 1110, 2590}, {370, 370, 1110, 2590}} *) Hope this helps. Or as @SimonWood has pointed out in the comments. Outer[LCM[37, ##] &, list1, list2]


2

Example: LCM[37, #[[1]], #[[2]]] & /@ Transpose[{list1, list2}] or MapThread[LCM[37, ##] &, {list1, list2}] Output: {370, 1110, 1110, 2590} Reference: & # /@ etc. MapThread Transpose



Only top voted, non community-wiki answers of a minimum length are eligible