## Hide OOTB web parts – SharePoint Stack Exchange

Environment: SharePoint 2019 – Modern

On my SharePoint team site, I want to use only a few OOTB web elements and would like to hide other OOTB web elements from the web part list.

It is only to prevent users from trying to put many different web elements on the pages. The attached image illustrates what I want if it is possible to do, for example, hide the web elements in red.

Best,
Haystack.

## shaders: project grid textures to select parts of the terrain (Unity)

So I am trying to be smart and not use more than 500 prefabricated mosaics to make a grid, and so far the background part has worked perfectly. Initially I used a dedicated mesh to represent the grid, but since I am now opting for 3D terrain (and not mosaic mapping), I thought there were many unnecessary vertices, especially if I want the grid to fit the terrain.

Using FE as inspiration, I am thinking of projecting the texture of a transparent grid on a base terrain layer.

• If I wanted some parts of the terrain not to be covered by the grid (like the water area in the image), would I simply use the world coordinates to tell the shader to do nothing there?

However, the most confusing part for me is how to highlight the mosaics. I want the movement and attack tiles to be painted & # 39; painted & # 39; on the ground in specific colors, but obviously they only affect an even smaller portion than the terrain than the grid.

• Would you simply be using the same shader to take world coordinates once more and more or less start / stop overlapping the texture of movement / attack on the grid / terrain? And if I'm really being efficient, do those textures belong to the same PNG and I only use UV to switch between them like a sprite sheet?

• Is this a good practice for shaders in the first place? Redraw and add textures only to parts of a material? Should I redraw and update all the texture in its place?

I guess they discard me because I'm only familiar with a 1: 1 mesh design, so the idea of ​​a single mesh but multiple textures in discrete parts that can overlap or make no sense on the paper. but the implementation in Unity is just above my ATM.

Thank you!

## February 2020: server parts price report

This is the second installment of the monthly server price report for 2020.

If you have been following, we have been following the changes in the prices of the parts for RAM, SSD, hard drives, CPUs and a pair of GPUs. Usually, this is done monthly and then shared with WHT and on our blog.

Currently, all prices indicated are from eBay, for used hardware. I can also start tracking more new hardware if there is a demand.

Prices as of February 13, 2020

– or + indicates if the price has gone up or down since last month

Code:

```Price Low* / Price High** / Part Name

SSDs

\$63(-) / \$110() / 480gb Intel DC S3500
\$100(-) / \$170(-) / 800gb Intel DC S3500
\$250() / \$290() / 1.6TB Intel DC S3500

New SSDs

\$125(-) / \$160() / 240gb Intel D3-S4610
\$180(-) / \$250() / 480gb Intel D3-S4610
\$600() / \$600() / 960gb Intel D3-S4610
\$678(+) / \$803(-) / 1.92tb Intel D3-S4610
\$1099() / \$1099() / 3.84tb Intel D3-S4610

Hard Drives

\$38(-) / \$50() / 3TB HGST SATA
\$160() / \$175() / 8TB HGST SATA
\$190() / \$220() / 10TB HGST SATA
\$299() / \$325(-) / 12TB HGST SATA

DDR3 RAM

\$10() / \$15() / 8GB DDR3 (a)
\$12(-) / \$25(-) / 8GB DDR3 (b)
\$25() / \$40() / 16GB DDR3 (a)
\$25(+) / \$32(+) / 16GB DDR3 (b)
\$68() / \$105() / 32GB DDR3 (c)

DDR4 RAM

\$25() / \$35() / 8GB DDR4 (d)
\$35() / \$115() / 8GB DDR4 (e)
\$69(+) / \$99(+) / 8GB DDR4 (f)
\$37() / \$60() / 16GB DDR4 (d)
\$50(+) / \$99(+) / 16GB DDR4 (e)
\$80(+) / \$155(+) / 16GB DDR4 (f)
\$79() / \$105() / 32GB DDR4 (d)
\$90(+) / \$145(-) / 32GB DDR4 (e)
\$110() / \$155() / 32GB DDR4 (f)

E5v2 CPUs

\$90(-) / \$140(-) / E5-2660v2
\$140(-) / \$170() / E5-2680v2
\$165(-) / \$200(-) / E5-2697v2

***********************

E5v3 CPUs

\$90() / \$150() / E5-2650v3
\$100(-) / \$140(-) / E5-2660v3
\$125(-) / \$150(-) / E5-2670v3
\$160(-) / \$192(+) / E5-2680v3
\$199(+) / \$215() / E5-2690v3
\$285(-) / \$375(+) / E5-2695v3
\$605(+) / \$975(+) / E5-2698v3
\$699(+) / \$995() / E5-2699v3

E5v4 CPUs

\$865(-) / \$1050(-) / E5-2650v4
\$1050(-) / \$1495() / E5-2660v4
\$435(-) / \$650() / E5-2680v4
\$1347(-) / \$1995(-) / E5-2690v4
\$2375(-) / \$3745(-) / E5-2699v4

Graphics Cards

\$425() / \$475() / Nvidia GTX 1080Ti
\$290() / \$325() / Nvidia GTX 1080
\$275() / \$350(+) / AMD Vega 64```

To compare with last month, here are the prices of January 13, 2020:

Code:

```Price Low* / Price High** / Part Name

SSDs

\$80(+) / \$110(+) / 480gb Intel DC S3500
\$110(+) / \$175(+) / 800gb Intel DC S3500
\$250(+) / \$290(+) / 1.6TB Intel DC S3500

New SSDs

\$130(-) / \$160(-) / 240gb Intel D3-S4610
\$200(+) / \$250() / 480gb Intel D3-S4610
\$600(+) / \$600(+) / 960gb Intel D3-S4610
\$560(+) / \$1185(-) / 1.92tb Intel D3-S4610
\$1099(+) / \$1099(+) / 3.84tb Intel D3-S4610

Hard Drives

\$40() / \$50() / 3TB HGST SATA
\$160() / \$175(-) / 8TB HGST SATA
\$190() / \$220(-) / 10TB HGST SATA
\$299() / \$450(-) / 12TB HGST SATA

DDR3 RAM

\$10() / \$15() / 8GB DDR3 (a)
\$15() / \$30() / 8GB DDR3 (b)
\$25() / \$40() / 16GB DDR3 (a)
\$22() / \$30() / 16GB DDR3 (b)
\$68() / \$105() / 32GB DDR3 (c)

DDR4 RAM

\$25(+) / \$35(-) / 8GB DDR4 (d)
\$35(-) / \$115() / 8GB DDR4 (e)
\$30(+) / \$45(+) / 8GB DDR4 (f)
\$37() / \$60() / 16GB DDR4 (d)
\$40(-) / \$90() / 16GB DDR4 (e)
\$70(-) / \$100() / 16GB DDR4 (f)
\$79(-) / \$105(+) / 32GB DDR4 (d)
\$85() / \$150() / 32GB DDR4 (e)
\$110(+) / \$155() / 32GB DDR4 (f)

E5v2 CPUs

\$110(-) / \$150(+) / E5-2660v2
\$142(+) / \$170(+) / E5-2680v2
\$173(-) / \$230(-) / E5-2697v2

***********************

E5v3 CPUs

\$90(+) / \$150(+) / E5-2650v3
\$125() / \$153(-) / E5-2660v3
\$125(-) / \$150(-) / E5-2670v3
\$168(+) / \$185() / E5-2680v3
\$195(-) / \$215(-) / E5-2690v3
\$310(+) / \$350(-) / E5-2695v3
\$520(+) / \$795(+) / E5-2698v3
\$695(+) / \$995(+) / E5-2699v3

E5v4 CPUs

\$1138(+) / \$1395(+) / E5-2650v4
\$1370(+) / \$1495(+) / E5-2660v4
\$499(-) / \$650(-) / E5-2680v4
\$1900(+) / \$2328(+) / E5-2690v4
\$3149(+) / \$4999(+) / E5-2699v4

Graphics Cards

\$425(+) / \$475(+) / Nvidia GTX 1080Ti
\$290(+) / \$325(+) / Nvidia GTX 1080
\$275() / \$325(-) / AMD Vega 64```

* Low price: the lowest price to buy this piece from an accredited seller in a moderate quantity, price sent to the USA. UU.
** High price: There is a reasonably large amount of this part available from multiple vendors accredited for this price or for a price lower than that sent to the US UU.

*** Price for the lowest price unit of this size, which matches this model number or better in the same class. "Same class" would mean sata (S) or nvme (P), as appropriate. "Better" means a higher model number than the listing. Ranked from worst to best, Intel model numbers are 3500, 3510, 3600, 3610, 3700, 3710

(a) – 2Rx4 PC3L-10600R REG ECC
(b) – 2Rx4 PC3L-12800R REG ECC
(c) – 4Rx4 PC3L-12800L ECC REG LRDIMM

(d) DDR4 PC4-2133P ECC registered
(e) DDR4 PC4-2400T ECC registered
(f) DDR4 PC4-2666V ECC registered

(/CODE)

Some notable changes from last month:

* There seems to be a lot of stability at this time in the price of server parts. The prices of RAM, SSD and HDD have remained fairly constant with only small price changes.

* For the most part, there have been very few changes in the price of the CPU, with the exception of a pair of E5v3 and E5v4 models.

* There is still very limited availability of some of the newer SSD models.

As before, let me know if you have any comments, how can I make this more useful, etc.

## Plot: help with ODE has the function in parts in the module

Suppose we have an ODE in the form:

```````f''(r) + (2 f'(r))/r == t Cosh(f(r))+h(r)`, where

h(r_): Piecewise({{t, 0 <= r <= a}, {0, a < r <= 1}})
``````

I am using the Module function

`````` a=0.01;
t=17;
gcd(t0_) := Module({t = t0},sol=ParametricNDSolveValue({f''(r) + (2 f'(r))/r == t Cosh(f(r)) + h(r),
f((Epsilon)) == f0, f'((Epsilon)) == 0}, {f, f'}, {r, (Epsilon),
1}, {f0}, WorkingPrecision -> 40);
FindRoot(sol(f0)(1), {f0, -3})
``````

How could I include the Piecewise function in my Module environment and plot f for different values ​​of `t`?

## calculation and analysis: accelerate integration with Max / Min or by parts

`Integrate` around a convex combination of two functions that contain `Min` or `Max` or `Piecewise` It doesn't end in 5 min. Conversely, `Integrate` it ends in one or two seconds when the argument is a linear function, and similarly when the argument contains a function with `Min` or `Max` or `Piecewise`, and similarly when the argument contains a convex combination of linear functions.
In the following example, the integrals of `d`, `da`, `d1`, `d2` take <2s and the integrals of `d1a`, `d2a` not finish in 5 min.

Am I making a simple mistake or how to accelerate similar integrals of convex combinations of `Piecewise` functions?

MWE:

``````Clear(d, d1, d2, da, d1a, d2a, cdf, pdf, cdf1, pdf1, cdf2, pdf2, s,
vi, vj, vlo, mui, muj, pi, pj, pis, pjs)
\$Assumptions =
Flatten@{Thread(0 < {s, pi, pj, pis, pjs, vlo, vi, vj}), s < 1};
cdf(v_) = v - vlo; pdf(v_) = 1;
cdf1(v_) = Max(0, Min(1, v - vlo)); pdf1(v_) = 1;
cdf2(v_) =
Piecewise({{0, v < vlo}, {v - vlo, vlo <= v <= vlo + 1}, {1,
v > vlo + 1}});
pdf2(v_) =
Piecewise({{0, v < vlo || v > vlo + 1}, {1, vlo <= v <= vlo + 1}});
d(pi_, pj_, s_, pis_) =
Integrate((1 - cdf(Max(pi, vj - pj + pi - s)))*pdf(vj), {vj, vlo,
vlo + 1});
d(0.2, 0.3, 0.1, 0.25) /. {vlo -> 0.1, mui -> 0.4}
da(pi_, pj_, s_, pis_) =
Integrate((mui*(1 - cdf(Max(pi, vj - pj + pi - s))) + (1 - mui)*(1 -
cdf(Max(0, vj - pj) + Max(pi, pis + s))))*pdf(vj), {vj, vlo,
vlo + 1});
da(0.2, 0.3, 0.1, 0.25) /. {vlo -> 0.1, mui -> 0.4}
d1(pi_, pj_, s_, pis_) =
Integrate((1 - cdf1(Max(pi, vj - pj + pi - s)))*pdf1(vj), {vj, vlo,
vlo + 1});
d1(0.2, 0.3, 0.1, 0.25) /. {vlo -> 0.1, mui -> 0.4}
d1a(pi_, pj_, s_, pis_) =
Integrate((mui*(1 - cdf1(Max(pi, vj - pj + pi - s))) + (1 -
mui)*(1 - cdf1(Max(0, vj - pj) + Max(pi, pis + s))))*
pdf1(vj), {vj, vlo, vlo + 1});
d1a(0.2, 0.3, 0.1, 0.25) /. {vlo -> 0.1, mui -> 0.4}
d2(pi_, pj_, s_, pis_) =
Integrate((1 - cdf2(Max(pi, vj - pj + pi - s)))*pdf2(vj), {vj, vlo,
vlo + 1});
d2(0.2, 0.3, 0.1, 0.25) /. {vlo -> 0.1, mui -> 0.4}
d2a(pi_, pj_, s_, pis_) =
Integrate((mui*(1 - cdf2(Max(pi, vj - pj + pi - s))) + (1 -
mui)*(1 - cdf2(Max(0, vj - pj) + Max(pi, pis + s))))*
pdf2(vj), {vj, vlo, vlo + 1});
d2a(0.2, 0.3, 0.1, 0.25) /. {vlo -> 0.1, mui -> 0.4}
``````

The use of Simplify`PWToUnitStep @ does not seem to accelerate integration.

## c # – How to handle the same code parts in Factory Method?

I have classes:

``````public abstract class House{
public string Name {set;get;}
public SomeClass Property1 {set;get;}
public OtherClass Property2 {set;get;}
}

public class WoodenHouse:House{
public string WoodType {set;get;}
public int WoodAge {set;get;}
}

public class StoneHouse:House{
public string StoneType{set;get;}
}
``````

And trying to create the Factory Method for this:

``````    abstract class Creator
{
public abstract HouseInfo Info { get; set; }

public Creator()
{
}

public abstract House FactoryMethod();
}

class WoodenHouseCreator : Creator
{
public override HouseInfo Info { get; set; }

public WoodenHouseCreator(WoodenHouseInfo info)
{
Info = info;
}

public override House FactoryMethod()
{
var info = Info as WoodenHouseInfo;

var woodenHouse = new WoodenHouse();
woodenHouse.Name = info.Name;
woodenHouse.Floors = info.Floors;
woodenHouse.RoofType = info.RoofType;
woodenHouse.WoodType = info.WoodType;
woodenHouse.WoodAge = info.WoodAge;
return woodenHouse;
}
}

class StoneHouseCreator : Creator
{
public override HouseInfo Info { get; set; }

public StoneHouseCreator(StoneHouseInfo info)
{
Info = info;
}

public override House FactoryMethod()
{
var info = Info as StoneHouseInfo;

var stoneHouse = new StoneHouse();
stoneHouse.Name = info.Name;
stoneHouse.Floors = info.Floors;
stoneHouse.RoofType = info.RoofType;
stoneHouse.StoneType = info.StoneType;
return stoneHouse;
}
}
``````

Here are classes that contain information to create a house:

``````    class HouseInfo
{
public string Name { set; get; }
public int Floors { set; get; }
public string RoofType { set; get; }
}

class WoodenHouseInfo : HouseInfo
{
public string WoodType { set; get; }
public int WoodAge { set; get; }
}

class StoneHouseInfo : HouseInfo
{
public string StoneType { set; get; }
}
``````

And use:

``````        var houseInfo = new WoodenHouseInfo{
Name = "HouseName",
Floors = 2,
RoofType = "Triangle",
WoodType = "Pine",
WoodAge = 100
};

House house;

if(houseInfo is WoodenHouseInfo)
{
var creator = new WoodenHouseCreator(houseInfo);
house = creator.FactoryMethod();
Console.Write((house as WoodenHouse).WoodAge);
}
``````

Full code violin.

My problem is how to handle code duplication. I mean, here are many lines that fill the base `House` object properties. How can I write that code only once?
Or I shouldn't use `Factory Method`?

``````class HousePopulator
{
public void PopulateHouse(HouseInfo info, House house)
{
house.Name = info.Name;
house.Floors = info.Floors;
house.RoofType = info.RoofType;
}
}
``````

And use:

``````abstract class Creator
{
public abstract HouseInfo Info{get;set;}
public HousePopulator HousePopulator {get;set;}
public Creator()
{
HousePopulator = new HousePopulator();
}
public abstract House FactoryMethod();
}

class WoodenHouseCreator : Creator
{
public override HouseInfo Info{get;set;}

public WoodenHouseCreator(WoodenHouseInfo info)
{
Info = info;
}
public override House FactoryMethod()
{
var info = Info as WoodenHouseInfo;

var woodenHouse = new WoodenHouse();
HousePopulator.PopulateHouse(Info, woodenHouse);
woodenHouse.WoodType = info.WoodType;
woodenHouse.WoodAge = info.WoodAge;
return woodenHouse;
}
}
``````

## How to convert the function in parts to the interpolation function?

A bit big for a comment: change the definition of the function as:

``````f[t_, T_] :=
FunctionInterpolation[
Piecewise[{{0, 0 <= t <= T/4}, {1 - Sin[2*[Pi]*t/T],
T/4 <= t <= 3*T/4}, {2, 3*T/4 <= t <= T}}], {t, 0, T},
InterpolationOrder -> 10]
``````

Now this produces an interpolation function.

``````f[t, 10]
``````

And it can be traced.

``````Plot[f[t, 10][x], {x, 0., 10.}]
``````

## Nt.number theory: in an inequality involving the imaginary parts \$ gamma_n> 0 \$ of the non-trivial zeros \$ rho_n \$ of the Riemann zeta function

Here for integers $$n geq 1$$ we denote the sequence of non-trivial zeros of the Riemann zeta function $$zeta (s)$$ how $$rho_n$$and as always, $$gamma_n = Im rho_n$$ denotes the imaginary parts of these zeros in the upper semiplane $$Im z> 0$$ in ascending order. I add Wikipedia as a reference Riemann zeta function.

I would like to know if your knowledge of the asymptotic of the infinite sequence $${ gamma_n } _ {n geq 1}$$ We can refute the following conjecture (my knowledge about this sequence is not the best and my experiments are poor, so I would not be surprised if the conjecture is false).

Guess. Inequality $$gamma_ {n + 1}> frac { left (1+ frac {1} {n} right) ^ 2} { sqrt (n) {2 pi n ^ 2}} , gamma_n ^ {1+ frac {1} {n}}$$
it is true for all integers $$n> 4$$.

Question. Is it possible to prove or disprove previous conjectures? If it is very difficult to elucidate, what work can be done assuming conjectures or open problems, particularly those related to the asymptotic of $${ gamma_n } _ {n geq 1}$$? Thank you.

The germ of this idea arises when I try to combine informally some asymptotics and conjectures found in the literature. I have verified it for the first (hundreds of) terms of the sequence A002410 of the OEIS using a Pari / GP program, since I don't have a better approach to $$gamma_n$$

## What are the 5 parts of a URL?

Hello friends,

What are the 5 parts of a URL?

## dual boot: in addition to kwin, what main parts of the Plasma DE can be installed separately on a different desktop (LXQt, etc.)?

I like KDE / Plasma but on an older laptop `plasmashell` The process sometimes rises sharply and the desktop stops responding for some time, especially during Internet browsing, but not exclusively. So, I prefer Xfce on that machine, but I would like to try other combinations.

I know `kwin` It can be installed as a window manager on other desktops (for example, LXQt), and I'm curious to know if other main components of the Plasma experience could run separately from the Plasma desktop.

For example, can KDE panel be installed without `plasmashell`?