Login   Register  
PHP Classes
elePHPant
Icontem

File: FunctionFit.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Jose Gomez  >  Linear Fit  >  FunctionFit.php  >  Download  
File: FunctionFit.php
Role: Class source
Content type: text/plain
Description: Functional fitting class
Class: Linear Fit
Perform linear regression on a set of data values
Author: By
Last change:
Date: 8 months ago
Size: 5,320 bytes
 

Contents

Class file image Download
<?php
    
/*
     * FunctionFit
     *
     * This class perform linear least squres fitting to a linear
     * combination of user defined functions in the form
     * y=a0+a1*F1(X)+ ... + an*Fn(X)
     *
     * Copyright (C) 2013 José Gómez López
      * 
     * This program is free software: you can redistribute it and/or modify
     * it under the terms of the GNU General Public License as published by
     * the Free Software Foundation, either version 3 of the License, or
     * (at your option) any later version.
     * 
     * This program is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     * GNU General Public License for more details.
     * 
     * You should have received a copy of the GNU General Public License
     * along with this program.  If not, see <http://www.gnu.org/licenses/>.
     * 
     */
    
require_once('LinearFit.php');

    
/**
     * FunctionFit
     *
     * @author José Gómez López <jose.gomez.lopez@gmail.com>
     *
     * This class perform linear least squres fitting to a linear
     * combination of user defined functions in the form
     * y=a0+a1*F1(X)+ ... + an*Fn(X)
     * It uses LinearFit class the independent variable vector is transformated
     * in an array which elements are its function values 
     **/
    
class FunctionFit extends LinearFit
    
{
        private 
$X;
        private 
$Y;
        private 
$Func;
        private 
$Size;
        private 
$Vars;
        private 
$nY;

        
/**
         * Initialize data
         *
         * Initialize internal data and prepare for next calculation
         **/
        
protected function init()
        {
            
$this->X=array();
            
$this->Y=array();
            
$this->Func=array();
            
$this->Conf=array();
            
$this->Size=0;
            
$this->Vars=0;
            
$this->nY=0;
        } 
// End of init()

        /**
         * Constructor
         *
         * Create a new object
         **/
        
public function __construct ()
        {
             
$this->init();
        } 
// End of function __construct

        /**
         * Set Functions
         *
         * sets foron array set for fitting
         * @param array $aFunction array of functions
         **/
         
public function SetFunctions($aFunction)
         {
             if (
count($this->Func) > 0)
            {
                
$this->Coeffs=array();
                
$this->Conf=array();
                
parent::init();
            }
            
$this->Func=$aFunction;
            if (
$this->Size>0)
            {
                for (
$i=0$i<count($this->Func); $i++)
                {
                    for (
$j=0$j<count($this->X); $j++)
                    {
                        
$adX[$j][$i]=call_user_func($this->Func[$i],$this->X[$j]); 
                    }
                }
                
parent::SetData($adX$this->Y);
            }
         }

        
/**
         * Add New data
         *
         * Add new data to the fitting process
         * @param array double $adX vector with values for each variable
         * @param double $dY value corresponding to $adX
         **/
        
public function AddData ($adX$dY)
        {
            if (
$this->Size>&& $this->Vars>&& $this->Vars != count($adX))
            {
                throw new 
Exception('# of variables of stored data and input vector is different'); 
            }
            else 
            {
                
$this->Size++;
                
$this->Vars=count($adX);
                if (
is_array($dY))
                {
                    if (
$this->nY==0)
                    {
                        
$this->nY=count($dY);
                    }
                    if (
count($dY) != $this->nY )
                    {
                        throw new 
Exception('Number of Y elements is wrong'); 
                    }

                }
                else
                {
                    if (
$this->nY==0)
                    {
                        
$this->nY=1;
                    }
                    if (
$this->nY != 1)
                    {
                        throw new 
Exception('Y must be an array'); 
                    }
                }
                
$this->Y[]=$dY;
                
$this->X[]=$adX;
                if (
count($this->Func)>0)
                {
                    for (
$i=0$i<count($this->Func); $i++)
                    {
                        
$adXr[$i]=call_user_func($this->Func[$i],$adX); 
                    }
                    
parent::AddData($adXr,$dY);
                }
            } 
// End of if
        
// End of AddData

        /**
         * Set New data 
         *
         * Set new data destroying previous data
         * @param array double $adX matrix with a set of X values 
         * @param array double $adY vector of values corresponding to each row of $adX
         **/
        
public function SetData($adX$adY)
        {
            if (
count($adX) != count($adY))
            {
                throw new 
Exception('The size of both arrays should be the same'); 
            }
            else
            {
                
$this->Size=count($adX);
                if (
is_array($adX[0]))
                {
                    
$this->Vars=count($adX[0]);
                }
                else
                {
                    
$this->Vars=1;
                }
                
$this->Y=$adY;
                
$this->X=$adX;
                if ( 
is_array($adY[0]) )
                {
                    
$this->nY=count($adY[0]);
                }
                else
                {
                    
$this->nY=1;
                }
                if (
count($this->Func)>0)
                {
                    if (
count($this->X)>0)
                    {
                        for (
$i=0$i<count($this->Func); $i++)
                        {
                            for (
$j=0$j<count($adX); $j++)
                            {
                                
$adXr[$j][$i]=call_user_func($this->Func[$i],$adX[$j]); 
                            }
                        }
                        
parent::SetData($adXr$this->Y);
                    }
                }
            } 
// End of if
        
// End of setData

        /**
         * Get values from an input
         *
         * Get the values of an input using the calculated coefficients
         * @param array double $adX input to get the values
         **/
        
public function GetValues($adXo)
        {
            if (
count($this->Func)>0)
            {
                if (!
is_array($adXo))
                {
                    
$adXin=array($adXo);
                }
                else
                {
                    
$adXin=$adXo;
                }
                for (
$i=0$i<count($this->Func); $i++)
                {
                    for (
$j=0$j<count($adXin); $j++)
                    {
                        
$adXr[$j][$i]=call_user_func($this->Func[$i],$adXin[$j]); 
                    }
                }

                if (!
is_array($adXo))
                {
                    return 
parent::GetValues($adXr)[0];
                }
                else
                {
                    return 
parent::GetValues($adXr);
                }
            }
        }
    } 
// End of class FunctionFit
?>