ฉันพยายามแปลงตัวเลขหนึ่งช่วงเป็นอีกช่วงหนึ่งโดยคงอัตราส่วนไว้ คณิตศาสตร์ไม่ใช่จุดแข็งของฉัน

ฉันมีไฟล์รูปภาพที่ค่าจุดอาจอยู่ในช่วง -16000.00 ถึง 16000.00 แม้ว่าช่วงทั่วไปอาจน้อยกว่ามาก สิ่งที่ฉันต้องการทำคือบีบอัดค่าเหล่านี้ลงในช่วงจำนวนเต็ม 0-100 โดยที่ 0 คือค่าของจุดที่เล็กที่สุดและ 100 คือค่าที่มากที่สุด ทุกจุดในระหว่างควรรักษาอัตราส่วนสัมพัทธ์แม้ว่าความแม่นยำบางอย่างจะสูญหายฉันต้องการทำเช่นนี้ในหลาม แต่อัลกอริทึมทั่วไปควรพอเพียง ฉันต้องการอัลกอริทึมที่สามารถปรับค่าต่ำสุด / สูงสุดหรือช่วงใดช่วงหนึ่งได้ (เช่นช่วงที่สองอาจเป็น -50 ถึง 800 แทนที่จะเป็น 0 ถึง 100)

NewValue = (((OldValue - OldMin) * (NewMax - NewMin)) / (OldMax - OldMin)) + NewMin

หรืออ่านเพิ่มเติมเล็กน้อย:

OldRange = (OldMax - OldMin)  
NewRange = (NewMax - NewMin)  
NewValue = (((OldValue - OldMin) * NewRange) / OldRange) + NewMin

หรือถ้าคุณต้องการปกป้องกรณีที่ช่วงเก่าเป็น 0 ( OldMin = OldMax ):

OldRange = (OldMax - OldMin)
if (OldRange == 0)
    NewValue = NewMin
else
{
    NewRange = (NewMax - NewMin)  
    NewValue = (((OldValue - OldMin) * NewRange) / OldRange) + NewMin
}

โปรดทราบว่าในกรณีนี้เราถูกบังคับให้เลือกหนึ่งในช่วงค่าใหม่ที่เป็นไปได้โดยพลการ ทางเลือกที่เหมาะสมอาจเป็น: NewMin( ดูตัวอย่าง ) NewMaxหรือ(NewMin + NewMax) / 2

นั่นคือการแปลงเชิงเส้นอย่างง่าย

new_value = ( (old_value - old_min) / (old_max - old_min) ) * (new_max - new_min) + new_min

ดังนั้นการแปลง 10,000 ในระดับ -16,000 ถึง 16,000 เป็นระดับใหม่ 0 ถึง 100 อัตราผลตอบแทน:

old_value = 10000
old_min = -16000
old_max = 16000
new_min = 0
new_max = 100

new_value = ( ( 10000 - -16000 ) / (16000 - -16000) ) * (100 - 0) + 0
          = 81.25

จริงๆแล้วมีบางกรณีที่คำตอบข้างต้นจะผิดพลาด เช่นค่าอินพุตผิดช่วงอินพุตผิดช่วงอินพุต / เอาต์พุตลบ

def remap( x, oMin, oMax, nMin, nMax ):

    #range check
    if oMin == oMax:
        print "Warning: Zero input range"
        return None

    if nMin == nMax:
        print "Warning: Zero output range"
        return None

    #check reversed input range
    reverseInput = False
    oldMin = min( oMin, oMax )
    oldMax = max( oMin, oMax )
    if not oldMin == oMin:
        reverseInput = True

    #check reversed output range
    reverseOutput = False   
    newMin = min( nMin, nMax )
    newMax = max( nMin, nMax )
    if not newMin == nMin :
        reverseOutput = True

    portion = (x-oldMin)*(newMax-newMin)/(oldMax-oldMin)
    if reverseInput:
        portion = (oldMax-x)*(newMax-newMin)/(oldMax-oldMin)

    result = portion + newMin
    if reverseOutput:
        result = newMax - portion

    return result

#test cases
print remap( 25.0, 0.0, 100.0, 1.0, -1.0 ), "==", 0.5
print remap( 25.0, 100.0, -100.0, -1.0, 1.0 ), "==", -0.25
print remap( -125.0, -100.0, -200.0, 1.0, -1.0 ), "==", 0.5
print remap( -125.0, -200.0, -100.0, -1.0, 1.0 ), "==", 0.5
#even when value is out of bound
print remap( -20.0, 0.0, 100.0, 0.0, 1.0 ), "==", -0.2

มีเงื่อนไขเมื่อค่าทั้งหมดที่คุณกำลังตรวจสอบอยู่เหมือนกันโดยที่ @ jerryjvl โค้ดจะส่งคืน NaN

if (OldMin != OldMax && NewMin != NewMax):
    return (((OldValue - OldMin) * (NewMax - NewMin)) / (OldMax - OldMin)) + NewMin
else:
    return (NewMax + NewMin) / 2

ฉันไม่ได้ขุดBNFสำหรับเรื่องนี้ แต่เอกสาร Arduino มีตัวอย่างที่ยอดเยี่ยมของฟังก์ชั่นและมันพัง ฉันสามารถใช้สิ่งนี้ใน Python เพียงแค่เพิ่มการเปลี่ยนชื่อ def เพื่อทำการแมปใหม่อีกครั้ง (สาเหตุที่ map เป็นแบบในตัว) และการลบ cast cast ประเภทและเครื่องหมายปีกกา (เช่นเพียงลบ 'long's' ทั้งหมด)

เป็นต้นฉบับ

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

หลาม

def remap(x, in_min, in_max, out_min, out_max):
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min

https://www.arduino.cc/en/reference/map

ในรายชื่อที่ให้บริการโดย PenguinTD ฉันไม่เข้าใจว่าเพราะเหตุใดช่วงนั้นจึงกลับด้านมันทำงานได้โดยไม่ต้องย้อนกลับช่วง การแปลงช่วงเชิงเส้นจะขึ้นอยู่กับสมการเชิงเส้นY=Xm+nที่mและnมาจากช่วงที่กำหนด แทนที่จะอ้างถึงช่วงเป็นminและmaxมันจะดีกว่าที่จะอ้างถึงพวกเขาเป็น 1 และ 2 ดังนั้นสูตรจะเป็น:

Y = (((X - x1) * (y2 - y1)) / (x2 - x1)) + y1

ที่ไหนY=y1เมื่อX=x1และเมื่อY=y2 , , และจะได้รับการใด ๆหรือค่า การกำหนดนิพจน์ในแมโครทำให้มีประโยชน์มากขึ้นและสามารถใช้กับชื่ออาร์กิวเมนต์ใด ๆ ได้X=x2x1x2y1y2positivenegative

#define RangeConv(X, x1, x2, y1, y2) (((float)((X - x1) * (y2 - y1)) / (x2 - x1)) + y1)

floatหล่อจะให้ลอยส่วนจุดในกรณีที่มีปากเสียงทั้งหมดที่มีintegerค่า ทั้งนี้ขึ้นอยู่กับการใช้งานก็อาจจะไม่จำเป็นต้องตรวจสอบช่วงและx1=x2y1==y2

ต่อไปนี้เป็นฟังก์ชัน Python สั้น ๆ สำหรับการคัดลอกและวางของคุณรวมถึงฟังก์ชั่นเพื่อขยายรายการทั้งหมด

def scale_number(unscaled, to_min, to_max, from_min, from_max):
    return (to_max-to_min)*(unscaled-from_min)/(from_max-from_min)+to_min

def scale_list(l, to_min, to_max):
    return [scale_number(i, to_min, to_max, min(l), max(l)) for i in l]

ซึ่งสามารถใช้เช่น:

scale_list([1,3,4,5], 0, 100)

[0.0, 50.0, 75.0, 100.0]

ในกรณีของฉันฉันต้องการปรับมาตรโค้งแบบลอการิทึมเช่น:

scale_list([math.log(i+1) for i in range(5)], 0, 50)

[0.0, 21.533827903669653, 34.130309724299266, 43.06765580733931, 50.0]

ฉันใช้วิธีแก้ปัญหานี้ในปัญหาที่ฉันแก้ไขใน js ดังนั้นฉันคิดว่าฉันจะแบ่งปันการแปล ขอบคุณสำหรับคำอธิบายและการแก้ปัญหา

function remap( x, oMin, oMax, nMin, nMax ){
//range check
if (oMin == oMax){
    console.log("Warning: Zero input range");
    return None;
};

if (nMin == nMax){
    console.log("Warning: Zero output range");
    return None
}

//check reversed input range
var reverseInput = false;
oldMin = Math.min( oMin, oMax );
oldMax = Math.max( oMin, oMax );
if (oldMin != oMin){
    reverseInput = true;
}

//check reversed output range
var reverseOutput = false;  
newMin = Math.min( nMin, nMax )
newMax = Math.max( nMin, nMax )
if (newMin != nMin){
    reverseOutput = true;
};

var portion = (x-oldMin)*(newMax-newMin)/(oldMax-oldMin)
if (reverseInput){
    portion = (oldMax-x)*(newMax-newMin)/(oldMax-oldMin);
};

var result = portion + newMin
if (reverseOutput){
    result = newMax - portion;
}

return result;
}

ตัวแปร C ++

ฉันพบว่าโซลูชั่นของ PenguinTD มีประโยชน์ดังนั้นฉันจึงแจ้งไปยัง C ++ หากใครต้องการ:

float remap (float x, ลอย oMin, ลอย oMax, ลอย nMin, ลอย nMax) {

//range check
if( oMin == oMax) {
    //std::cout<< "Warning: Zero input range";
    return -1;    }

if( nMin == nMax){
    //std::cout<<"Warning: Zero output range";
    return -1;        }

//check reversed input range
bool reverseInput = false;
float oldMin = min( oMin, oMax );
float oldMax = max( oMin, oMax );
if (oldMin == oMin)
    reverseInput = true;

//check reversed output range
bool reverseOutput = false;  
float newMin = min( nMin, nMax );
float newMax = max( nMin, nMax );
if (newMin == nMin)
    reverseOutput = true;

float portion = (x-oldMin)*(newMax-newMin)/(oldMax-oldMin);
if (reverseInput)
    portion = (oldMax-x)*(newMax-newMin)/(oldMax-oldMin);

float result = portion + newMin;
if (reverseOutput)
    result = newMax - portion;

return result; }

PHP พอร์ต

พบวิธีแก้ปัญหาของ PenguinTD ที่เป็นประโยชน์ดังนั้นฉันจึงส่งไปที่ PHP ช่วยตัวของคุณเอง!

/**
* =====================================
*              Remap Range            
* =====================================
* - Convert one range to another. (including value)
*
* @param    int $intValue   The value in the old range you wish to convert
* @param    int $oMin       The minimum of the old range
* @param    int $oMax       The maximum of the old range
* @param    int $nMin       The minimum of the new range
* @param    int $nMax       The maximum of the new range
*
* @return   float $fResult  The old value converted to the new range
*/
function remapRange($intValue, $oMin, $oMax, $nMin, $nMax) {
    // Range check
    if ($oMin == $oMax) {
        echo 'Warning: Zero input range';
        return false;
    }

    if ($nMin == $nMax) {
        echo 'Warning: Zero output range';
        return false;
    }

    // Check reversed input range
    $bReverseInput = false;
    $intOldMin = min($oMin, $oMax);
    $intOldMax = max($oMin, $oMax);
    if ($intOldMin != $oMin) {
        $bReverseInput = true;
    }

    // Check reversed output range
    $bReverseOutput = false;
    $intNewMin = min($nMin, $nMax);
    $intNewMax = max($nMin, $nMax);
    if ($intNewMin != $nMin) {
        $bReverseOutput = true;
    }

    $fRatio = ($intValue - $intOldMin) * ($intNewMax - $intNewMin) / ($intOldMax - $intOldMin);
    if ($bReverseInput) {
        $fRatio = ($intOldMax - $intValue) * ($intNewMax - $intNewMin) / ($intOldMax - $intOldMin);
    }

    $fResult = $fRatio + $intNewMin;
    if ($bReverseOutput) {
        $fResult = $intNewMax - $fRatio;
    }

    return $fResult;
}

นี่คือเวอร์ชัน Javascript ที่ส่งคืนฟังก์ชันที่ทำการ rescaling สำหรับช่วงต้นทางและปลายทางที่กำหนดไว้ล่วงหน้าซึ่งจะลดจำนวนการคำนวณที่ต้องทำในแต่ละครั้ง

// This function returns a function bound to the 
// min/max source & target ranges given.
// oMin, oMax = source
// nMin, nMax = dest.
function makeRangeMapper(oMin, oMax, nMin, nMax ){
    //range check
    if (oMin == oMax){
        console.log("Warning: Zero input range");
        return undefined;
    };

    if (nMin == nMax){
        console.log("Warning: Zero output range");
        return undefined
    }

    //check reversed input range
    var reverseInput = false;
    let oldMin = Math.min( oMin, oMax );
    let oldMax = Math.max( oMin, oMax );
    if (oldMin != oMin){
        reverseInput = true;
    }

    //check reversed output range
    var reverseOutput = false;  
    let newMin = Math.min( nMin, nMax )
    let newMax = Math.max( nMin, nMax )
    if (newMin != nMin){
        reverseOutput = true;
    }

    // Hot-rod the most common case.
    if (!reverseInput && !reverseOutput) {
        let dNew = newMax-newMin;
        let dOld = oldMax-oldMin;
        return (x)=>{
            return ((x-oldMin)* dNew / dOld) + newMin;
        }
    }

    return (x)=>{
        let portion;
        if (reverseInput){
            portion = (oldMax-x)*(newMax-newMin)/(oldMax-oldMin);
        } else {
            portion = (x-oldMin)*(newMax-newMin)/(oldMax-oldMin)
        }
        let result;
        if (reverseOutput){
            result = newMax - portion;
        } else {
            result = portion + newMin;
        }

        return result;
    }   
}

นี่คือตัวอย่างของการใช้ฟังก์ชันนี้เพื่อปรับขนาด 0-1 เป็น -0x80000000, 0x7FFFFFFF

let normTo32Fn = makeRangeMapper(0, 1, -0x80000000, 0x7FFFFFFF);
let fs = normTo32Fn(0.5);
let fs2 = normTo32Fn(0);

ข้อเสนอแบบย่อ / ย่อ

 NewRange/OldRange = Handy multiplicand or HM
 Convert OldValue in OldRange to NewValue in NewRange = 
 (OldValue - OldMin x HM) + NewMin

เวย์น

ฉันใช้คลาสผู้ช่วยที่รองรับยาชื่อสามัญ (ใช้งาน Swift 3 ได้)

struct Rescale<Type : BinaryFloatingPoint> {
    typealias RescaleDomain = (lowerBound: Type, upperBound: Type)

    var fromDomain: RescaleDomain
    var toDomain: RescaleDomain

    init(from: RescaleDomain, to: RescaleDomain) {
        self.fromDomain = from
        self.toDomain = to
    }

    func interpolate(_ x: Type ) -> Type {
        return self.toDomain.lowerBound * (1 - x) + self.toDomain.upperBound * x;
    }

    func uninterpolate(_ x: Type) -> Type {
        let b = (self.fromDomain.upperBound - self.fromDomain.lowerBound) != 0 ? self.fromDomain.upperBound - self.fromDomain.lowerBound : 1 / self.fromDomain.upperBound;
        return (x - self.fromDomain.lowerBound) / b
    }

    func rescale(_ x: Type )  -> Type {
        return interpolate( uninterpolate(x) )
    }
}

ตัวอย่างนี้แปลงตำแหน่งปัจจุบันของเพลงเป็นช่วงมุมที่ 20 - 40

    /// <summary>
    /// This test converts Current songtime to an angle in a range. 
    /// </summary>
    [Fact]
    public void ConvertRangeTests()
    {            
       //Convert a songs time to an angle of a range 20 - 40
        var result = ConvertAndGetCurrentValueOfRange(
            TimeSpan.Zero, TimeSpan.FromMinutes(5.4),
            20, 40, 
            2.7
            );

        Assert.True(result == 30);
    }

    /// <summary>
    /// Gets the current value from the mixValue maxValue range.        
    /// </summary>
    /// <param name="startTime">Start of the song</param>
    /// <param name="duration"></param>
    /// <param name="minValue"></param>
    /// <param name="maxValue"></param>
    /// <param name="value">Current time</param>
    /// <returns></returns>
    public double ConvertAndGetCurrentValueOfRange(
                TimeSpan startTime,
                TimeSpan duration,
                double minValue,
                double maxValue,
                double value)
    {
        var timeRange = duration - startTime;
        var newRange = maxValue - minValue;
        var ratio = newRange / timeRange.TotalMinutes;
        var newValue = value * ratio;
        var currentValue= newValue + minValue;
        return currentValue;
    }

รายการความเข้าใจโซลูชั่นซับหนึ่ง

color_array_new = [int((((x - min(node_sizes)) * 99) / (max(node_sizes) - min(node_sizes))) + 1) for x in node_sizes]

รุ่นที่ยาวกว่า

def colour_specter(waste_amount):
color_array = []
OldRange = max(waste_amount) - min(waste_amount)
NewRange = 99
for number_value in waste_amount:
    NewValue = int((((number_value - min(waste_amount)) * NewRange) / OldRange) + 1)
    color_array.append(NewValue)
print(color_array)
return color_array

เวอร์ชั่น Java

ใช้งานได้เสมอไม่ว่าคุณจะป้อนอะไร!

ฉันปล่อยทุกอย่างให้กว้างขึ้นเพื่อให้ง่ายต่อการเรียนรู้ แน่นอนว่าการปัดเศษนั้นเป็นทางเลือก

    private long remap(long p, long Amin, long Amax, long Bmin, long Bmax ) {

    double deltaA = Amax - Amin;
    double deltaB = Bmax - Bmin;
    double scale  = deltaB / deltaA;
    double negA   = -1 * Amin;
    double offset = (negA * scale) + Bmin;
    double q      = (p * scale) + offset;
    return Math.round(q);

}