diy – Where can I get replacement part signal pins for a Nikon Nikkor AF-P lens?

When I try to replace a bayonet mount on my Nikkor AF-P 70-300mm lens, I inadvertently lost one of the 8 signal pins (CPU contact). Is there a source where I can just get a signal pin (or assignment)?

Any help would be greatly appreciated.

Annotation of variables in replacement rules

How to decorate or annotate a variable in a replacement rule?

for example

{(e((-X + Y)^2 || f))} //. {e((-a_ + b_)^2 || f) -> (-a + b)^2}

Ideally would come back:

(-lagXdt + lagYdt) ^ 2

Update:
What follows does not come back lagXdt and lagYdt but rather lagadt and lagbdt:

{(e((-X + Y)^2 || f))} //. {e((-a_ + b_)^2 || 
     f) -> (-Symbol("lag" <> ToString@a <> "dt") + 
      Symbol("lag" <> ToString@b <> "dt"))^2}

Sublime Text 3: How to Create a Reusable Custom Search and Replacement

I'm trying to see if there is a way to replicate a feature in Sublime available in Dreamweaver. With Dreamweaver, you can create custom commands using a javascript file for the actual command and an associated HTML file for the pop-up window, which asks you if you want to execute the command after selecting it in the menu Order. All of mine are files that perform searches and replacements consecutively, which saves me a lot of time.

I wonder if there is a similar function in which I can create a javascript file that I can execute from Sublime to search and replace several elements one after the other.

Where can you buy replacement lens caps for a Canon DSLR?

You should be able to get a lens cap in any local camera store or easily buy one online.

For the majority of lenses, you only need to know the diameter in millimeters of the filter wire. This would be marked with a "ø", ie "ø52" would indicate a 52 mm filter thread and you will simply need a 52 mm lens cap. It is not necessary that it be a Canon lens cap.

The only exception (as far as I know) relates to the ultra-wide-angle lenses and fisheye lenses with a protruding front element (the lens protrudes the body from the lens) – but I feel that it's a good thing. it is unlikely that an EOS 1000 on occasion will be equipped with such an objective.

replacement – ReplaceRepeated multi-part pattern

As always with a replacement problem, examine the FullForm of your expressions. Here is your expression:

expr = (2-2 NormCDF(((-2 e+s^2) t-2 Log(A)+2 Log(K))/(2 s Sqrt(t))));
expr //FullForm

Plus (2, Times (-2, NormCDF (Times (Rational (1,2), Power, 1), Power (s, -1), Power (t, Rational (-1,2)), Plus (Times (More (Times (- 2, e), power (s, 2)), t), time (-2, log (A)), time (2, log (K)))))))

And here is your rule:

rule = n_-n_ NormCDF(x___);
rule //FullForm

More (Pattern (n, Blank ()), Times (-1, NormCDF (Pattern (x, BlankNullSequence ())), Pattern (n, Blank ()))

Notice how the product in your expression is of the form:

Times(-2, _NormCDF)

and your replacement rule uses:

Times(-1, _NormCDF, n_)

Since they do not match, no replacement occurs. An alternative that will work is:

expr /. n_ + m_ NormCDF(x_) /; n+m==0 :> n NormCDF(-x)

2 NormCDF (- (((- 2 e + s ^ 2) t – 2 Log (A) + 2 Log (K)) / (2 s Sqrt (t))))

Rule Replacement Fails with Embedded Conditional

I used a rule replacement that creates a matrix. To one rule, I added a condition to return a vector, then this one (after the condition and in the same replacement) to another. This gives an error, whereas if I put the addition in the conditional, it does what I expect. Since I have the workaround, this is not an urgent problem, but it has taken me some time to figure out how to solve this problem. There is something to do with a subtlety of replacement rules that I do not understand. Can I find out what makes the first version fail?

ClearAll(l1, l2, l3, l4, l5);
SeedRandom(20);
l1 = RandomReal({0.01, 0.05}, 10);
l2 = RandomReal({0.001, 0.005}, 10);
l3 = RandomReal({0.0001, 0.0005}, 10);
l4 = RandomReal({0.00001, 0.00005}, 10);
l5 = RandomReal({0.00001, 0.00005}, 10);
Tuples(Join({0, .1}, {1, 2}), 2) /. {
  {0, 0} -> l1,
  {0, a_} /; a != 0 -> If(a != .1, (l2/a), l3) + l4 ,
  {a_, 0} /; a != 0 -> If(a != .1, l2, l3),
  {a_, b_} /; (a != 0) && (b != 0) -> If(b != .1, (l2/b), l5)
  }

Incorrect result (note the extra layer in the list after the first list):
(* {0.0346891, 0.042335, 0.0139251, 0.0372237, 0.0482159, 0.0369557,
0.0142226, 0.0386726, 0.0308678,
0.0381804}, {{0.000305425, 0.000521417, 0.000460095, 0.000402933,
0.000349666, 0.000203166, 0.000462641, 0.000499664, 0.000210436,
0.000213133}, {0.000297734, 0.000513725, 0.000452403, 0.000395241,
0.000341974, 0.000195474, 0.00045495, 0.000491972, 0.000202745,
0.000205441}, {0.000287534, 0.000503525, 0.000442203, 0.000385041,
0.000331774, 0.000185274, 0.00044475, 0.000481772, 0.000192545,
0.000195241}, {0.000316639, 0.00053263, 0.000471309, 0.000414146,
0.00036088, 0.000214379, 0.000473855, 0.000510877, 0.00022165,
0.000224346}, {0.000287595, 0.000503587, 0.000442265, 0.000385103,
0.000331836, 0.000185336, 0.000444811, 0.000481834, 0.000192606,
0.000195303}, {0.000318435, 0.000534427, 0.000473105, 0.000415943,
0.000362676, 0.000216176, 0.000475652, 0.000512674, 0.000223447,
0.000226143}, {0.000294051, 0.000510042, 0.000448721, 0.000391558,
0.000338291, 0.000191791, 0.000451267, 0.000488289, 0.000199062,
0.000201758}, {0.000309041, 0.000525032, 0.000463711, 0.000406548,
0.000353282, 0.000206782, 0.000466257, 0.00050328, 0.000214052,
0.000216748}, {0.000302288, 0.00051828, 0.000456958, 0.000399796,
0.000346529, 0.000200029, 0.000459505, 0.000496527, 0.0002073,
0.000209996}, {0.000288887, 0.000504879, 0.000443557, 0.000386395,
0.000333128, 0.000186628, 0.000446104, 0.000483126, 0.000193899,
0.000196595}}, {{0.0045267, 0.00483969, 0.00452058, 0.00501934,
0.00215483, 0.00274077, 0.002371, 0.0031683, 0.00263791,
0.00301823}, {0.00451901, 0.004832, 0.00451289, 0.00501164,
0.00214714, 0.00273308, 0.00236331, 0.00316061, 0.00263022,
0.00301054}, {0.00450881, 0.0048218, 0.00450269, 0.00500144,
0.00213694, 0.00272288, 0.00235311, 0.00315041, 0.00262002,
0.00300034}, {0.00453792, 0.00485091, 0.00453179, 0.00503055,
0.00216604, 0.00275199, 0.00238222, 0.00317951, 0.00264913,
0.00302944}, {0.00450887, 0.00482186, 0.00450275, 0.00500151,
0.002137, 0.00272294, 0.00235317, 0.00315047, 0.00262008,
0.003 0004}, {0.00453971, 0.0048527, 0.00453359, 0.00503235,
0.00216784, 0.00275378, 0.00238401, 0.00318131, 0.00265092,
0.00303124}, {0.00451533, 0.00482832, 0.00450921, 0.00500796,
0.00214345, 0.0027294, 0.00235963, 0.00315692, 0.00262654,
0.00300685}, {0.00453032, 0.00484331, 0.0045242, 0.00502295,
0.00215844, 0.00274439, 0.00237462, 0.00317191, 0.00264153,
0.00302184}, {0.00452357, 0.00483656, 0.00451744, 0.0050162,
0.00215169, 0.00273764, 0.00236787, 0.00316516, 0.00263478,
0.00301509}, {0.00451017, 0.00482315, 0.00450404, 0.0050028,
0.00213829, 0.00272424, 0.00235446, 0.00315176, 0.00262138,
0.00300169}}, {{0.00227743, 0.00243393, 0.00227437, 0.00252375,
0.0010915, 0.00138447, 0.00119958, 0.00159823, 0.00133304,
0.0015232}, {0.00226974, 0.00242624, 0.00226668, 0.00251606,
0.0010838, 0.00137678, 0.00119189, 0.00159054, 0.00132535,
0.0015155}, {0.00225954, 0.00241604, 0.00225648, 0.00250586,
0.0010736, 0.00136658, 0.00118169, 0.00158034, 0.00131515,
0.0015053}, {0.00228865, 0.00244514, 0.00228558, 0.00253496,
0.00110271, 0.00139568, 0.0012108, 0.00160944, 0.00134425,
0.00153441}, {0.0022596, 0.0024161, 0.00225654, 0.00250592,
0.00107367, 0.00136664, 0.00118175, 0.0015804, 0.00131521,
0.00150537}, {0.00229044, 0.00244694, 0.00228738, 0.00253676,
0.00110451, 0.00139748, 0.00121259, 0.00161124, 0.00134605,
0.00153621}, {0.00226606, 0.00242255, 0.002263, 0.00251237,
0.00108012, 0.00137309, 0.00118821, 0.00158685, 0.00132166,
0.00151182}, {0.00228105, 0.00243754, 0.00227799, 0.00252736,
0.00109511, 0.00138808, 0.0012032, 0.00160185, 0.00133665,
0.00152681}, {0.0022743, 0.00243079, 0.00227123, 0.00252061,
0.00108836, 0.00138133, 0.00119645, 0.00159509, 0.0013299,
0.00152006}, {0.00226089, 0.00241739, 0.00225783, 0.00250721,
0.00107496, 0.00136793, 0.00118304, 0.00158169, 0.0013165,
0.00150666}}, {0.000277264, 0.000493255, 0.000431934, 0.000374771,
0.000321505, 0.000175004, 0.00043448, 0.000471502, 0.000182275,
0.000184971}, {0.0000361249, 0.0000377894, 0.0000206777,
0.0000428898, 0.0000111111, 0.0000444345, 0.000028785, 0.0000141051,
0.0000396807, 0.0000405228}, {0.00449854, 0.00481153, 0.00449242,
0.00499117, 0.00212667, 0.00271261, 0.00234284, 0.00314014,
0.00260975, 0.00299007}, {0.00224927, 0.00240577, 0.00224621,
0.00249559, 0.00106333, 0.00135631, 0.00117142, 0.00157007,
0.00130488, 0.00149503}, {0.00449854, 0.00481153, 0.00449242,
0.00499117, 0.00212667, 0.00271261, 0.00234284, 0.00314014,
0.00260975, 0.00299007}, {0.0000361249, 0.0000377894, 0.0000206777,
0.0000428898, 0.0000111111, 0.0000444345, 0.000028785, 0.0000141051,
0.0000396807, 0.0000405228}, {0.00449854, 0.00481153, 0.00449242,
0.00499117, 0.00212667, 0.00271261, 0.00234284, 0.00314014,
0.00260975, 0.00299007}, {0.00224927, 0.00240577, 0.00224621,
0.00249559, 0.00106333, 0.00135631, 0.00117142, 0.00157007,
0.00130488, 0.00149503}, {0.00449854, 0.00481153, 0.00449242,
0.00499117, 0.00212667, 0.00271261, 0.00234284, 0.00314014,
0.00260975, 0.00299007}, {0.0000361249, 0.0000377894, 0.0000206777,
0.0000428898, 0.0000111111, 0.0000444345, 0.000028785, 0.0000141051,
0.0000396807, 0.0000405228}, {0.00449854, 0.00481153, 0.00449242,
0.00499117, 0.00212667, 0.00271261, 0.00234284, 0.00314014,
0.00260975, 0.00299007}, {0.00224927, 0.00240577, 0.00224621,
0.00249559, 0.00106333, 0.00135631, 0.00117142, 0.00157007,
0.00130488, 0.00149503}}
*)

Replace the addition outside the conditional inside the conditional:

Tuples(Join({0, .1}, {1, 2}), 2) /. {
  {0, 0} -> l1,
  {0, a_} /; a != 0 -> If(a != .1, (l2/a) + l4, l3 + l4),
  {a_, 0} /; a != 0 -> If(a != .1, l2, l3),
  {a_, b_} /; (a != 0) && (b != 0) -> If(b != .1, (l2/b), l5)
  }

Give the expected result:
(* {0.0346891, 0.042335, 0.0139251, 0.0372237, 0.0482159, 0.0369557,
0.0142226, 0.0386726, 0.0308678, 0.0381804}, {0.000305425,
0.000513725, 0.000442203, 0.000414146, 0.000331836, 0.000216176,
0.000451267, 0.00050328, 0.0002073, 0.000196595}, {0.0045267,
0.004832, 0.00450269, 0.00503055, 0.002137, 0.00275378, 0.00235963,
0.00317191, 0.00263478, 0.00300169}, {0.00227743, 0.00242624,
0.00225648, 0.00253496, 0.00107367, 0.00139748, 0.00118821,
0.00160185, 0.0013299, 0.00150666}, {0.000277264, 0.000493255,
0.000431934, 0.000374771, 0.000321505, 0.000175004, 0.00043448,
0.000471502, 0.000182275, 0.000184971}, {0.0000361249, 0.0000377894,
0.0000206777, 0.0000428898, 0.0000111111, 0.0000444345,
0.000028785, 0.0000141051, 0.0000396807, 0.0000405228}, {0.00449854,
0.00481153, 0.00449242, 0.00499117, 0.00212667, 0.00271261,
0.00234284, 0.00314014, 0.00260975, 0.00299007}, {0.00224927,
0.00240577, 0.00224621, 0.00249559, 0.00106333, 0.00135631,
0.00117142, 0.00157007, 0.00130488, 0.00149503}, {0.00449854,
0.00481153, 0.00449242, 0.00499117, 0.00212667, 0.00271261,
0.00234284, 0.00314014, 0.00260975, 0.00299007}, {0.0000361249,
0.0000377894, 0.0000206777, 0.0000428898, 0.0000111111,
0.0000444345, 0.000028785, 0.0000141051, 0.0000396807,
0.0000405228}, {0.00449854, 0.00481153, 0.00449242, 0.00499117,
0.00212667, 0.00271261, 0.00234284, 0.00314014, 0.00260975,
0.00299007}, {0.00224927, 0.00240577, 0.00224621, 0.00249559,
0.00106333, 0.00135631, 0.00117142, 0.00157007, 0.00130488,
0.00149503}, {0.00449854, 0.00481153, 0.00449242, 0.00499117,
0.00212667, 0.00271261, 0.00234284, 0.00314014, 0.00260975,
0.00299007}, {0.0000361249, 0.0000377894, 0.0000206777,
0.0000428898, 0.0000111111, 0.0000444345, 0.000028785, 0.0000141051,
0.0000396807, 0.0000405228}, {0.00449854, 0.00481153, 0.00449242,
0.00499117, 0.00212667, 0.00271261, 0.00234284, 0.00314014,
0.00260975, 0.00299007}, {0.00224927, 0.00240577, 0.00224621,
0.00249559, 0.00106333, 0.00135631, 0.00117142, 0.00157007,
0.00130488, 0.00149503}}
*)

replacement – Replace Expressions – Mathematica Stack Exchange

Consider the following example

Rd0 = Sqrt(R^2 + (a + Sqrt(h^2 + z^2))^2);
Rn0 = Sqrt(R^2 + z^2) - rs;

Vd = -Md/Rd0;
Vn = -Mn/Rn0;

Veff = Vd + Vn + Lz^2/(2*R^2);

VR = D(Veff, R);

L & # 39; Expression VR given

-(Lz^2/R^3)+(Mn R)/(Sqrt(R^2+z^2) (-rs+Sqrt(R^2+z^2))^2)+(Md R)/
 (R^2+(a+Sqrt(h^2+z^2))^2)^(3/2)

Now, I want to replace some expressions, using the rule

rule = {Sqrt(h^2 + z^2) -> Rdz; Sqrt(R^2 + z^2) -> Rcn, 
          (R^2 + (a + Sqrt(h^2 + z^2))^2)^(3/2) -> Rd^3};

However, when I apply it as VR /. rule1 I receive

-(Lz^2/R^3)+(Mn R)/((Rcn-rs)^2 Sqrt(R^2+z^2))+(Md R)/
 (R^2+(a+Sqrt(h^2+z^2))^2)^(3/2)

As can be seen, only one of the terms has been replaced, all the others have not been replaced. So my question is: how can I replay all expressions effectively in accordance with the rule above?

Replacement for GoDaddy hosting? | Talk Web Hosting

Hi!

I manage multiple websites for a small business and we have recently been burned by godaddy.com web hosting. When we tried to upgrade our account, they suspended our web hosting and all our sites were left out. Their customer service was awful, their representatives do not have permission to write to the accounts and can only provide links to basic help files, in addition to taking half an hour to get back to your question , on LIVE CHAT !!!

So my question is: who would you recommend to host Web for multiple wordpress sites (PHP / mySQL based) with the correct support and decent disk / processor support?

We can not afford to see our hosting abandoned again without even a phone call or email.

Please, let me know!

replacement – TagSetDelayed to locate zero derivatives

I'm trying to set up my own differential operator, d(arg_, var_),
which calculates the derivative of arg w.r.t. var.
Now, I have to "teach" MMA the key properties of this operator.
In particular, I want it to remove all derivatives obviously void because arg is independent of var.
My attempt is as follows

Clear(d);
d /: d(arg_, var_) := 0 /; (SameQ(D(arg, var), 0));

At first this rule seemed to work well, because I had to

d(x,x)
   ---> d(x,x)
d(x,y)
   ---> 0 

However, if I know how to cumulate the derivatives, the rule seems to be badly applied.
Indeed, I had

d(d(x+y,x),y)
   ---> 0

which is incorrect.

To search for the origin of this strange behavior, I modified the previous rule to also display its arguments during its application. As such

Clear(d);
d /: d(arg_, var_) := (Print("| ",arg, " | ", var); 0) /; (SameQ(D(arg, var), 0));

For the same test as before

d(d(x+y,x),y)
   ---> | #1 | #2
        | d(x+y,x) | y
        0

So it seems that the rule is used once with pure arguments {#1,#2}, which is probably the reason for the bug encountered.

Where does this strange assessment come from?
And how should we repair the TagSetDelayed for the rule to be correctly applied?