## Join the largest Crowdfunding Program – Other Money Making Opportunities

Are you looking at starting a new Business, Project, Career, buying a new car or acquiring a new home? but need financial assistance.

Well you don’t have to worry again because betaprofitss has you covered

Join the largest Crowdfunding Program:

Acquire Luxury homes
Brand New Car acquisition
Start a new career
And so much more

To get started :    https://betaprofitss.com/users/register?r=MTAwMDA2 .

## Largest square inscribed in a rectangle

The side length of the largest square inscribed in a rectangle of width $$a$$ and height $$b$$ is surely $$min(a,b)$$. How is this proved? (Or if it be wrong, what is the correct result?)

## Largest Crypto Trading Group On Telegram Free Bitcoin Bot & Signals

Cryptosignalalert is the largest Telegram group provide Free Bitcoin Binance auto trading bot which execute automatically in your account.We too provide high quality signals for Binance, Binance Futures, Bitmex, Coinbase Pro, Kucion, HitBTC

COPY PROFITABLE TRADING SIGNALS IN REAL TIME. EXPERT TRADERS AT YOUR SERVICE. GAIN CONSISTENT TRADING EXPERIENCE. FOLLOW TRADES ON THE GO. RISK MANAGEMENT & HIGH RISK TO REWARD RATIO. SMALL SL & LARGE TP. All these makes us the best. Get a FREE DEMO in above Telegram group

## regionfunction – Finding the largest disk within a convex region using Region primitives

As an area maximization problem:

reg = Polygon[{{0, 1}, {0, 6}, {4, 10}, {8, 10}, {11, 7}, {11, 4}, {7, 0}, {1, 0}, {0, 1}}];
rnf = RegionNearest[RegionBoundary[reg]];
gendisk[{x_, y_}] := Disk[{x, y}, EuclideanDistance[{x, y}, rnf[{x, y}]]]
cost[{x_?NumericQ, y_?NumericQ}] := Area[gendisk[{x, y}]]
{err, sol} = NMaximize[cost[{x, y}], {x, y} [Element] reg,
Method -> "RandomSearch"];
Graphics[{FaceForm[None], EdgeForm[Black], reg, Yellow,
FaceForm[Yellow], gendisk[Values@sol], Red, Point[Values[sol]]}] There’s a ridge at the centre of the distance transform, so I don’t think there is a unique solution but a family of disks with maximal area.

ImageAdjust@DistanceTransform@ColorNegate@Graphics[reg] ## linear algebra – Maximize the largest singular value of a matrix

I don’t know if there is a readily available conclusion for this. Given a diagonal matrix $$Sigma = operatorname{diag}(sigma_1, sigma_2, …, sigma_n)$$ where the diagonal entries are in descending order, I’m trying to find a rank $$k$$ ($$k le n$$) matrix A to maximize
$$lVert Sigma – A rVert_2,$$
but I’m not sure whether I should try to maximize the largest singular value of $$Sigma – A$$, or try to use the definition of the spectral norm:
$$lVert Sigma – A rVert_2 = max_{xne 0} frac{lVert (Sigma – A)x rVert_2}{lVert x rVert_2}.$$

Any suggestion is appreciated.

## javascript – Algorithm for dividing a number into largest “power of two” buckets?

For example, these are expected outputs:

3: 2, 1
4: 4
5: 4, 1
6: 4, 2
7: 4, 2, 1
8: 8
9: 8, 1
...
20: 16, 4
...
25: 16, 8, 1
...
36: 32, 4
...
50: 32, 16, 2


Up to the max of 32 being the largest subunit. So then we get larger:

100: 32, 32, 32, 4
...
201: 32, 32, 32, 32, 32, 32, 8, 1
...


What is the equation / algorithm to implement this most optimally in JavaScript? By optimal I mean the fastest performance, or fewest primitive steps for example, with the least amount of temporary variables, etc. I feel like my solution below is a “brute force” approach which lacks elegance and it seems like it could be optimized somehow. Ideally there would be no Math.floor or division as well, if possible to use some sort of bit magic.

log(20)
log(25)
log(36)
log(50)
log(100)
log(200)

function log(n) {
console.log(generate_numbers(n).join(', '))
}

function generate_numbers(n) {
const chunks = count_chunks(n)
const sum = chunks.reduce((m, i) => m + i, 0)
const result = new Array(sum)
const values = ( 1, 2, 4, 8, 16, 32 )
let i = chunks.length
let j = 0
while (i--) {
let x = chunks(i)
while (x--) {
result(j++) = values(i)
}
}
return result
}

function count_chunks(n) {
let chunks = (0, 0, 0, 0, 0, 0)
if (n >= 32) {
let i = Math.floor(n / 32)
chunks(5) = i
n = n - (i * 32)
}
if (n >= 16) {
chunks(4) = 1
n = n - 16
}
if (n >= 8) {
chunks(3) = 1
n = n - 8
}
if (n >= 4) {
chunks(2) = 1
n = n - 4
}
if (n >= 2) {
chunks(1) = 1
n = n - 2
}
if (n >= 1) {
chunks(0) = 1
}
return chunks
}

## computer architecture – Is machine epsilon the largest relative error in representing a number as a floating point number?

Thanks for contributing an answer to Computer Science Stack Exchange!

But avoid

• Making statements based on opinion; back them up with references or personal experience.

Use MathJax to format equations. MathJax reference.

## algorithms – What is the largest sum that can be constructed with the given recipes?

There are $$n$$ sets of distinct positive integers, $$S_1,ldots,S_n$$.
There is a set of recipes that allows us to construct tuples of integers from these sets. For example, the recipe {1,2} allows us to construct tuples of two integers: one from $$S_1$$ and one from $$S_2$$. Each integer can be used in at most one tuple. What is an algorithm that, given the sets and the recipes, constructs tuples such that the sum of integers in all tuples together is maximum? Here are some simple cases:

(a) There is a single recipe, e.g. {1,2}. Then the algorithm is simple: sort the integers in $$S_1$$ and in $$S_2$$ in descending order; pair the largest integers in each set; pair the second-largest integers in each set; keep pairing integers as long as the sum of the next pair is positive.

(b) There are two recipes {1,2} and {1,3}. Then, $$S_2$$ and $$S_3$$ are substitutes: combine them into a single set $$S_4 = S_2cup S_3$$, and proceed as in (a) with the recipe {1, 4}.

(c) There are two recipes {1,2} and {1,3,4}. Then, $$S_3$$ and $$S_4$$ are complements: sort each one in descending order, and construct a new set $$S_5$$ in which the largest element is the sum of the largest elements in $$S_3,S_4$$, the second-largest is the sum of the two second-largest elements, and so on. Proceed as in (b) with the recipes {1,2} and {1,5}.

(d) The above two operations can be generalized to the case in which the set of recipes has a tree structure: there is a tree in which each node is a set, and each recipe is a path from root to leaf in the tree. The tree can be “contracted” as follows: a leaf which is the unique child of its parent can be combined with its parent as in (c); two leafs of the same parent can be combined as in (b).

Is there an efficient algorithm that works for any set of recipes?

## data structures – Algorithm- Find the length of largest subarray having sum greater than k

I tried to solve this problem but could not do it better than O(n^2).

My Algorithm:
1.calculate prefixsum
2.for i 1...n
for j 1...i
if(presum(i)-presum(j-1)>k)
ans=max(ans,i-j);


However, this is inefficient for large values of n.Can someone help me with optimized algorithm along with code preferably in c++.

## Which screen resolution (Largest or smallest) is best for developer hand-offs?

I am currently designing a web app to cater for the following screen resolutions:

1. 1920 x 1080
2. 1600 x 864
3. 1366 x 768

I’m wondering:

• Which is the default/primary resolution I should design in for developer hand-offs. (It’s a huge web app and I can’t possibly replicate it in all the resolutions.)
• What trade-offs am I making, or what precaution should I take if I select 1 resolution over another. (I’m currently inclined to design in 1366×768 since it’s easier for developer to imagine scaling up)