1:39 AM
The difference above in the values of `Sin[]` has to do with a difference in how the values are computed when vectorized and not vectorized. Here's a single instance:
```t1 = N[t0 = 1880891293519271/2251799813685248];
s1 = SetPrecision[Sin@t1, Infinity];
s2 = SetPrecision[First@Sin@ConstantArray[t1, 257], Infinity];
s1 - Sin[t0] // N[#, 16] &
s2 - Sin[t0] // N[#, 16] &

(*  5.567563500914014*10^-17
-5.534666745337552*10^-17  *)```
The fraction `t0` is the exact representation of the binary fraction for the floating-point `t1`.
The vectorized result `s2` is slightly better than the singleton-computed `s1`. For most inputs to `Sin[]`, the two values are bitwise identical.
The magic number `257` comes from:
```SystemOptions["ParallelOptions"]

{"ParallelOptions" -> {..., "VectorArithmeticThresholds" -> {{256, 2147483647}, {256,
2147483647}, {256, 2147483647}}}}```
I don't know what the numbers represent, but if you change the second `256`, you change the threshold needed for the length of `ConstantArray` in the example.

5 hours later…
6:42 AM
1

Warning: This is just some basic analysis that I thought people might find cute. If you want me to delete it / change the title to free up an objectively good question title, I'm happy to do so. Obviously Mathematica.SE is all about the points and no one is going to spend 2 days helping someo...

3 hours later…
10:12 AM
Here's a tip for people on OS X with multiple versions of Mma installed: You can save 40%+ disk space by compressing the app using `afsctool`. I have been doing this for quite a while, and noticed no problems so far. I don't know if it will blow up things when we upgrade to OS X 10.13 with APFS at the end of the year, though.
3

3 hours later…
12:53 PM
Hi, guys. Could you help me a little with a list construction problem? Let's say I have a list A={a,b,c,d,e} and for some elements with positions stored in another list indx={1,3,5} I want to insert additional sublists from list B={{K,13},{E,15},{F,16}}. Final list should look like {{a,{K,13}},{b},{c,{E,15}},{d},{e,{F,16}}}. Any hints?

1:23 PM
@Mr.Eight It can be done like this: MapThread[List, {A[[indx]], B}]

Mathematica can use "opencv"?

1 hour later…
2:32 PM
@C.E. Yours omits the b and d, yes? @Mr.Eight Maybe Fold[#2[#] &, List /@ A, MapAt[Append[#2], #] & @@@ Thread[{indx, B}]]
@yode I would guess J/Link is the easiest way to use opencv from Mathematica.
@Mr.Eight I like this one more ReplacePart[List /@ A, MapThread[{#} -> {A[[#]], #2} &, {indx, B}]]

Thank you very much, indeed C. E.'s answer omits b and d, while both your works well.

2 hours later…
4:21 PM
Is this behavior intentional?
```list = {{1, 2, 3}, {4, 5, 6}};
Extract[list, {2, 2 ;; 3}]
Extract[list, {2 ;; 2, 2 ;; 3}]```
```During evaluation of In[1]:= Extract::psl1: Position specification {2,2;;3} in Extract[{{1,2,3},{4,5,6}},{2,2;;3}] is not applicable.
Out[2]= Extract[{{1, 2, 3}, {4, 5, 6}}, {2, 2 ;; 3}]
Out[3]= {{5, 6}}```

2 hours later…
5:59 PM
posted on August 02, 2017 by Stephen Wolfram

The Summer Camp Was a Success! How far can one get in teaching computational thinking to high-school students in two weeks? Judging by the results of this year’s Wolfram High-School Summer Camp the answer is: remarkably far. I’ve been increasingly realizing what an immense and unique opportunity there now is to teach computational thinking with [...]

2 hours later…
7:46 PM
Hello to all
Does anyone know if it's 'safe' to change the limit of the machine precision with which MAthematica does its computations?

8:12 PM