Tag Info

New answers tagged

1

You may consider this, rl= (a_. Sum[b_. Subscript[x_, i_], {i_, i0_: 1, n_}]) :> Sum[(a b) Subscript[x, i], {i, i0, n}]; exp = Sum[2/9 Subscript[x, i], {i, 1, n}] + 2 Sum[1/9 Subscript[x, i], {i, 1, n}]; Apply transformation rule repeatedly: exp //. rl Collecting more than two sums: exp1 = 1 Sum[3/9 Subscript[x, i], {i, 1, n}] + 3 ...


0

Use a replacement rule rule = (a1_. * Sum[c1_. Subscript[x_, i_], {i_, i0_: 1, n_}] + a2_. * Sum[c2_. Subscript[x_, i_], {i_, i0_: 1, n_}]) :> Sum[(a1*c1 + a2*c2) Subscript[x, i], {i, i0, n}]; expr = Sum[2/9 Subscript[x, i], {i, 1, n}] + 2 Sum[1/9 Subscript[x, i], {i, 1, n}]; expr /. rule Sum[(4*Subscript[x, i])/9, {i, 1, n}]


1

I'm guessing you are looking for the list of replacements that need to be made going down to level 0 instead of just showing the level 0 results. Are you looking for something like this? assignments[d] = a + b; assignments[e] = b c; assignments[f] = d e; assignments[x_] := x; FixedPointList[Map[assignments, #, {-1}] &, {f}][[;; -2, 1]] {f, d e, b ...


1

Maybe I missed the point, but if you just copy and paste your expressions (and insert spaces to give multiplication) you get: d = a + b; e = b c; f = d e which gives you b (a + b) c, which is equivalent to your given f. Is this all you were asking?


2

expr = Abs[x + I y] + Sin[Abs[c + I (d + e)]]; expr /. Abs[a_ + I*b_] -> Sqrt[a^2 + b^2] (* Sqrt[x^2 + y^2] + Sin[Sqrt[c^2 + (d + e)^2]] *) Have fun!


4

Use ComplexExpand expr = Abs[x + I y] + Sin[Abs[c + I (d + e)]]; expr // ComplexExpand Sqrt[x^2 + y^2] + Sin[Sqrt[c^2 + (d + e)^2]]


2

You main problem here is that a SymmetrizedArray is not an expression once you have constructed it. It is an atom, a raw object that (although it looks otherwise) cannot be decomposed into smaller expressions AA = SymmetrizedArray[{{1, 2} -> (a^2 - b^2)^3, {1, 3} -> ((a - b) (a + b))^3, {2, 3} -> x}, {3, 3}, Antisymmetric[{1, 2}]]; AtomQ[AA] ...


3

eqn = x/y + x/y^2 + x/y^3 + x/y^4 == 4/x; Numerator[Together[eqn /. Equal -> Subtract]] == 0 x^2+x^2 y+x^2 y^2+x^2 y^3-4 y^4==0 %// TeXForm $x^2 y^3+x^2 y^2+x^2 y+x^2-4 y^4=0$ Or, flttnF = Numerator[Together[# /. Equal -> Subtract]] == 0 &; flttnF@eqn (* same result *)


0

flattenEqn[eqn_Equal] := Module[ {factor = Times @@ Denominator /@ (eqn // Together), eqn2}, eqn2 = factor*# & /@ eqn; eqn2[[1]] - eqn2[[-1]] == 0 // Expand] eqn = x/y + x/y^2 + x/y^3 + x/y^4 == 4/x; flattenEqn[eqn] x^2 + x^2*y + x^2*y^2 + x^2*y^3 - 4*y^4 == 0 Collect[#, x] & /@ % -4*y^4 + x^2*(1 + y + y^2 + y^3) == 0


1

The problem here is with FullSimplify, not your definition. (First I'll rewrite your definition to be a little more standard.) myArcTan[c_, s_] := Pi + ArcTan[-c, -s] Just because Mathematica fails to Simplify this expression myArcTan[Cos[x], Sin[x]] to x doesn't mean that they're not equal: Plot[myArcTan[Cos[x], Sin[x]], {x, 0, 2 Pi}] In fact, ...


1

Not sure if I understand you correctly but you can define your own function as follows: f[0, x_] := Sign[x] Pi/2 f[x_, y_] := ArcTan[x, y] f[Cos[x_], Sin[x_]] := x FullSimplify[f[Cos[x], Sin[x]]] (*x*) Based on your comments, I can suggest for you this method: MyArcTan[x_, y_] := ArcTan[-x, -y] + Pi; MyArcTan[r_.*Cos[x_], r_.*Sin[x_]] := x; Assuming[0 ...


2

Patterned assumptions seem to need to match the ConditionalExpression's condition exactly to work out for some cases. The ∈ Reals-assumptions do work as you gave them, while the inequality Subscript[s,_]>0 does not, but observe the different behavior of Subscript[s,_]>=0: Evaluating without any assumptions first: f = 1/\[Sqrt](2 \[Pi] Subscript[s, ...


1

The document never promises that pattern-matching is supported inside Assumptions. (Though in some cases it does seem to be!) So the only stable way I can think of is as following: Subscript[g, i_][x_] := ($Assumptions = Union[$Assumptions~Join~ {{Subscript[m, i], Subscript[s, i]} ∈ Reals, Subscript[s, i] > 0}]; Exp[-((x - Subscript[m, ...


2

Because you made a mistake when using double angle identity. In your equations, I got(2 Sin[θ/2]) == (1 - Cos[θ]), where it should be (2 Sin[θ/2]^2) == (1 - Cos[θ]) Assuming[μ > 0 && g > 0 && ℏ > 0 && m > 0 && k > 0, Integrate[(4 μ^2 g^2)/(ℏ^4 (m^2 + 4 k^2 Sin[θ/2]^2)^2) Sin[θ], {θ, 0, π}, {ϕ, 0, 2 π}]] // ...


2

Use ComplexExpand to tell M all symbols are real ComplexExpand[Im[(20 + 140 I)*Lg + (7 + 140 I)*Ls], {Ls > 0, Lg > 0}] See help on ComplexExpand. Ps. This question has been asked many times before and is duplicate. Will be closed.


0

I suspect that it relates to convergence. Here are some experiments which may give a clue to that. Sum[Binomial[m - r - 1, b] z^(r + b) (-1)^(a + b + r + 1), {b, 0, m - r - 1, 1}, GenerateConditions -> True] ConditionalExpression[((-1)^(a + r) (1 - z)^(m - r) z^r)/(-1 + z), m - r \[Element] Integers && (z != 1 || Re[m - r] > 1) && m ...


0

Here comes a simple solution, perhaps. The two cases characterize the usage well. expr = Sqrt[f[y[qq], z]^2] + Sqrt[DD[2, 3, 4]^2] + (f[1, 2] > 0); FullSimplify[expr, Thread[Cases[expr, x_[___] /; ! ValueQ[x], Infinity] > 0]] FullSimplify[expr, Thread[Cases[expr, f[___] /; ! ValueQ[f], Infinity] > 0]] Out[94]= True + DD[2, 3, 4] + f[y[qq], z] ...


1

This might be what you want: myfullsimplify[expr_, assum_] := Module[ {pat, tmp, seq}, pat = FirstCase[Level[assum, Infinity], p[_]] /. p[x_] -> x; tmp = FirstCase[Level[expr, Infinity], pat]; seq = {expr, assum} /. {pat -> #, p[_] -> #}; FullSimplify @@ seq /. # -> tmp ] It's used as follows: myfullsimplify[entry[1, 2, 3] < 0, ...


0

MapAt[ToExpression@ToString@# &, #, Position[#, _Rule]] &[ToExpression@#] &@str (* {1 -> {a -> aa, b -> bb}, 2 -> {2 a -> {b -> bb}}} *)


3

Generally speaking, If is for programming and Piecewise is for function construction. While the distinction is somewhat artificial, the significant difference is that Piecewise, although having the attribute HoldAll, evaluates its arguments. The effective difference can been seen by evaluating q1[t] with the OP's definition of k[v] and this one: k[v_] := ...


2

You can start by simply creating a function that tests, whether a string is a list of rules or not isTransformable[str_String] := SyntaxQ[str] && MatchQ[MakeExpression[str], HoldComplete[{_Rule ..}]]; isTransformable[___] := False; Note that this function does much more that search for a "->" inside a string. First, it tests, whether the ...


1

I don't quite understand your code, especially the key_/;key->val_ part, but the following code shall do your work: ToExpression@str //. key_String /; StringMatchQ[key, ___ ~~ "->" ~~ ___] :> ToExpression[key]


3

In recent versions of Mathematica you should see something like this: RandomInteger[99, {500, 50}] Or like this (version 7): Clicking show all or Show Full Output should do just that. Be aware that if the expression is large this can hang the Front End or consume all your RAM. Within the preferences you should also have something like this (the ...


3

For performance fiends: I had an application that had this very need for some huge sets of long integer strings. kguler's solution is certainly the canonical way, and quite quick, as is Felix's version (I was actually surprised on that one). eldo's solution is probably what most would come up with, but in performance-intensive scenarios the StringSplit is ...


1

Or the StringReplace version: In[3]:= StringReplace[str, WordCharacter .. ~~ " -> ," -> ""] Out[3]= "{Aaaa -> a, Bbbb -> b, Ddddd -> c, Fffff -> e}" In[4]:= ToExpression@% Out[4]= {Aaaa -> a, Bbbb -> b, Ddddd -> c, Fffff -> e}


2

FromDigits /@ StringSplit["1 2 3 4 5 6"] ToExpression@StringSplit["1 2 3 4 5 6"] StringCases["1 2 3 4 5 6", ns : NumberString :> FromDigits[ns]] ToExpression@StringCases["1 2 3 4 5 6", NumberString] all give (* {1, 2, 3, 4, 5, 6} *)


2

res = ToExpression@StringSplit["1 2 3 4 5 6", " "] {1, 2, 3, 4, 5, 6} Head /@ res {Integer, Integer, Integer, Integer, Integer, Integer}


2

Flatten[ImportString["1 2 3 4 5 6", "Table"]] {1,2,3,4,5,6} Head /@ % {Integer, Integer, Integer, Integer, Integer, Integer}


1

ToExpression["{" <> StringReplace["1 2 3 4 5 6", " " -> ","] <> "}"]


2

You can also use a combination of StringSplit, SyntaxQ and Pick: str = "{Aaaa -> a, Bbbb- > b, Cccc -> , Ddddd -> c, Eeeee -> , Fffff -> e}"; str2 = Pick[#, SyntaxQ /@ #] &@StringSplit[str, "," | "{" | "}"] (* {"Aaaa -> a", " Ddddd -> c", " Fffff -> e"} *) ToExpression@str2 (* {Aaaa -> a, Ddddd -> c, Fffff -> e} *) ...


2

You can use StringCases. str = "{Aaaa -> a, Bbbb -> b, Cccc -> , Ddddd -> c, Eeeee -> , Fffff -> e}"; ToExpression@StringCases[str, WordCharacter .. ~~ " -> " ~~ WordCharacter ..] {Aaaa -> a, Bbbb -> b, Ddddd -> c, Fffff -> e}


1

Different version of Bob Hanlon's solution: f = (1 - # &)@*(1 - # &)@(# &) (*#1 &*) f@x (*x*)


0

Just another way to look f = (1 - #) & (*your function*) g[f__] := (a f@ # + b f@f@#)& (*your arbitrary complicated function of function*) h[x_] := Simplify[g[f][x]] (*your final function*) (I just wanted to use Simplify somehow)


4

Since, Attributes[Function] {HoldAll, Protected} Use Evaluate f = Function[{x}, Evaluate[(1 - # &)@*(1 - # &)@x]] Function[{x}, x] f@x x


1

ToExpression[ "{a-> POR, b-> D610, c-> 0, d-> \"300/7\", e -> \"1/400\"}" ] /. s_String :> Defer @ ToExpression[s] {a -> POR, b -> D610, c -> 0, d -> ToExpression["300/7"], e -> ToExpression["1/400"]} response to comment: ToExpression[ "{a-> POR, b-> D610, c-> 0, d-> \"300/7\", e -> ...


3

Perhaps the closest thing to what you want is to use HoldForm to prevent the sorting behavior of Times due to Orderless: str = "one Test String to see"; HoldForm @@ MakeExpression @ str one Test String to see However it is important to realize that the HoldForm head is still present, only that it is not shown in standard formatted output. Also know ...


1

The issue arises due to numerical rounding differences between the expression and its simplified form. If you Rationalize the original expression you will get the expected results. Eqs = {{-((3 \[Rho]^2 q1[x])/(1 - x^2)^2) - 2. \[Rho]^2 q1[ x] q4[x]^2 - (1/(16 x (-1 + x^2)^2 q1[x] q2[x]^2 q3[ x])) \[Rho]^2 (-4 x q1[x] + (-1 + x^2) ...


7

You can try something like this using Factor to help grease the wheels: expr = Sqrt[u^4 + 4 u^6]; PowerExpand[Factor[expr]] (* u^2 Sqrt[1 + 4 u^2] *) I think this will work in any of your cases. expr = Sqrt[u^6 + 4 u^9] PowerExpand[Factor[expr]] (* u^3 Sqrt[1 + 4 u^3] *)


1

As a place to start I suggest TransformationFunctions: FullSimplify[expr1, TransformationFunctions -> {Automatic, schId, sortarg}] 0 This works even if both sortarg and schId are defined with /. rather than //.. For more manual application consider MapAt. Also familiarize yourself with levelspec.



Top 50 recent answers are included