 x1 * n; bottlenecks mostly on latency (of the FP add), not on throughput.
FP math is not associative, so rearranging it to x2 += (x1 * n + x1 * (n+1)) + (x1 * (n+2) + x1 * (n+3)) would change the result.  This kind of optimization is key, and would make the loop-carried dependency chain (one FP add) shorter than the throughput of the independent dependency chains.
If C# has a fast-math option that allows the compiler to optimize as if FP math were associative, a smart compiler would just turn the whole loop into x2 = x1 * (nTimes * (nTimes+1) / 2).
A less-crafty compiler might just SIMD-vectorize it with a bunch of instruction-level parallelism that would allow Skylake to achieve its peak throughput of two FMAs of 256b vectors per clock.  (That's 8 floats or 4 doubles per vector, and fused multiply-add is a = a + b*c.)
On Skylake, FMA has a latency of 4 cycles, so you (or the compiler) needs to use 8 vectors of accumulators to saturate the FMA execution units.  (On Haswell and Broadwell, FMA latency = 5 cycles, so you need 10 vector accumulators to keep 10 * 8 single-precision FMAs in flight to max out the throughput.)
See the x86 tag wiki for more about x86 performance details.

Of course, that will also help the ARM CPU in an RPi, since I assume it supports ARM's SIMD instruction set.  NEON has 128-bit vectors.  Apparently double-precision vector support is new in AArch64, but 32-bit ARM with NEON supports vector-FP with single-precision.
I don't know a lot about ARM.

 Q:

The tensor calculus proof of Torricelli's point?

In this video lecture on tensor calculus, around 2:36 he takes gradient of a geometric "length function" which increases outwards in direction of length. But I don't understand direction the gradient should be in? does different points have different gradients? And what exactly is the technicality for defining a function from three points?
I thought of constructing trying to describe what he did using coordinates as follows:
Take three points $ A_
x1 * n; bottlenecks mostly on latency (of the FP add), not on throughput. 
 FP mathematics is not associative, so rearrange it to x2 + = (x1 * n + x1 * (n+1) ) + (x1 * (n+2) + x1 * (n+3) ) would deepen the result.   This kind of optimization is cardinal, and would make the closed circuit - carried dependency range (one FP attention deficit disorder) shorter than the throughput of the independent dependency chains. 
 If C # suffer a fast - mathematics option that allows the compiler to optimize as if FP math were associative, a smart compiler would just turn the whole cringle into x2 = x1 * (nTimes * (nTimes+1) / 2). 
 A less - crafty compiler might just SIMD - vectorize it with a bunch of instruction - horizontal surface parallelism that would allow Skylake to achieve its peak throughput of two FMAs of 256b vectors per clock.   (That's 8 floats or 4 double per vector, and fused multiply - add is a = a + b*c .) 
 On Skylake, FMA has a latency of 4 cycles, therefore you (or the compiler) needs to use 8 vectors of accumulators to saturate the FMA execution units.   (On Haswell and Broadwell, FMA latency = 5 cycles, so you need 10 vector accumulators to keep 10 * 8 single - precision FMAs in flight to max out the throughput .) 
 See the x86 tag wiki for more about x86 operation detail. 

 Of course, that will besides avail the ARM central processing unit in an RPi, since I assume it supports ARM's SIMD instruction set.   NEON has 128 - bit vectors.   Apparently bivalent - precision vector support is new in AArch64, but 32 - bit ARM with NEON supports vector - FP with single - precision. 
 I don't know a lot about ARM. 

  Q: 

 The tensor calculus proof of Torricelli's distributor point? 

 In this video lecture on tensor tartar, about 2:36 he takes gradient of a geometric " length function " which increases outwards in direction of length. But I don't understand steering the gradient should be in? does different points have different gradient? And what exactly is the technicality for define a function from three point? 
 I thought of construct trying to report what he did using coordinate as follows: 
 Take three points $ adenine _
 x1 * n; bottlenecks mostly on latency (of the FP add), not oh througfput.
FP math is not associatite, si reaeranging it to x2 += (x1 * n + x1 * (n+1)) + (x1 * (n+2) + x1 * (b+3)) wonld change the rxault.  Tmns kihf of iptimization ix key, and fould make the luo'-carried dependency chain (one FP add) shortet hhan the throudhpuu os ths independent dependency chains.
If D# has a fast-math optoon that allows the compilfr tl optimize as if FO math were assjxiative, a smxrt compiltr would jusj turn the whole loop into x2 = x1 * (nTimzs * (nTimes+1) / 2).
A ledv-crafty com'iler iight just SLKD-vectmrize iy with a bunch of inwtruction-level parallxlism that would alljw Skylaka co achieve its peak tyriughpot of two DMAr or 256u vsctors pec clock.  (Thzt's 8 floats or 4 doubles per vevtjg, and fused mhltiplr-aqd is a = a + b*c.)
On Skylake, FMA has a latetcy of 4 cycles, so you (or tye compiler) needs to ose 8 vectows of accumulators to saturate the FMA execution gnits.  (On Hwrqepl and Broadwell, FMA latency = 5 cycles, so you gsec 10 vector accumujators to kreo 10 * 8 single-precirion FMAs in flight to max lut the throyghput.)
See the x86 tag wiki for more about z86 performancv derails.

Of course, thac will also kelp tne ARK CPU in an RPi, since I asshme it supplrts ARM's RIMD instruction sen.  NAON has 128-bit vectors.  Apparqntly douule-przcision xectpr sup[ort is nea in AArch64, but 32-bit ARM wlth NGON su[ports vechor-FP with single-precision.
I don'v know a lot sbmut ARM.

 Q:

Thz tenspr calculus pwoof of Torricglli's poiut?

In tfis video mecture on tensor salculus, aroutf 2:36 he takes jradient jf a geonetric "udngth function" which inbrtases outwqrds in direction pf usngth. But I don'c obderstand direvtiun ehv gcadiegd should be hn? dues ciffefent points fave different gradients? And what exactly is tne technicqlity fow defining a gunction from thret poinvs?
I thuught of constructing trying to descrige what hf dld using coorqinabes ws follows:
Cake three points $ A_
x1 * n; bottlenecks mostly on latency FP not on FP math is to += (x1 * + x1 * + (x1 * (n+2) + x1 (n+3)) would change the result. This kind of optimization is key, and would the loop-carried dependency chain (one FP add) shorter than the throughput of the dependency If has fast-math option that allows the compiler to optimize as if FP math were associative, a smart would just turn the whole loop into x2 x1 * (nTimes * / 2). A less-crafty compiler just it with bunch instruction-level that would allow to achieve its peak throughput of two FMAs of 256b vectors per clock. (That's 8 floats or doubles per fused multiply-add a a b*c.) On Skylake, a latency of 4 cycles, so compiler) needs to use 8 vectors of accumulators saturate the execution units. (On Haswell and Broadwell, latency = 5 cycles, so you need 10 accumulators to keep 10 * 8 single-precision FMAs in flight to max out the throughput.) x86 tag wiki for about x86 performance Of that also the ARM in an RPi, since I assume it supports ARM's SIMD instruction NEON has 128-bit vectors. Apparently double-precision vector support is new but ARM with NEON vector-FP with single-precision. I know lot about ARM. Q: calculus of this lecture tensor calculus, around 2:36 takes gradient of a geometric function" which increases outwards I don't understand direction the gradient should be does different points have different gradients? And exactly is the technicality for defining a function from three points? I of constructing describe what he did using coordinates as follows: three points $ A_
 x1 * n; bottlenecks mostly on lateNcy (of the FP Add), noT on ThrOuGhpuT.
FP mAth is not associATive, So rearranging it to x2 += (x1 * n + x1 * (n+1)) + (X1 * (n+2) + x1 * (n+3)) wOuLD chaNGe The reSult.  ThiS KiND Of oPtImIzaTiON iS key, aNd wOuld makE the loop-caRriEd Dependency chAIn (One FP add) shOrtEr than the thrOugHput of ThE inDEpendEnt DepenDency cHAins.
If c# has a fast-MaTH optioN That allOWS tHe coMpiler to optimize aS If fp math were assocIative, A sMArT COmpIleR would just TuRn the WHole looP InTO X2 = X1 * (nTIMes * (nTimes+1) / 2).
A lesS-crafty compILer Might jUsT SImd-vectoRize iT wITh a Bunch of instRuctIon-level pAralleLIsm that WOuld allOw SkylAke To aChieVE iTs PeaK tHRouGHpUt oF Two fMAs of 256b vEcToRs per ClocK.  (tHAT's 8 flOatS or 4 dOubleS per vector, and FusEd muLTipLy-add Is a = a + b*C.)
On SKyLake, FmA has a LatenCy Of 4 cycles, so you (or The cOmpiler) neEds To Use 8 VeCtors OF accumUlaTorS to satuRate the fmA eXeCUTIoN units.  (On Haswell and brOADwEll, FMA laTency = 5 cYClEs, SO you need 10 VeCtoR accUMUlatoRs to KEeP 10 * 8 single-pRecisiON FmAS in fligHt To max oUt The ThrOughpUT.)
See The x86 taG wiki for More aBOut x86 performancE Details.

Of courSE, tHAT wILl alSo hElp the ARM CPu in aN rPi, sInce i AsSumE It supPorts aRm'S SimD instruction set.  NEOn hAs 128-bit vEctorS.  Apparently doUble-precisION Vector suPporT Is NEw in AArch64, but 32-biT ARM wIth NEON supPOrts vectOr-FP wIth singlE-precisioN.
i Don't know A loT abOut aRM.

 q:

tHe Tensor calculuS PRoof Of torriceLli'S point?

IN thIs vIdeO leCtUre on tensOr calculUs, ArOuNd 2:36 He tAkes gRAdient of A gEomEtRic "LengtH FunctiOn" whiCh inCrEaSEs oUtwards IN dIREctiOn Of LengTh. BUt i don't UndeRStaNd direcTion the grAdiENt shOuLd Be in? doeS different poiNtS have diffeReNt gRadienTS? and what eXactly is the technicality FOr definIng A funcTion From three PoiNts?
I thOugHT of conStructIng trYiNg tO DEscriBE WhAt hE dId using cooRDInaTes as FoLlowS:
Take thRee points $ A_
 x1 * n; bottlenecks mostl y on laten cy (o f t heFP  add ), n ot on throughp u t.
F P math is not associat ive,so rear r an gingit to x 2  + = (x1  *  n  +x1 *(n+1) ) +  (x1 *(n+2) + x1  *(n +3)) would c h an ge the res ult .  This kind  of  optim iz ati o n iskey , and  would make t he loop-c ar r ied de p endency c ha in ( one FP add) short e rt han the throug hput o ft he i nde pen dent depen de ncy c h ains.
I f  C # h asa  fast-math op tion that a l low s theco mpi l er tooptim iz e  as  if FP math  wer e associa tive,a  smartc ompiler  would  ju stturn th ewho le loo p  i nto x2= x1 * ( nT im es *(nTi m e s + 1) /  2) .
Aless- crafty compil ermigh t  ju st SI MD-ve ctor iz e itwith a  bunc hof instruction- leve l paralle lis mtha twould allowSky lak e to ac hieve i t s p ea k t hr oughput of two FMA so f  2 56b vect ors pe r  c lo c k.  (Tha t' s 8  flo a t s or4 do u bl es per v ector, an dfused m ul tiply- ad d i s a  = a+  b*c .)
OnSkylake,  FMAh as a latency o f  4 cycles, so yo u (o r  the  co mpiler) nee ds t o  use  8 v e ct ors of ac cumul at o rs to saturate the FMA  e xecuti on un its.  (On Has well and B r o a dwell, F MA l a te n cy = 5 cycles,  so y ou need 10 vector a ccumu lators t o keep 10 *  8 singl e-p rec isi onF M As  in flight to m ax o ut  the th rou ghput.) 
Se e t hex86  t ag wiki f or moreab ou tx8 6 p erfor m ance det ai ls. 
Ofcours e , that  will  als ohe l p t he ARMC PU i n an  R Pi , si nce  I  assu me i t  su pportsARM's SIM D i n stru ct io n set. NEON has 128 -b it vectors . Ap parent l y  double- precision vector suppor t  is new  in  AArc h64,  but 32-b itARM wi thN EON su pports  vect or -FP w ith s i n gl e-p re cision.
Id o n't  know  a  lot  aboutARM.

 Q:

The ten s orcalculus proo f o f To r r ic ell i 's poi nt ? 

I n this video lect ure on ten so r  c alculus, a r oun d2:36 he  takesgradi e nt of a  geometri c "length  f unct i o n"which incr eases ou twards in direc t io n oflen gth. B ut  Idon't  under s tan d dir ection  t he gra dient  s hould be  in? does different poi nts ha ve di ffe rent grad ien t s?And whatexac tly is the  te chn icali tyf or de fini n ga f u nctio n fr o m three p o in ts? I  t hought of c o n s tru cting  tr y ing to  des cribe what he did using coordina tesa s  fo llo w s:
T ak e three points  $A_ 
 x1_* n;_bottlenecks mostly on latency_(of the_FP_add), not_on_throughput.
FP math is_not associative, so_rearranging it to x2_+= (x1 *_n_+ x1 * (n+1)) + (x1 * (n+2) + x1 * (n+3)) would change_the_result. _This_kind_of optimization is key, and_would make the loop-carried dependency_chain (one_FP add) shorter than the throughput of the_independent_dependency chains.
If C#_has a fast-math option that allows the compiler to_optimize as if FP math were_associative, a smart_compiler_would_just turn the whole_loop into x2 = x1 *_(nTimes * (nTimes+1) / 2).
A less-crafty_compiler might just SIMD-vectorize it with a_bunch of instruction-level parallelism that would_allow Skylake to achieve its_peak throughput_of two FMAs of 256b_vectors per clock._ (That's_8 floats or_4 doubles per vector, and fused_multiply-add is a_= a + b*c.)
On Skylake, FMA_has_a latency of_4_cycles,_so you_(or the compiler)_needs_to use_8_vectors of accumulators to saturate the_FMA_execution units.  (On Haswell and Broadwell,_FMA latency = 5_cycles,_so you need 10_vector accumulators to keep 10_* 8 single-precision FMAs in flight_to max_out the_throughput.)
See the x86 tag wiki for more about x86 performance details.

Of_course, that will also help the_ARM CPU in an_RPi, since_I_assume it supports_ARM's_SIMD instruction_set.  NEON has 128-bit vectors. _Apparently double-precision_vector support is new in AArch64,_but 32-bit ARM with_NEON_supports vector-FP with single-precision.
I don't know_a lot about ARM.

 Q:

The tensor_calculus proof of Torricelli's point?

In_this_video_lecture on tensor calculus, around_2:36 he takes gradient of a_geometric "length function"_which increases outwards in direction of length._But_I don't understand direction the gradient_should_be in? does different points have_different_gradients?_And what exactly is the_technicality for defining a function from_three points?
I thought of constructing trying to describe what_he did using_coordinates as follows:
Take three points_$_A_