مۆدیوول:Weather box

بەڵگەدارکردنی مۆدیوول[ببینە] [دەستکاری بکە] [مێژوو] [پاکسازی]

Usage

This module is used by {{Weather box}}.

{{#invoke:Weather box|function_name}}

زانیاریی کەشوھەوا بۆ «Edmonton City Centre (Blatchford Field) Airport (1981−2010)»
مانگی زایینی	١	٢	٣	٤	٥	٦	٧	٨	٩	١٠	١١	١٢	ساڵ
بەرزترین پلەی تۆمارکراو	١١٫٧ (٥٣)	١٤٫٠ (٥٧)	٢٣٫٩ (٧٥)	٣١٫١ (٨٨)	٣٢٫٣ (٩٠)	٣٤٫٩ (٩٥)	٣٤٫٦ (٩٤)	٣٤٫٥ (٩٤)	٣٣٫٩ (٩٣)	٢٨٫٦ (٨٣)	٢١٫٧ (٧١)	١٦٫٧ (٦٢)	٣٤٫٩ (٩٥)
نێونجی بەرزترین پلە	−٦٫٠ (٢١)	−٢٫٧ (٢٧)	٢٫٢ (٣٦)	١١٫٢ (٥٢)	١٧٫٥ (٦٤)	٢١٫٠ (٧٠)	٢٣٫١ (٧٤)	٢٢٫٦ (٧٣)	١٧٫١ (٦٣)	١٠٫٤ (٥١)	٠٫٠ (٣٢)	−٤٫٥ (٢٤)	٩٫٣ (٤٩)
نێونجی ڕۆژانە	−١٠٫٤ (١٣)	−٧٫٦ (١٨)	−٢٫٥ (٢٨)	٥٫٤ (٤٢)	١١٫٥ (٥٣)	١٥٫٥ (٦٠)	١٧٫٧ (٦٤)	١٦٫٩ (٦٢)	١١٫٤ (٥٣)	٥٫١ (٤١)	−٤٫١ (٢٥)	−٨٫٨ (١٦)	٤٫٢ (٤٠)
نێونجی کەمترین پلە	−١٤٫٨ (٥)	−١٢٫٥ (١٠)	−٧٫٢ (١٩)	−٠٫٥ (٣١)	٥٫٤ (٤٢)	٩٫٩ (٥٠)	١٢٫٣ (٥٤)	١١٫٣ (٥٢)	٥٫٨ (٤٢)	−٠٫٢ (٣٢)	−٨٫٢ (١٧)	−١٣٫١ (٨)	−١٫٠ (٣٠)
کەمترین پلەی تۆمارکراو	−٤٤٫٤ (−٤٨)	−٤٦٫١ (−٥١)	−٣٦٫١ (−٣٣)	−٢٥٫٦ (−١٤)	−١٢٫٢ (١٠)	−١٫١ (٣٠)	٠٫٦ (٣٣)	−١٫٢ (٣٠)	−١١٫٧ (١١)	−٢٥٫٠ (−١٣)	−٣٤٫١ (−٢٩)	−٤٨٫٣ (−٥٥)	−٤٨٫٣ (−٥٥)
کەمترین پلەی تۆمارکراوی ساردیی با	−٥٢٫٨	−٥٠٫٧	−٤٤٫٦	−٣٧٫٥	−١٤٫٥	٠٫٠	٠٫٠	−٣٫٧	−١٣٫٣	−٣٤٫٣	−٥٠٫٢	−٥٥٫٥	−٥٥٫٥
نێونجی بارین میلیمەتر	٢١٫٧ (٠٫٨٥)	١٢٫٠ (٠٫٤٧)	١٥٫٨ (٠٫٦٢)	٢٨٫٨ (١٫١٣)	٤٦٫١ (١٫٨١)	٧٧٫٥ (٣٫٠٥)	٩٣٫٨ (٣٫٦٩)	٦١٫٩ (٢٫٤٤)	٤٣٫٥ (١٫٧١)	٢١٫٧ (٠٫٨٥)	١٨٫٠ (٠٫٧١)	١٥٫٠ (٠٫٥٩)	٤٥٥٫٧ (١٧٫٩٤)
نێونجی باران بارین میلیمەتر	١٫٣ (٠٫٠٥)	٠٫٧٦ (٠٫٠٣)	١٫٧ (٠٫٠٧)	١٤٫٥ (٠٫٥٧)	٤٠٫٧ (١٫٦)	٧٧٫٥ (٣٫٠٥)	٩٣٫٨ (٣٫٦٩)	٦١٫٨ (٢٫٤٣)	٤٢٫٤ (١٫٦٧)	١٠٫٩ (٠٫٤٣)	١٫٦ (٠٫٠٦)	٠٫٧٣ (٠٫٠٣)	٣٤٧٫٨ (١٣٫٦٩)
نێونجی بەفر بارین سانتیمەتر	٢٤٫٥ (٩٫٦)	١٣٫٤ (٥٫٣)	١٧٫٤ (٦٫٩)	١٥٫٣ (٦)	٤٫٩ (١٫٩)	٠٫٠ (٠)	٠٫٠ (٠)	٠٫٠ (٠)	١٫٠ (٠٫٤)	١١٫٦ (٤٫٦)	١٩٫١ (٧٫٥)	١٦٫٤ (٦٫٥)	١٢٣٫٥ (٤٨٫٦)
نێونجی ژمارەی ڕۆژەکانی بارین (≥ ٠.٢ mm)	١١٫٠	٧٫٩	٨٫٣	٨٫٨	١١٫٠	١٤٫٢	١٤٫٦	١١٫١	٩٫٨	٨٫٠	٨٫٨	٩٫٤	١٢٢٫٩
نێونجی ژمارەی ڕۆژە باراناوییەکان (≥ ٠.٢ mm)	١٫١	٠٫٨٣	١٫٤	٥٫٩	١٠٫٥	١٤٫٢	١٤٫٦	١١٫١	٩٫٦	٥٫٦	١٫٥	٠٫٧٥	٧٧٫٣
نێونجی ژمارەی ڕۆژە بەفراوییەکان (≥ ٠.٢ cm)	١٠٫٧	٧٫٧	٧٫٧	٤٫٢	١٫٢	٠٫٠	٠٫٠	٠٫٠	٠٫٥٠	٣٫٢	٧٫٩	٩٫٣	٥٢٫٤
نێونجی شێی ڕێژەیی (٪)	٦٥٫٢	٦١٫٢	٥٦٫٥	٤٢٫٩	٤٠٫٤	٤٨٫٢	٥٢٫٦	٥١٫٤	٥٠٫١	٥٠٫٥	٦٤٫٧	٦٥٫٤	٥٤٫١
نێونجی مانگانەی سەعاتەکانی ھەتاوی بوون	١٠٠٫٨	١٢١٫٧	١٧٦٫٣	٢٤٤٫٢	٢٧٩٫٩	٢٨٥٫٩	٣٠٧٫٥	٢٨٢٫٣	١٩٢٫٧	١٧٠٫٨	٩٨٫٤	٨٤٫٥	٢٬٣٤٤٫٨
ڕێژەی سەدیی ئەگەری ھەتاوی بوون	٤٠٫٢	٤٤٫١	٤٨٫١	٥٨٫٢	٥٦٫٨	٥٦٫٢	٦٠٫٢	٦١٫٥	٥٠٫٤	٥٢٫٠	٣٧٫٨	٣٦٫٠	٥٠٫١
سەرچاوە: Environment Canada, Weather Atlas

سەرچاوەکان

ئەم سەرچاوانە لە وتارەکە دەردەکەون، بەڵام ئەم لیستە تەنھا لەسەر ئەم پەڕەیە دەردەکەوێت.

w = {};
math_mod = require( "Module:Math" );
wbc = require( "Module:Weather box/colors" );
local supportKurdish = require("Module:Numeral converter").convert

function checkFlag( flag )
    if flag == nil then
        return nil;
    elseif type( flag ) == 'boolean' then
        return flag;        
    elseif type( flag ) == 'string' then
        flag = flag:lower();
        if flag == '0' or flag == 'false' or
                flag == '' or flag == 'no' or
                flag == 'n' then
            return false;
        else
            return true;
        end
    else
        return error( 'جۆری ئاڵا نادروستە' );
    end    
end

function w.buildRow( frame )
    local mode = (frame.args.mode or 'basic'):lower();
    local group_name = frame.args.group_name;
    local first_value_string, second_value_string;
    local first_value_number, second_value_number, color_values;
    local color_scheme = frame.args.color_scheme or 't';
    local scale_factor = math_mod._cleanNumber( frame.args.scale_factor) or 1;
    local date_mode = checkFlag( frame.args.date_mode or false );
    local label = frame.args.label or '';
    local annual_mode = (frame.args.annual_mode or 'avg'):lower();
    local include_space = checkFlag( frame.args.include_space or true );
    local second_line = checkFlag( frame.args.second_line ) or false;
    local prefer_cm = checkFlag( frame.args.prefer_cm ) or false;
    local result;

    local pframe = frame:getParent();
    local imperial_first = checkFlag( frame.args['imperial first'] );
    if imperial_first == nil then imperial_first = checkFlag( pframe.args['imperial first'] ); end
        
    local metric_first = checkFlag( frame.args['metric first'] );
    if metric_first == nil then metric_first = checkFlag( pframe.args['metric first'] ); end

    local single_line = checkFlag( frame.args['single line'] );
    if single_line == nil then single_line = checkFlag( pframe.args['single line'] ); end

    if imperial_first == nil and metric_first ~= nil then
        imperial_first = not metric_first;
    else
        imperial_first = true;
    end    

    if mode == 'basic' then
        first_value_string, first_value_number = getInputs( pframe, group_name, 
            nil, include_space );
        second_value_string = nil;
        second_value_number = nil;
    elseif mode == 'temperature' then
        first_value_string, first_value_number = getInputs( pframe, group_name, 
            {'C'}, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name, 
            {'F'}, include_space );
        first_value_string, first_value_number, second_value_string, second_value_number =
            reconcileTemperature( first_value_string, first_value_number, 
                second_value_string, second_value_number )
    elseif mode == "precipitation" then
        first_value_string, first_value_number, variant = getInputs( pframe, group_name, 
            {'cm', 'mm'}, include_space );
        second_value_string, second_value_number = getInputs( pframe, group_name, 
            {'inch'}, include_space );        
        first_value_string, first_value_number, second_value_string, second_value_number,
            variant =
            reconcilePrecipitation( first_value_string, first_value_number, 
                second_value_string, second_value_number, variant, prefer_cm )
    else
        error( 'دۆخی داواکراو نەناسرایەوە' );
    end  
    
    local good = false;
    for i = 1,13 do
        if first_value_string[i] ~= nil and first_value_string[i] ~= '' then
            good = true;
            break;
        end
    end        
    if not good then
        return '';
    end

    if first_value_string[13] == nil or first_value_string[13] == '' then
        first_value_string[13], first_value_number[13] = getAnnualValue( first_value_number, annual_mode );
    end
    if second_value_string ~= nil then
        if second_value_string[13] == nil or second_value_string[13] == '' then
            second_value_string[13], second_value_number[13] = getAnnualValue( second_value_number, annual_mode );
        end
        if mode == 'precipitation' then
            for i = 1,12 do
                if variant[i] ~= 0 then
                    variant[13] = variant[i];
                    break;
                end
            end
        end                        
    end   

    color_scheme = wbc.interpret_color_code( color_scheme );

    color_values = {};
    month_adj = { 31/30, 28/30, 31/30, 1, 31/30, 1, 
        31/30, 31/30, 1, 31/30, 1, 31/30, 12.175 };
    local adj;
    for i = 1,13 do        
        if first_value_number[i] ~= nil and first_value_number[i] ~= -9999 then
            adj = scale_factor;
            if date_mode then 
                adj = adj / month_adj[i];
            end
            if mode == "precipitation" then
                if variant[i] == 1 then
                    adj = adj * 10;
                end
            end
            table.insert( color_values, color_scheme( first_value_number[i] * adj ) );               
        else
            table.insert( color_values, color_scheme( nil ) );
        end
    end
    
    local lang = mw.getContentLanguage();
    for i = 1,13 do
        if first_value_number[i] ~= nil and first_value_number[i] ~= -9999 then
            if math.abs(first_value_number[i]) >= 1000 then
                first_value_string[i] = lang:formatNum( math.abs(first_value_number[i]) );
                if first_value_number[i] < 0 then
                    first_value_string[i] = '−' .. first_value_string[i];
                end
            elseif first_value_number[i] < 0 then
                first_value_string[i] = '−' .. first_value_string[i]:sub(2);
            end
        end
        if second_value_number ~= nil then
            if second_value_number[i] ~= nil and second_value_number[i] ~= -9999 then
                if math.abs(first_value_number[i]) >= 1000 then
                    second_value_string[i] = lang:formatNum( math.abs(second_value_number[i]) );
                    if second_value_number[i] < 0 then
                        second_value_string[i] = '−' .. second_value_string[i];
                    end
                elseif second_value_number[i] < 0 then
                    second_value_string[i] = '−' .. second_value_string[i]:sub(2);
                end
            end
        end
    end              

    if imperial_first and second_value_string ~= nil then
        local t = first_value_string;
        first_value_string = second_value_string;
        second_value_string = t;
    end    

    if not single_line then
        if second_line and second_value_string ~= nil then
            first_value_string = second_value_string;
        end
        second_value_string = nil;
    end

    return makeLine( label, first_value_string, second_value_string, color_values, color_scheme );
end    

function makeLine( label, first_value_string, second_value_string, color_values, color_scheme )
    local result, color_str, value_str;
    
    result = {'|- \n! height="16" | ', label,  "\n"}
    for i = 1,13 do
        color_str = color_values[i];

        if i == 13 then
            table.insert( result, table.concat( {'|style="', color_str, ' border-right-width:medium" | '} ) );
        else
            table.insert( result, table.concat( {'|style="', color_str, '" | '} ) );
        end                

        value_str = first_value_string[i];
        if value_str ~= '' and value_str ~= nil then 
            table.insert( result, supportKurdish("ckb", value_str, true) );
            if second_value_string ~= nil then
                value_str = second_value_string[i];
                if value_str ~= '' and value_str ~= nil then 
                    table.insert( result, "<br /> (" .. supportKurdish("ckb", value_str, true) .. ")" );
                end    
            end
        else
            table.insert( result, '—' );
        end        
    
        table.insert( result, "\n" ); 
    end
    
    return table.concat( result );
end  

function getInputs( frame, group_name, suffix, include_space )
    local month_names = { 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'year' };
    local str, str2, val;
    
    local output_string = {};
    local output_value = {};
    local variant = {};
    if suffix == nil then
        for _, mon in ipairs( month_names ) do
            if include_space then
                str = ( frame.args[ mon .. ' ' .. group_name ] or '' );
            else
                str = ( frame.args[ mon .. group_name ] or '' );
            end                
            val, str2 = math_mod._cleanNumber( supportKurdish("en", str) );
            if val ~= nil then 
                table.insert( output_string, supportKurdish("ckb", str2, true) );
                table.insert( output_value, val );
            else
                table.insert( output_string, supportKurdish("ckb", str, true) );
                table.insert( output_value, -9999 );
            end                
        end
    else
        local updated = false;
        for _, mon in ipairs( month_names ) do
            updated = false;
            for i, suf in ipairs( suffix ) do
                if include_space then
                    str = frame.args[ mon .. ' ' .. group_name .. ' ' .. suf ];
                else
                    str = frame.args[ mon .. group_name .. ' ' .. suf ];
                end                    
                if str ~= nil and str ~= '' then 
                    val, str2 = math_mod._cleanNumber( supportKurdish("en", str) );
                    if val ~= nil then 
                        table.insert( output_string, supportKurdish("ckb", str2, true) );
                        table.insert( output_value, val );
                    else
                        table.insert( output_string, supportKurdish("ckb", str, true) );
                        table.insert( output_value, -9999 );
                    end                
                    table.insert( variant, i );
                    updated = true;
                    break;
                end                
            end
            if not updated then
                table.insert( output_string, '' );
                table.insert( output_value, -9999 );
                table.insert( variant, 0 );
            end            
        end
    end
        
    return output_string, output_value, variant;
end

function getAnnualValue( values, mode )
    local total = 0;
    local val = 0;
    
    if mode == 'avg' or mode == 'sum' then
        local p1, p2;
        p1 = 0;
        for i = 1, 12 do
            val = values[i];
            if val == -9999 then
                return '', -9999;
            end            
            
            p2 = math_mod._precision( val );
            if p2 > p1 then
                p1 = p2;
            end
            
            total = total + val;
        end
        if mode == 'avg' then
            total = math_mod._round( total / 12, p1 + 1 );
        end
        return tostring( total ), total;
    elseif mode == 'min' then
        local min_val = nil;
        for i = 1, 12 do
            val = values[i];
            if val ~= -9999 then
                if min_val == nil or val < min_val then
                    min_val = val;
                end                
            end            
        end
        return tostring( min_val ), min_val;
    elseif mode == 'max' then
        local max_val = nil;
        for i = 1, 12 do
            val = values[i];
            if val ~= -9999 then
                if max_val == nil or val > max_val then
                    max_val = val;
                end                
            end            
        end
        return tostring(max_val), max_val;
    else
        error( 'دۆخی ساڵانە نەزانراوە' );
    end
end        

function reconcileTemperature( C_degree_strings, C_degree_values, F_degree_strings, F_degree_values )
    local p;
    for i = 1,13 do
        if C_degree_strings[i] == '' then
            if F_degree_values[i] ~= -9999 then
                p = math.max( 0, math_mod._precision( F_degree_strings[i] ) );
                C_degree_values[i] = math_mod._round( (F_degree_values[i] - 32)*5/9, p );
                C_degree_strings[i] = tostring( C_degree_values[i] );
            end            
        elseif F_degree_strings[i] == '' then
            if C_degree_values[i] ~= -9999 then
                p = math.max( 0, math_mod._precision( C_degree_strings[i] ) );
                F_degree_values[i] = math_mod._round( C_degree_values[i]*9/5 + 32, p );
                F_degree_strings[i] = tostring( F_degree_values[i] );
            end                        
        end        
    end
    return C_degree_strings, C_degree_values, F_degree_strings, F_degree_values;
end    

function reconcilePrecipitation( M_degree_strings, M_degree_values, 
        I_degree_strings, I_degree_values, variant, prefer_cm )
    local p;
    
    local v_class = 0;
    for i = 1,13 do
        if variant[i] == 1 then
            v_class = 1;
        elseif variant[i] == 2 then
            v_class = 2;
        end
    end
    if v_class == 0 then
        if prefer_cm then
            v_class = 1;
        else
            v_class = 2;
        end        
    end
    for i = 1,13 do
        if M_degree_strings[i] == '' then
            if I_degree_values[i] ~= -9999 then
                if v_class == 1 then 
                    p = math.max( 0, math_mod._precision( I_degree_strings[i] ) );
                    M_degree_values[i] = math_mod._round( I_degree_values[i]*2.54, p );
                    variant[i] = v_class;
                else 
                    p = math.max( 0, math_mod._precision( I_degree_strings[i] ) ) - 1;
                    M_degree_values[i] = math_mod._round( I_degree_values[i]*25.4, p );
                    variant[i] = v_class;
                end                
                M_degree_strings[i] = tostring( M_degree_values[i] );
            end            
        elseif I_degree_strings[i] == '' then
            if M_degree_values[i] ~= -9999 then
                if variant[i] == 1 then
                    p = math.max( 0, math_mod._precision( M_degree_strings[i] ) ) + 1;
                    I_degree_values[i] = M_degree_values[i]/2.54;
                else
                    p = math.max( 0, math_mod._precision( M_degree_strings[i] ) ) + 2;
                    I_degree_values[i] = M_degree_values[i]/25.4;
                end                    
                I_degree_values[i] = math_mod._round( I_degree_values[i], p );
                I_degree_strings[i] = tostring( I_degree_values[i] );
            end                        
        end  
    end
    return M_degree_strings, M_degree_values, I_degree_strings, I_degree_values, variant;
end    

return w;