Welcome! My Account | Logout

TaxCode

BasicRate
AllowanceRate
DaysAbsent
HoursLate
HoursOvertime

BasicPay
OvertimePay
OtherIncome
AllowancePay

RegularPay

SupplementaryPay

RegularPayForMonth
SSS
SSSER
SSSEC
PHIC
PHICER
HDMF
HDMFER

NetRegularPay

WTax

L_SSSBB
L_SSSAdj
L_SSS
L_SSSEB

L_PABB
L_PAAdj
L_PA
L_PAEB

NetPay

Trace

Payscript

Download Payscript

Trace of last calculation on Oct 05, 2024  11:44:48 AM
{
    
    numeric input var BasicRate = null [default:null PreviousPay.BasicRate];	
    numeric input var AllowanceRate = null [default:null PreviousPay.AllowanceRate];	

    
    numeric input var DaysAbsent = 0 [default:0];
    numeric input var HoursLate = 0 [default:0];
    numeric input var HoursOvertime = 0 [default:0];

    
    var WorkingDays
    {
        WorkingDays = 10;  
        if( True ['Monthly' PayPeriod.PrdType = 'Monthly'] )
            WorkingDays = 20;  
    }
}{
    
    numeric output var BasicPay = [...] [Round2([...] [null BasicRate - [...] [(null DaysAbsent * null BasicRate / null WorkingDays)] - [...] [(null HoursLate * null BasicRate / 160 [(null WorkingDays * 8)])]])];
    
    numeric output var OvertimePay = [...] [Round2([...] [null HoursOvertime * null BasicRate / 160 [(null WorkingDays * 8)]])];
    
    numeric input var OtherIncome = 0 [default:0];
    
    numeric output var AllowancePay = [...] [Round2([...] [null AllowanceRate - [...] [(null DaysAbsent * null AllowanceRate / null WorkingDays)] - [...] [(null HoursLate * null AllowanceRate / 160 [(null WorkingDays * 8)])]])];
}


numeric output var RegularPay = [...] [Round2([...] [null BasicPay + null AllowancePay])];
numeric output var SupplementaryPay = [...] [Round2([...] [null OvertimePay + null OtherIncome])];{
    
    numeric output var RegularPayForMonth = [...] [0 MonthPay.RegularPay + null RegularPay];

    
    vector var SSSBracket = null [GetSSSTableBracket()];

    
    
    
    numeric input var SSS
    {
        SSS = null [default:[...] [null SSSBracket.EECont - 0 MonthPay.SSS]];
    }
    numeric input var SSSER
    {
        SSSER = null [default:[...] [null SSSBracket.ERCont - 0 MonthPay.SSSER]];
    }
    numeric input var SSSEC
    {
        SSSEC = null [default:[...] [null SSSBracket.EREC - 0 MonthPay.SSSEC]];
    }

    
    vector var PHICBracket = null [GetPHICTableBracket()];

    
    
    
    numeric input var PHIC
    {
        PHIC = null [default:[...] [null PHICBracket.EECont - 0 MonthPay.PHIC]];
    }
    numeric input var PHICER
    {
        PHICER = null [default:[...] [null PHICBracket.ERCont - 0 MonthPay.PHICER]];
    }

    
    numeric input var HDMF
    {
      
      HDMF = null [default:[...] [Round2([...] [[...] [null RegularPayForMonth * 0.01] - 0 MonthPay.HDMF])]];

      
      if( False [null RegularPayForMonth >= 5000] )
        HDMF = Round2( RegularPayForMonth * 0.02 - MonthPay.HDMF );
    }

    numeric input var HDMFER
    {
      
      HDMFER = null [default:[...] [Round2([...] [[...] [null RegularPayForMonth * 0.01] - 0 MonthPay.HDMFER])]];

      
      if( False [null RegularPayForMonth >= 5000] )
        HDMFER = Round2( RegularPayForMonth * 0.02 - MonthPay.HDMFER );

      
      if( False [[...] [0 MonthPay.HDMFER + null HDMFER] > 100] )
        HDMFER = 100 - MonthPay.HDMFER;
    }
}

numeric output var NetRegularPay = [...] [Round2([...] [null RegularPay - null SSS - null PHIC - null HDMF])];{
    var TaxTable = 'Monthly' PayPeriod.PrdType;

    
    vector var WTaxExemptionBracket = ['Monthly' TabID,'010' ID,'Z' KeyCode,0 AmtExempt,0 AmtLvl01,0 AmtLvl02,833 AmtLvl03,2500 AmtLvl04,5833 AmtLvl05,11667 AmtLvl06,20833 AmtLvl07,41667 AmtLvl08,'Data' Type] [GetWTAXTableExemptionBracket(, )];
    var TaxExemption = 0 WTaxExemptionBracket.AmtExempt;

    
    var TaxableRegPay = [...] [null NetRegularPay - null TaxExemption]
    {
      if( False [null TaxableRegPay < 0] )
        TaxableRegPay = 0;
    }

    
    vector var WTaxBracket = null [GetWTAXTableTaxBracket(, , )];
    var TaxOnBracket = null WTaxBracket.WTAX;

    
    var TaxOnExcess = [...] [[...] [(null TaxableRegPay - null WTaxBracket[] + null SupplementaryPay)] * null WTaxBracket.PCTOVER];
}

numeric input var WTax
{
    WTax = null [default:[...] [Round2([...] [null TaxOnBracket + null TaxOnExcess])]];
}
;



var LoanTotal = 0
{{
        
        numeric output var L_SSSBB = null PreviousPay.L_SSSEB;

        
        numeric input var L_SSSAdj = 0 [default:0];

        
        numeric input var L_SSS = null [default:null PreviousPay.L_SSS]
        {
            var EB = [...] [null L_SSSBB + null L_SSSAdj - null L_SSS];

            
            if( False [null EB < 0] )
                L_SSS = L_SSSBB + L_SSSAdj;
        }

        
        numeric output var L_SSSEB = [...] [null L_SSSBB + null L_SSSAdj - null L_SSS];
    }
    LoanTotal = [...] [null LoanTotal + null L_SSS];
    ;{
        
        numeric output var L_PABB = null PreviousPay.L_PAEB;

        
        numeric input var L_PAAdj = 0 [default:0];

        
        numeric input var L_PA = null [default:null PreviousPay.L_PA]
        {
            var EB = [...] [null L_PABB + null L_PAAdj - null L_PA];

            
            if( False [null EB < 0] )
                L_PA = L_PABB + L_PAAdj;
        }

        
        numeric output var L_PAEB = [...] [null L_PABB + null L_PAAdj - null L_PA];
    }
    LoanTotal = [...] [null LoanTotal + null L_PA];
    ;
   
}









numeric output var NetPay = [...] [Round2([...] [null NetRegularPay + null SupplementaryPay - null WTax - null LoanTotal])];

return ;

/********************************************************************************
///Payscript: SampleMonthlyComputation1.payscript
///Scribe: sweldista.com
///Title:  Sample Monthly or Semi-monthly Net Pay Computation
///Summary: 
Computes NetPay based on a payscript that works on Semi-monthly and Monthly periods.

///Environment: Philippines.200901
///WorkingPeriods: Monthly, Semi-monthly
********************************************************************************/

{
    // rates
    numeric input var BasicRate = PreviousPay.BasicRate;	// semi-monthly or monthly rate
    numeric input var AllowanceRate = PreviousPay.AllowanceRate;	// semi-monthly or monthly rate

    // attendance
    numeric input var DaysAbsent = 0.0;
    numeric input var HoursLate = 0.0;
    numeric input var HoursOvertime = 0.0;

    // working days per month
    var WorkingDays
    {
        WorkingDays = 10;  // Semi-monthly - assumes 10 working days
        if( PayPeriod.PrdType = 'Monthly' )
            WorkingDays = 20;  // Monthly - assumes 20 working days
    }
}

{
    // basic pay
    numeric output var BasicPay = Round2( BasicRate - ( DaysAbsent * BasicRate / WorkingDays ) - ( HoursLate * BasicRate / ( WorkingDays * 8 ) ) );
    // overtime
    numeric output var OvertimePay = Round2( HoursOvertime * BasicRate / ( WorkingDays * 8 ) );
    // other income
    numeric input var OtherIncome = 0.0;
    // allowance pay
    numeric output var AllowancePay = Round2( AllowanceRate - ( DaysAbsent * AllowanceRate / WorkingDays ) - ( HoursLate * AllowanceRate / ( WorkingDays * 8 ) ) );
}

//
numeric output var RegularPay = Round2( BasicPay + AllowancePay );
numeric output var SupplementaryPay = Round2( OvertimePay + OtherIncome );

// sss, phic, hdmf
{
    // MonthPay.RegularPay gets the RegularPay for the month (excludes the current period)
    numeric output var RegularPayForMonth = MonthPay.RegularPay + RegularPay;

    // Get the SSSBracket based on RegularPayForMonth
    vector var SSSBracket = GetSSSTableBracket( RegularPayForMonth );

    // MonthPay.SSS and MonthPay.SSSER/MonthPay.SSSEC are the employee and employer contributions for the month (excludes the current period).
    // So, the contribution for the period should be derived from the difference of what the contribution of the month should be
    // and what has been deducted on the previous periods within the month.
    numeric input var SSS
    {
        SSS = SSSBracket.EECont - MonthPay.SSS;
    }
    numeric input var SSSER
    {
        SSSER = SSSBracket.ERCont - MonthPay.SSSER;
    }
    numeric input var SSSEC
    {
        SSSEC = SSSBracket.EREC - MonthPay.SSSEC;
    }

    // Get the PHICBracket based on RegularPayForMonth
    vector var PHICBracket = GetPHICTableBracket( RegularPayForMonth );

    // MonthPay.PHIC and MonthPay.PHICER are the employee and employer contributions for the month (excludes the current period).
    // So, the contribution for the period should be derived from the difference of what the contribution of the month should be
    // and what has been deducted on the previous periods within the month.
    numeric input var PHIC
    {
        PHIC = PHICBracket.EECont - MonthPay.PHIC;
    }
    numeric input var PHICER
    {
        PHICER = PHICBracket.ERCont - MonthPay.PHICER;
    }

    //
    numeric input var HDMF
    {
      // HDMF is 1% of regular pay
      HDMF = Round2( RegularPayForMonth * 0.01 - MonthPay.HDMF );

      // HDMF is 2% of regular pay when regular pay is 5000 or more
      if( RegularPayForMonth >= 5000 )
        HDMF = Round2( RegularPayForMonth * 0.02 - MonthPay.HDMF );
    }

    numeric input var HDMFER
    {
      // HDMF is 1% of regular pay
      HDMFER = Round2( RegularPayForMonth * 0.01 - MonthPay.HDMFER );

      // HDMF is 2% of regular pay when regular pay is 5000 or more
      if( RegularPayForMonth >= 5000 )
        HDMFER = Round2( RegularPayForMonth * 0.02 - MonthPay.HDMFER );

      // check that the total for the month will not exceed 100
      if( MonthPay.HDMFER + HDMFER > 100 )
        HDMFER = 100 - MonthPay.HDMFER;
    }
}
// basis for withholding tax
numeric output var NetRegularPay = Round2( RegularPay - SSS - PHIC - HDMF );

{
    var TaxTable = PayPeriod.PrdType;

    // TaxExemption depends on the TaxCode of the Employee
    vector var WTaxExemptionBracket = GetWTAXTableExemptionBracket( TaxTable, TaxCode );
    var TaxExemption = WTaxExemptionBracket.AmtExempt;

    // Compute TaxableRegPay by deducting TaxExemption from NetRegularPay
    var TaxableRegPay = NetRegularPay - TaxExemption
    {
      if( TaxableRegPay < 0 )
        TaxableRegPay = 0;
    }

    // TaxOnBracket and WTaxBracket are based on TaxableRegPay only (without SupplementaryPay)
    vector var WTaxBracket = GetWTAXTableTaxBracket( TaxTable, TaxCode, TaxableRegPay );
    var TaxOnBracket = WTaxBracket.WTAX;

    // TaxOnExcess is based on TaxableRegPay and SupplementaryPay minus the WTaxBracket of the TaxCode
    var TaxOnExcess = ( TaxableRegPay - WTaxBracket[ TaxCode ] + SupplementaryPay ) * WTaxBracket.PCTOVER;
}
// WTax is the sum of TaxOnBracket and TaxOnExcess
numeric input var WTax
{
    WTax = Round2( TaxOnBracket + TaxOnExcess );
}
;

/******************** THIS BLOCK IS FOR LOANS - START ****************************/
//
var LoanTotal = 0.0
{
   /* SSS LOAN - START */
    {
        // Beginning balance is derived from the ending balance of the previous pay period
        numeric output var L_SSSBB = PreviousPay.L_SSSEB;

        // Input any new SSS loan in L_SSSAdj
        numeric input var L_SSSAdj = 0.0;

        // Loan deduction defaults to the deduction of the previous pay period
        numeric input var L_SSS = PreviousPay.L_SSS
        {
            var EB = L_SSSBB + L_SSSAdj - L_SSS;

            // Do not let the Ending Balance be negative
            if( EB < 0.0 )
                L_SSS = L_SSSBB + L_SSSAdj;
        }

        // Ending balance is equal to the Beginning Balance plus any new loan minus any Deduction
        numeric output var L_SSSEB = L_SSSBB + L_SSSAdj - L_SSS;
    }
    LoanTotal = LoanTotal + L_SSS;
    ;
   /* SSS LOAN - END */
    
   /* PAYROLL ADVANCES/LOANS - START*/
    {
        // Beginning balance is derived from the ending balance of the previous pay period
        numeric output var L_PABB = PreviousPay.L_PAEB;

        // Input any new Payroll Advance in L_PAAdj
        numeric input var L_PAAdj = 0.0;

        // Loan deduction defaults to the deduction of the previous pay period
        numeric input var L_PA = PreviousPay.L_PA
        {
            var EB = L_PABB + L_PAAdj - L_PA;

            // Do not let the Ending Balance be negative
            if( EB < 0.0 )
                L_PA = L_PABB + L_PAAdj;
        }

        // Ending balance is equal to the Beginning Balance plus any new loan minus any Deduction
        numeric output var L_PAEB = L_PABB + L_PAAdj - L_PA;
    }
    LoanTotal = LoanTotal + L_PA;
    ;
   /* PAYROLL ADVANCES/LOANS - END*/
}

/******************** THIS BLOCK IS FOR LOANS - END ****************************/

// net pay

// REPLACED THIS LINE TO SUBTRACT LOANS
// numeric output var NetPay = Round2( NetRegularPay + SupplementaryPay - WTax );  // not used

// 
numeric output var NetPay = Round2( NetRegularPay + SupplementaryPay - WTax - LoanTotal);

return NetPay;

Note: The sample paysheets and payscripts are meant for illustration purposes only.
It is the user's responsibility to verify compliance with government regulations and company policies.

kept trying o include ur formula made about loans and advances but i cant add for additional columns for loans and deductions. can u help me with this problem? thanks.(Posted as a reply to: kept trying o include ur formula made about loans and advances but i cant add for additional columns for loans and deductions. can u help me with this problem? thanks.)View Parent Topic

Ang Unang Sweldista

<<<1 >>>

Ang Unang Sweldista

2011-May-16

0 replies

Rating: +1

Hi,

Hope this helps you:
1. I just added the block contained in
/******************** THIS BLOCK IS FOR LOANS ****************************/
2. I also changed the formula for NetPay to subtract LoanTotal (pls. see last lines of payroll formula)

If you want to add more loans, just add another block of formula similar to how I added SSS loans and Payroll Advances.

That's it!

<<<1 >>>

1 message