www.gusucode.com > mbcdata 工具箱 matlab 源码程序 > mbcdata/@cgoppoint/addfactor.m

    function p = addfactor(p,factor,data,varargin)
% p = addfactor(p,ptrlist,[data]) adds factor indexed by ptr
% p = addfactor(p,namelist,[data]) adds named factors. namelist is single name or cell array.
%  data is empty or not present - add blank factors
%  data is matrix - bolt data to existing data
%  data is cell array - set ranges of factors
% p = addfactor(...,property,value,...) sets property/value pairs for the new factors
%
% For ptrlist input, factor_type is set to 'input' for value expressions, 
%   'output' for non-value expressions;
% For namelist input, all factor_types are set to 'input'
% To override these defaults, use p = addfactor(...,'factor_type','type')
%
% Range and tolerance are calculated for new factors.

%  Copyright 2000-2008 The MathWorks, Inc. and Ford Global Technologies, Inc.



nf = length(p.ptrlist);
np = get(p,'numpoints');
olddata = p.data;
argsused = 1;
if nargin>2
    dataarg = data;
end

if nargin==1
    data = olddata;
    
elseif (length(factor)==1) && isa(factor,'xregpointer') && isvalid(factor(1)) && isa(factor.info,'cglookup') && ~nf && ...
        (nargin==2 || ~isnumeric(data))
    if nargin>2 && ischar(data) && strcmpi(data,'fill')
        fillopt = 'fill';
        argsused = 3;
    else
        fillopt = '';
        argsused = 2;
    end
    [p,data] = create_from_table(p,factor,fillopt);
            
elseif isempty(factor)
    if nargin>2 && isempty(data)
        argsused = 3;
    else
        argsused = 2;
    end
    data = olddata;
    
else
    if ischar(factor)
        factor = {factor};
    end
    
    if nargin==2
        argsused = 2;
    elseif (nargin>2) && ischar(data)
        argsused = 2;
    else
        argsused = 3;
    end
    
    %check 'factor' is in a valid form - allow cell, pointer list
    if iscell(factor)
        for i = 1:length(factor)
            if ~ischar(factor{i}) && ~isempty(factor{i})
                error(message('mbc:cgoppoint:InvalidValue'));
            end
        end
    elseif isa(factor,'xregpointer')
        for i = 1:length(factor)
            if ~ (isa(factor(i),'xregpointer'))
                error(message('mbc:cgoppoint:InvalidValue1'));
            end
        end
    else
        error(message('mbc:cgoppoint:InvalidValue2'));
    end
    
    %check 'data' is in a valid form - empty, matrix or cell
    range = []; constant = [];
    if (argsused<3) || isempty(data)
        if (argsused>2) && iscell(data) %empty cell - get default ranges
            range = cell(1,length(factor));
            for i = 1:length(factor)
                range{i} = i_eval(factor(i).info);
            end
        end
        data = [olddata zeros(np,length(factor))];
    elseif iscell(data)
        if length(factor)~=length(data)
            error(message('mbc:cgoppoint:InvalidValue3'));
        else
            range = data;
        end
        data = [olddata zeros(np,length(factor))];
    elseif isnumeric(data)
        if size(data,2)~=length(factor)
            if size(data,1)==length(factor)
                data = data';
            else
                error(message('mbc:cgoppoint:InvalidValue4'));
            end
        end
        if size(data,1)==1
            constant = data;
            if nf && np
                data = [olddata repmat(data,np,1)];
            end
        else
            if nf && np
                if size(data,1)~=np
                    error(message('mbc:cgoppoint:InvalidValue5'));
                else
                    data = [olddata data];
                end
            elseif nf && ~np
                data = [repmat(get(p,'constant'),size(data,1),1) data];
            elseif ~nf
                %leave data as it is
            end
        end
    end
        
    nf2 = length(factor);
    % Don't need to do anything with rules selection or outliers.
    if iscell(factor)
        p.orig_name = [p.orig_name factor];
        p.factor_type = [p.factor_type ones(1,nf2)]; % inputs
        p.overwrite = [p.overwrite ones(1,nf2)]; % overwrite by default
        p.group = [p.group zeros(1,nf2)];
        p.grid_flag = [p.grid_flag zeros(1,nf2)];
        p.range = [p.range cell(1,nf2)];
        p.constant = [p.constant zeros(1,nf2)];
        p.tolerance = [p.tolerance zeros(1,nf2)];
        p.created_flag = [p.created_flag zeros(1,nf2)]; 
        for i = 1:nf2
            p.ptrlist = [p.ptrlist xregpointer];
            p.units = [p.units {''}];
            p.linkptrlist = [p.linkptrlist xregpointer];
        end
    elseif isa(factor,'xregpointer')
        p.ptrlist = [p.ptrlist factor];
        p.orig_name = [p.orig_name cell(1,nf2)];
        p.group = [p.group zeros(1,nf2)];
        if ~isempty(range)
            p.range = [p.range range];
            p.grid_flag = [p.grid_flag ones(1,nf2)];
        else
            p.range = [p.range cell(1,nf2)];
            p.grid_flag = [p.grid_flag zeros(1,nf2)];
        end
        if ~isempty(constant)
            p.constant = [p.constant constant];
        else
            p.constant = [p.constant zeros(1,nf2)];
        end
        p.tolerance = [p.tolerance zeros(1,nf2)];
        p.created_flag = [p.created_flag -ones(1,nf2)]; % created from cage
        for i = 1:nf2
            if ~isvalid(factor(i)) || factor(i).isa('cgvariable')
                p.factor_type = [p.factor_type 1]; % input
                p.overwrite = [p.overwrite 1]; 
            else
                p.factor_type = [p.factor_type 2]; % output
                p.overwrite = [p.overwrite 0]; 
            end
            p.units = [p.units {''}];
            p.linkptrlist = [p.linkptrlist xregpointer];
        end
    end
end

p.data = data;
if nargin>argsused
    if (argsused == 2) && ischar(dataarg)
        args = {dataarg,varargin{:}};
    else
        args = {varargin{:}};
    end
    if nf
        p = set(p, nf+1:length(p.ptrlist),args{:});
    else
        p = set(p,args{:});
    end
end



function [p,data] = create_from_table(p,tptr,do_fill)
tbl = tptr.info;
if ~hasinportperaxis(tbl)
    %Unable to perform this action if table doesn't have a single inport
    %for each axis.
    data = [];
    return
end

pInp = getinports(tbl);
nInp = length(pInp);
inp_set = setinportsforcells(tbl);
if ~inp_set
    % Add empty columns for inports
    data = zeros(0, nInp);
    inpVal = cell(1, nInp);
else
    % Grid over inport to each axis
    inpVal = pveceval(pInp, @getvalue);
    colVals = cell(1, nInp);
    [colVals{:}] = ndgrid(inpVal{:});
    data = zeros(numel(colVals{1}), nInp);
    for n = 1:nInp
        data(:, n) = colVals{n}(:);
    end
end

% Don't need to do anything with rules selection or outliers.
p.orig_name = [p.orig_name cell(1,nInp)];
p.factor_type = [p.factor_type ones(1, nInp)]; % inputs
p.overwrite = [p.overwrite ones(1, nInp)]; % overwrite by default
p.group = [p.group zeros(1, nInp)];
p.grid_flag = [p.grid_flag 6*ones(1,nInp)];
p.range = [p.range inpVal];
p.constant = [p.constant zeros(1, nInp)];
p.tolerance = [p.tolerance zeros(1, nInp)];
p.created_flag = [p.created_flag -ones(1,nInp)];
p.ptrlist = [p.ptrlist, pInp];
p.linkptrlist = [p.linkptrlist null(xregpointer,1,nInp)];
for i = 1:nInp
    p.units = [p.units {''}];
end

if strcmp(do_fill,'fill')
    % Add the table pointer
    p.orig_name = [p.orig_name {[]}];
    p.factor_type = [p.factor_type 2]; % output
    p.overwrite = [p.overwrite 0]; % overwrite by default
    p.group = [p.group 0];
    p.grid_flag = [p.grid_flag 0];
    p.range = [p.range {[]}];
    p.constant = [p.constant 0];
    p.tolerance = [p.tolerance 0];
    p.ptrlist = [p.ptrlist tptr];
    p.units = [p.units {''}];
    p.created_flag = [p.created_flag -1];
    p.linkptrlist = [p.linkptrlist xregpointer];
    tabledata = get(tbl, 'values'); % Assume inputs are set exactly to table cells
    data = [data tabledata(:)];
end