In Windows 10, how to make icons text bold on the desktop. The size is fine

Battery exchange network

The Stack Exchange network includes 175 question and answer communities, including Stack Overflow, the largest and most reliable online community for developers who want to learn, share knowledge and develop their careers.

Visit Stack Exchange

Flash Network – What is your opinion on the block size debate?

I have been following Bitcoin for a few years now, and I was wondering what the developers are thinking here about block size right now.

I realize that we can never evolve towards millions of transactions per second on the chain, I understand that – that's why LN etc. is under construction to also maintain the decentralization of Bitcoins while continuing to evolve. But wouldn't that also benefit the Lightning network, that more "deposits" on the chain to LN could be made in one block (imagine a few million users trying to access LN at the same time – the Bitcoins blockchain would be blocked quickly – essentially meaning no deposit in LN for a long time?).

If the block size has been increased to say 10 times (10 MB): I realize that Bitcoin node operators would start to experience problems with storing the fast growing blockchain (more centralization) – but then again , is it really necessary that everyone can execute a knot? Aren't nodes primarily used for miners and programmers?

I realize that validating your own transactions is a great thing, but should that be hindering scaling up on the chain? It is a cutting edge, but I think we have to find a balance. Either way, at 10MB we would be increasing the blockchain by 1.4GB per day, or 500GB per year (assuming the blocks are full), which is a lot. But then again, it's not unusual to see hard drives the size of a few double-digit TB these days – it seems that capacity is on an increasing trend, so maybe decentralization is possible. after all at this size? I'm really curious to hear more arguments against increasing the size of the blocks, now that a few years have passed since the big boom 🙂

semigroups and monoids – On the number of connected functional digraphs recoverable from the size structure of the set of pre-images

I am studying the list of inverse images (pre-image sets) of a function $ f $ at a given inverse depth $ j $ – for each element $ x_i $ of a finite domain $ X $.

For example,
$ P_j = left (f ^ {- j} (x_1), f ^ {- j} (x_2), f ^ {- j} (x_3), text {…}, f ^ {- j} (x_n) right) $

For each of them we can fill in the matrix

$ P = left ( begin {array} {cccc}
f ^ {- 1} (x_ {1}) & f ^ {- 2} (x_ {1}) & cdots & f ^ {- n} (x_ {1}) \
f ^ {- 1} (x_ {2}) & ddots \
vdots \
f ^ {- 1} (x_ {n}) & & & f ^ {- n} (x_ {n})
end {array} right) $

However, what particularly interests me is what happens when we look sizes such matrix elements.
Transfer a matrix $ Sigma $ with entrances

$ Sigma = left ( begin {array} {cccc}
mid f ^ {- 1} (x_ {1}) mid & cdots & mid f ^ {- n} (x_ {1}) mid \
& ddots \
vdots \
mid f ^ {- 1} (x_ {n}) mid & & mid f ^ {- n} (x_ {n}) mid
end {array} right) $

For example, for $ f = (a, b), (b, a), (c, a) $ by calculating the second matrix, we get $ Sigma_f = left ( begin {array} {ccc}
2 & 1 & 2 \
1 & 2 & 1 \
0 & 0 & 0
end {array} right) $

Now, each pre-image size matrix (Sigma) must be associated with a set of functions which have the matrix as the Sigma matrix. This is the partition of functions $ X ^ X $ by the matrix structure.

I suspect: 1. In each class $ (f) = {g: Sigma g = Sigma f} $ there is only one functional single component digraph. 2. There are no two functions with the same size cycle

For example, for $ f = (a, b), (b, a), (c, a), (d, b) $ and $ g = (a, a), (b, b), (c, a), (d, b) $ we have the same sigma matrix
$ Sigma_ {f, g} = left ( begin {array} {ccc}
2 & 2 & 2 & 2 \
2 & 2 & 2 & 2 \
0 & 0 & 0 & 0 \
0 & 0 & 0 & 0
end {array} right) $

However, there is only one (maximum) functional digraph connected $ f $

If anyone has references or a suggestion on how to do this, I would be grateful … I suspect keeping everything else the same, increasing / decreasing the size of the cycle in one Connected functional digraph changes the structure of the pre-image. So, to get cycles of length 1 (in the example above), the graph had to be disconnected. Similarly, increasing the size of the cycle to 3 would require a different pre-image structure …

Any help appreciated.

Fournier, Bradford M., "Towards a theory of recursive function
Complexity: Sigma Matrices and Inverse Complexity Measures "(2015).
Theses and dissertations from the University of New Orleans. 2072.

https://scholarworks.uno.edu/td/2072

dnd 5th – What is the size of a target on which you can launch Heat Metal?

I was running a game and the group was trying to get away from a flying Illithid raid skiff. It was made of metal and had two Illithid crew members on deck. The bard of the evening launched Heat Metal on the hull of the skiff. I didn't know how to make it work, so to keep the game moving, I made it as close to RAW as possible. It was a metal object made within reach, so everyone on deck had to take damage and try to save it. If I had more time, I don't know how I would have governed it.

As it stands, I can think of a few possible alternatives and I want an external input.

  1. In the rough, the entire metal shell heats up. (As I played it)
  2. The target spell on the shell plate, and heats that, anyone in contact with this plate is affected by the spell. (Each plate is made, then assembled, a little prickly.)
  3. The spell fails because the entire object was not within range. (Very Nitpicky)
  4. the spell only heats a certain mass or volume, perhaps an area 10 feet by 10 feet from the hull. (Assuming the armor of a huge giant is only very large)

The first option has the implications that you could throw it at an aircraft carrier and condemn them all.

Option two implies that only one piece of armor full of plates is checked by the spell and that heat is directed to the others.

Option three implies that casting a targeting spell when only having a creature hand in range would fail.

Option four has the consequence that its heat is of limited range.

Thoughts?

Unit card size limitations? Card Streaming

These are tools like Sectr stream which are not free, I want to create my own tool for that.
All tutorials do it for the procedural worlds, which is NOT what I want. I want to design a world and distribute it as the user plays (not based on an instance). I have designed zones separately and this is now becoming critical.
Please help.

How to change the default font size on iOS Mail for outgoing emails?

I know you can change the default font via the Format pane:

enter description of image here

But if you change the font size, you only change it for the email you compose.

Is there a way to change default font size?

My software version is 13.3.1.

c ++ – Obtaining a transposition of a size matrix of n * n where n = 2 ^ m using multithreading

The following is c ++ source code to obtain a matrix (std::vector>) transpose in parallel.

The duration is $ Theta ( lg ^ 2 (n)) $ during work $ Theta (n ^ 2) $

Any suggestion for improvement will be appreciated.

#include
#include
#include
#include
template 
void parallelForColsTrans(std::vector>& A, size_t fCol, size_t lCol, size_t i, size_t n)
{
    if (fCol == lCol)
    {
        T temp = A(i)(fCol+n);
        A(i)(fCol+n) = A(i+n)(fCol);
        A(i+n)(fCol) = temp;

        return;
    }

    std::async(parallelForColsTrans, std::ref(A), fCol, (fCol + lCol) / 2, i, n);
    std::async(parallelForColsTrans, std::ref(A), (fCol + lCol) / 2 + 1, lCol, i, n);

}


template 
void parallelForRowsTrans(std::vector>& A, size_t fRow, size_t lRow, size_t fCol, size_t lCol, size_t n)
{
    if (fRow == lRow) {
        parallelForColsTrans(A, fCol, lCol, fRow, n);
        return;
    }

    std::async(parallelForRowsTrans, std::ref(A), fRow, (fRow+lRow) / 2, fCol, lCol, n);
    std::async(parallelForRowsTrans, std::ref(A), (fRow + lRow) / 2 + 1, lRow, fCol, lCol, n);
}

template 
void pMatTransposeRecursive(std::vector>& A, size_t firstRow, size_t lastRow, size_t firstColumn, size_t lastColumn)
{
    if (firstRow == lastRow)    return;

    auto t1 =std::async(pMatTransposeRecursive, std::ref(A), firstRow, (firstRow +lastRow)/2, firstColumn, (firstColumn+lastColumn)/2);
    auto t2 =std::async(pMatTransposeRecursive, std::ref(A), (firstRow +lastRow)/2+1, lastRow, firstColumn, (firstColumn+lastColumn)/2);
    auto t3 =std::async(pMatTransposeRecursive, std::ref(A), firstRow, (firstRow +lastRow)/2, (firstColumn+lastColumn)/2+1, lastColumn);
    pMatTransposeRecursive(std::ref(A), (firstRow +lastRow)/2+1, lastRow, (firstColumn+lastColumn)/2+1, lastColumn);
    t1.get();
    t2.get();
    t3.get();
    size_t n = (lastColumn-firstColumn+1)/2;
    parallelForRowsTrans(std::ref(A), firstRow, firstRow+n-1, firstColumn, firstColumn+n-1, n);

}

template 
void transpose(std::vector>& A){
    pMatTransposeRecursive( A, 0, A.size()-1, 0, A(0).size()-1);
}
int main(){

    std::vector> A = {{1,2,3,4,7,7,7,8}, {5,6,7,8,4,5,1,1}, {9,10,5,5,11,12,4,79}, {7,8,13,14,15,16,44,6}, {13,-14,7,-7,15,-16,-44,6}, {13,-14,105,106,404,6,9,9}, {13,-14,7,-7,15,-16,-44,6}, {13,-14,105,106,404,6,9,9}};
    transpose(A);
    for(auto & el:A){
        for(auto& ele:el) std::cout << ele << std::setw(4) ;
        std::cout << "n";

    }
}

c # – Search for grid cells in a 2D grid based on the size and rotation of the object

I'm working on a game that uses a grid system that allows the player to place buildings around the world. Each grid cell measures 64 x 64. All buildings will be a multiple of 64 x 64, so everything will fit evenly into the grid.

Below shows an example of a building which is 128×64 and placed at the grid position 64×64. The client sends the "basic" cell, which in this case is 1.1 (@ 64×64), to the server, and knows that the building under construction is 128×64, so it puts both cells in the state " occupied ", which means that a building is placed in these 2 grids.

Example without rotation

The problem I encounter is to allow the client to rotate the building 90, 180 or 270 degrees.

For example, if the client wanted to place the same building, but turned 90 degrees, it would look like this:

Example 90 rotation

Basically what I'm asking is: since the client is sending the server the location to build 64×64 and sending 90 for rotation, how do i (on the server) determine which cells is going on to be built?

Currently, I'm using this code to get the grids, but it doesn't allow rotation because I have no idea.

https://pastebin.com/UaaUa7jZ

Any help would be appreciated.

algorithms – How does the maximum number of guesses necessary to win Mastermind (board game) change as the size of the board increases?

Donald Knuth has shown that the code breaker in the Mastermind board game can solve the model in five moves or less using the following algorithm:

  1. Create a set S of remaining possibilities (at this point there are 1296). The first assumption is aabb.
  2. Remove all possibilities from S that would not give the same score of colored and white pegs if they were the answer.
  3. For each possible assumption (not necessarily in S), calculate how many possibilities of S would be eliminated for each possible color / white score. The guess score is the lesser of these values. Make the assumption with the highest score (minimax).
  4. Go back to step 2 until you get it right.

I'm curious: what would be the maximum number of guesses necessary to win a game of Mastermind with 5 pegs instead of 4? How about 1000 pegs, or a million?

Web application – Spring Data Rest 2.4 does not work with links {? page, size, sort}

I am trying to run my Spring Boot web template v2.1.5.RELEASE, but when I go to http: // localhost: 8080 /, I see the following:

_links  
users   
href    "http://localhost:8080/users{?page,size,sort}"
template    true
profile 
href    "http://localhost:8080/profile"

the model does not run