How can I minimize two integers so that their product is less than a certain value? - pixel

Question

Given two integers, how can I minimize them so that their product is less than some other value, while maintaining their relative ratio?
That's the formal problem. The practical problem is this: I have width/height pixel resolutions containing random values (anywhere from 1 to 8192 for either dimension). I want to adjust the pairs of values, such that their product doesn't exceed some total number of pixels (ex: 1000000), and I need to ensure that the aspect ratio of the adjusted resolution remains the same (ex: 1.7777).
The naive approach is to just run a loop where I subtract 1 from the width each time, adjusting the height to match the aspect ratio, until their product is under the threshold. Ex:
int wid = 1920;
int hei = 1080;
float aspect = wid / (float)hei;
int maxPixels = 1000000;
while (wid * hei > maxPixels)
{
wid -= 1;
hei = wid / aspect;
}
Surely there must be a more analytical approach to this problem though?

Answer 1

Edit: Misread the original question.
Another way to word your question is with a W and H what is the largest a and b such that a/b = W/H and a*b < C where C is your limit on .
To do so, find the D = gcd(W,H) or greatest common divisor of W and H. Greatest common denominator is commonly found using the Euclidean Algorithm.
Set x = W/D and y = H/D, this is minimal solution with the same ratio.
To produce the maxima under C, start with the inequality of F*x*F*y <= C where F will be our scale factor for x and y
Algebra:
F^2 <= C/(x*y)
F <= sqrt(C/(x*y))
Since we want F to be a whole number and strictly less than the above,
F = floor(sqrt(C/(x*y)))
This will give you a new solution A = x*F and B = y*F where A*B < C and A/B = W/H.

Answer 2

mascoj came up with the answer, but here is an interpretation in code form:
#include <utility>
#include <numeric>
#include <cmath>
#include <iostream>
// Mathsy stuff
std::pair<uint64_t, uint64_t> ReduceRatio(const uint64_t W, const uint64_t H)
{
const double D = std::gcd(W, H);
return {W/D, H/D};
}
std::pair<uint64_t, uint64_t> Maximise(const uint64_t C, const uint64_t W, const uint64_t H)
{
const auto [x, y] = ReduceRatio(W, H);
const uint64_t F = std::floor(std::sqrt(C/double(x*y)));
const uint64_t A = x*F;
const uint64_t B = y*F;
return {A, B};
}
// Test harness
void Test(const uint64_t MaxProduct, const uint64_t W, const uint64_t H)
{
const auto [NewW, NewH] = Maximise(MaxProduct, W, H);
std::cout << W << "\u00D7" << H << " (" << (W*H) << " pixels)";
if (NewW > W)
std::cout << '\n';
else
std::cout << " => " << NewW << "\u00D7" << NewH << " (" << (NewW * NewH) << " pixels)\n";
}
int main()
{
Test(100000, 1024, 768);
Test(100000, 1920, 1080);
Test(500000, 1920, 1080);
Test(1000000, 1920, 1080);
Test(2000000, 1920, 1080);
Test(4000000, 1920, 1080);
}
// g++ -std=c++17 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
// 1024×768 (786432 pixels) => 364×273 (99372 pixels)
// 1920×1080 (2073600 pixels) => 416×234 (97344 pixels)
// 1920×1080 (2073600 pixels) => 928×522 (484416 pixels)
// 1920×1080 (2073600 pixels) => 1328×747 (992016 pixels)
// 1920×1080 (2073600 pixels) => 1872×1053 (1971216 pixels)
// 1920×1080 (2073600 pixels)