Changeset 13484


Ignore:
Timestamp:
Sep 16, 2019 8:10:51 AM (3 months ago)
Author:
randersson
Message:

#5819 Added changes from running 2to3 on core.py and xmlparser.py directly to PyFMI trunk

Location:
PyFMI/trunk/src/common
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • PyFMI/trunk/src/common/core.py

    r13027 r13484  
    106106            (FMU)Model.set(['damper.d','gear.a'], [1.1, 10])
    107107        """
    108         if isinstance(variable_name, basestring):
     108        if isinstance(variable_name, str):
    109109            self._set(variable_name, value) #Scalar case
    110110        else:
    111             for i in xrange(len(variable_name)): #A list of variables
     111            for i in range(len(variable_name)): #A list of variables
    112112                self._set(variable_name[i], value[i])
    113113   
     
    133133            (FMU)Model.get(['damper.d','gear.a'])
    134134        """
    135         if isinstance(variable_name, basestring):
     135        if isinstance(variable_name, str):
    136136            return self._get(variable_name) #Scalar case
    137137        else:
    138138            ret = []
    139             for i in xrange(len(variable_name)): #A list of variables
     139            for i in range(len(variable_name)): #A list of variables
    140140                ret += [self._get(variable_name[i])]
    141141            return ret
     
    155155        AlgorithmBase = getattr(algdrive, 'AlgorithmBase')
    156156       
    157         if isinstance(algorithm, basestring):
     157        if isinstance(algorithm, str):
    158158            module = __import__(module, globals(), locals(), [algorithm], -1)
    159159            algorithm = getattr(module, algorithm)
     
    190190        AlgorithmBase = getattr(algdrive, 'AlgorithmBase')
    191191       
    192         if isinstance(algorithm, basestring):
     192        if isinstance(algorithm, str):
    193193            module = __import__(module, globals(), locals(), [algorithm], -1)
    194194            algorithm = getattr(module, algorithm)
  • PyFMI/trunk/src/common/xmlparser.py

    r9999 r13484  
    950950            for sv in scalarvariables:
    951951                names.append(sv.get_name())
    952             return zip(tuple(self._vrefs),tuple(names))
     952            return list(zip(tuple(self._vrefs),tuple(names)))
    953953
    954954        for sv in scalarvariables:
    955955            if sv.get_alias() == NO_ALIAS:
    956956                names.append(sv.get_name())
    957         return zip(tuple(self._vrefs_noAlias),tuple(names))
     957        return list(zip(tuple(self._vrefs_noAlias),tuple(names)))
    958958       
    959959    def get_variable_aliases(self, ignore_cache=False):
     
    980980        for sv in scalarvariables:
    981981            alias_data.append(sv.get_alias())
    982         return zip(tuple(self._vrefs),tuple(alias_data))
     982        return list(zip(tuple(self._vrefs),tuple(alias_data)))
    983983
    984984    def get_variable_descriptions(self, include_alias=True, ignore_cache=False):
     
    10141014            for sv in scalarvariables:
    10151015                descriptions.append(sv.get_description())
    1016             return zip(tuple(self._vrefs),tuple(descriptions))
     1016            return list(zip(tuple(self._vrefs),tuple(descriptions)))
    10171017           
    10181018        for sv in scalarvariables:
    10191019            if sv.get_alias() == NO_ALIAS:
    10201020                descriptions.append(sv.get_description())
    1021         return zip(tuple(self._vrefs_noAlias),tuple(descriptions))
     1021        return list(zip(tuple(self._vrefs_noAlias),tuple(descriptions)))
    10221022       
    10231023    def get_variable_variabilities(self, include_alias=True,
     
    10541054            for sv in scalarvariables:
    10551055                variabilities.append(sv.get_variability())
    1056             return zip(tuple(self._vrefs),tuple(variabilities))
     1056            return list(zip(tuple(self._vrefs),tuple(variabilities)))
    10571057       
    10581058        for sv in scalarvariables:
    10591059            if sv.get_alias() == NO_ALIAS:
    10601060                variabilities.append(sv.get_variability())
    1061         return zip(tuple(self._vrefs_noAlias),tuple(variabilities))
     1061        return list(zip(tuple(self._vrefs_noAlias),tuple(variabilities)))
    10621062
    10631063    def get_variable_nominal_attributes(self, include_alias=True,
     
    10981098                else:
    10991099                    nominals.append(None)
    1100             return zip(tuple(self._vrefs),tuple(nominals))
     1100            return list(zip(tuple(self._vrefs),tuple(nominals)))
    11011101       
    11021102        for sv in scalarvariables:
     
    11071107                else:
    11081108                    nominals.append(None)
    1109         return zip(tuple(self._vrefs_noAlias),tuple(nominals))
     1109        return list(zip(tuple(self._vrefs_noAlias),tuple(nominals)))
    11101110
    11111111    def get_variable_fixed_attributes(self, include_alias=True,
     
    11461146                else:
    11471147                    fixeds.append(None)
    1148             return zip(tuple(self._vrefs),tuple(fixeds))
     1148            return list(zip(tuple(self._vrefs),tuple(fixeds)))
    11491149       
    11501150        for sv in scalarvariables:
     
    11551155                else:
    11561156                    fixeds.append(None)
    1157         return zip(tuple(self._vrefs_noAlias),tuple(fixeds))
     1157        return list(zip(tuple(self._vrefs_noAlias),tuple(fixeds)))
    11581158
    11591159
     
    11921192            for sv in scalarvariables:
    11931193                start_attributes.append(sv.get_fundamental_type().get_start())
    1194             return zip(tuple(self._vrefs), tuple(start_attributes))
     1194            return list(zip(tuple(self._vrefs), tuple(start_attributes)))
    11951195       
    11961196        for sv in scalarvariables:
    11971197            if sv.get_alias() == NO_ALIAS:
    11981198                start_attributes.append(sv.get_fundamental_type().get_start())
    1199         return zip(tuple(self._vrefs_noAlias), tuple(start_attributes))
     1199        return list(zip(tuple(self._vrefs_noAlias), tuple(start_attributes)))
    12001200       
    12011201    def get_all_real_variables(self, include_alias=True, ignore_cache=False):
     
    13611361                        vrefs.append(sv.get_value_reference())
    13621362                        names.append(sv.get_name())
    1363             return zip(tuple(vrefs), tuple(names))
     1363            return list(zip(tuple(vrefs), tuple(names)))
    13641364           
    13651365        for sv in scalarvariables:
     
    13691369                        vrefs.append(sv.get_value_reference())
    13701370                        names.append(sv.get_name())
    1371         return zip(tuple(vrefs), tuple(names))
     1371        return list(zip(tuple(vrefs), tuple(names)))
    13721372               
    13731373    def get_dx_variable_names(self, include_alias=True, ignore_cache=False):
     
    14051405                    vrefs.append(sv.get_value_reference())
    14061406                    names.append(sv.get_name())
    1407             return zip(tuple(vrefs), tuple(names))
     1407            return list(zip(tuple(vrefs), tuple(names)))
    14081408           
    14091409        for sv in scalarvariables:
     
    14121412                    vrefs.append(sv.get_value_reference())
    14131413                    names.append(sv.get_name())
    1414         return zip(tuple(vrefs), tuple(names))
     1414        return list(zip(tuple(vrefs), tuple(names)))
    14151415                   
    14161416    def get_x_variable_names(self, include_alias=True, ignore_cache=False):
     
    14491449                    vrefs.append(sv.get_value_reference())
    14501450                    names.append(sv.get_name())
    1451             return zip(tuple(vrefs), tuple(names))
     1451            return list(zip(tuple(vrefs), tuple(names)))
    14521452           
    14531453        for sv in scalarvariables:
     
    14561456                    vrefs.append(sv.get_value_reference())
    14571457                    names.append(sv.get_name())
    1458         return zip(tuple(vrefs), tuple(names))
     1458        return list(zip(tuple(vrefs), tuple(names)))
    14591459                   
    14601460    def get_u_variable_names(self, include_alias=True, ignore_cache=False):
     
    14921492                    vrefs.append(sv.get_value_reference())
    14931493                    names.append(sv.get_name())
    1494             return zip(tuple(vrefs), tuple(names))
     1494            return list(zip(tuple(vrefs), tuple(names)))
    14951495           
    14961496        for sv in scalarvariables:
     
    15001500                    vrefs.append(sv.get_value_reference())
    15011501                    names.append(sv.get_name())
    1502         return zip(tuple(vrefs), tuple(names))
     1502        return list(zip(tuple(vrefs), tuple(names)))
    15031503
    15041504    def get_w_variable_names(self, include_alias=True, ignore_cache=False):
     
    15361536                    vrefs.append(sv.get_value_reference())
    15371537                    names.append(sv.get_name())
    1538             return zip(tuple(vrefs), tuple(names))
     1538            return list(zip(tuple(vrefs), tuple(names)))
    15391539           
    15401540        for sv in scalarvariables:
     
    15441544                    vrefs.append(sv.get_value_reference())
    15451545                    names.append(sv.get_name())
    1546         return zip(tuple(vrefs), tuple(names))
     1546        return list(zip(tuple(vrefs), tuple(names)))
    15471547
    15481548    def get_p_opt_start(self, include_alias=True, ignore_cache=False):
     
    15821582                    vrefs.append(sv.get_value_reference())
    15831583                    start_attributes.append(sv.get_fundamental_type().get_start())
    1584             return zip(tuple(vrefs), tuple(start_attributes))
     1584            return list(zip(tuple(vrefs), tuple(start_attributes)))
    15851585           
    15861586        for sv in scalarvariables:
     
    15901590                    vrefs.append(sv.get_value_reference())
    15911591                    start_attributes.append(sv.get_fundamental_type().get_start())
    1592         return zip(tuple(vrefs), tuple(start_attributes))
     1592        return list(zip(tuple(vrefs), tuple(start_attributes)))
    15931593               
    15941594    def get_dx_start(self, include_alias=True, ignore_cache=False):
     
    16261626                    vrefs.append(sv.get_value_reference())
    16271627                    start_attributes.append(sv.get_fundamental_type().get_start())
    1628             return zip(tuple(vrefs), tuple(start_attributes))
     1628            return list(zip(tuple(vrefs), tuple(start_attributes)))
    16291629           
    16301630        for sv in scalarvariables:
     
    16331633                    vrefs.append(sv.get_value_reference())
    16341634                    start_attributes.append(sv.get_fundamental_type().get_start())
    1635         return zip(tuple(vrefs), tuple(start_attributes))
     1635        return list(zip(tuple(vrefs), tuple(start_attributes)))
    16361636                   
    16371637    def get_x_start(self, include_alias=True, ignore_cache=False):
     
    16691669                    vrefs.append(sv.get_value_reference())
    16701670                    start_attributes.append(sv.get_fundamental_type().get_start())
    1671             return zip(tuple(vrefs), tuple(start_attributes))
     1671            return list(zip(tuple(vrefs), tuple(start_attributes)))
    16721672           
    16731673        for sv in scalarvariables:
     
    16761676                    vrefs.append(sv.get_value_reference())
    16771677                    start_attributes.append(sv.get_fundamental_type().get_start())
    1678         return zip(tuple(vrefs), tuple(start_attributes))
     1678        return list(zip(tuple(vrefs), tuple(start_attributes)))
    16791679                   
    16801680    def get_u_start(self, include_alias=True, ignore_cache=False):
     
    17131713                    vrefs.append(sv.get_value_reference())
    17141714                    start_attributes.append(sv.get_fundamental_type().get_start())
    1715             return zip(tuple(vrefs), tuple(start_attributes))
     1715            return list(zip(tuple(vrefs), tuple(start_attributes)))
    17161716           
    17171717        for sv in scalarvariables:
     
    17211721                    vrefs.append(sv.get_value_reference())
    17221722                    start_attributes.append(sv.get_fundamental_type().get_start())
    1723         return zip(tuple(vrefs), tuple(start_attributes))
     1723        return list(zip(tuple(vrefs), tuple(start_attributes)))
    17241724
    17251725    def get_w_start(self, include_alias=True, ignore_cache=False):
     
    17581758                    vrefs.append(sv.get_value_reference())
    17591759                    start_attributes.append(sv.get_fundamental_type().get_start())
    1760             return zip(tuple(vrefs), tuple(start_attributes))
     1760            return list(zip(tuple(vrefs), tuple(start_attributes)))
    17611761           
    17621762        for sv in scalarvariables:
     
    17661766                    vrefs.append(sv.get_value_reference())
    17671767                    start_attributes.append(sv.get_fundamental_type().get_start())
    1768         return zip(tuple(vrefs), tuple(start_attributes))
     1768        return list(zip(tuple(vrefs), tuple(start_attributes)))
    17691769
    17701770############################
     
    18031803                    vrefs.append(sv.get_value_reference())
    18041804                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1805             return zip(tuple(vrefs), tuple(fixed_attributes))
     1805            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18061806           
    18071807        for sv in scalarvariables:
     
    18101810                    vrefs.append(sv.get_value_reference())
    18111811                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1812         return zip(tuple(vrefs), tuple(fixed_attributes))
     1812        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18131813                   
    18141814    def get_x_fixed(self, include_alias=True, ignore_cache=False):
     
    18461846                    vrefs.append(sv.get_value_reference())
    18471847                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1848             return zip(tuple(vrefs), tuple(fixed_attributes))
     1848            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18491849           
    18501850        for sv in scalarvariables:
     
    18531853                    vrefs.append(sv.get_value_reference())
    18541854                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1855         return zip(tuple(vrefs), tuple(fixed_attributes))
     1855        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18561856                   
    18571857    def get_u_fixed(self, include_alias=True, ignore_cache=False):
     
    18901890                    vrefs.append(sv.get_value_reference())
    18911891                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1892             return zip(tuple(vrefs), tuple(fixed_attributes))
     1892            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18931893           
    18941894        for sv in scalarvariables:
     
    18981898                    vrefs.append(sv.get_value_reference())
    18991899                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1900         return zip(tuple(vrefs), tuple(fixed_attributes))
     1900        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    19011901
    19021902    def get_w_fixed(self, include_alias=True, ignore_cache=False):
     
    19351935                    vrefs.append(sv.get_value_reference())
    19361936                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1937             return zip(tuple(vrefs), tuple(fixed_attributes))
     1937            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    19381938           
    19391939        for sv in scalarvariables:
     
    19431943                    vrefs.append(sv.get_value_reference())
    19441944                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1945         return zip(tuple(vrefs), tuple(fixed_attributes))
     1945        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    19461946
    19471947    def get_x_nominal(self, include_alias=True, ignore_cache=False):
     
    19791979                    vrefs.append(sv.get_value_reference())
    19801980                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    1981             return zip(tuple(vrefs), tuple(nominal_attributes))
     1981            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    19821982           
    19831983        for sv in scalarvariables:
     
    19861986                    vrefs.append(sv.get_value_reference())
    19871987                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    1988         return zip(tuple(vrefs), tuple(nominal_attributes))
     1988        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    19891989                   
    19901990    def get_u_nominal(self, include_alias=True, ignore_cache=False):
     
    20232023                    vrefs.append(sv.get_value_reference())
    20242024                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2025             return zip(tuple(vrefs), tuple(nominal_attributes))
     2025            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20262026           
    20272027        for sv in scalarvariables:
     
    20312031                    vrefs.append(sv.get_value_reference())
    20322032                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2033         return zip(tuple(vrefs), tuple(nominal_attributes))
     2033        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20342034
    20352035    def get_w_nominal(self, include_alias=True, ignore_cache=False):
     
    20682068                    vrefs.append(sv.get_value_reference())
    20692069                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2070             return zip(tuple(vrefs), tuple(nominal_attributes))
     2070            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20712071           
    20722072        for sv in scalarvariables:
     
    20762076                    vrefs.append(sv.get_value_reference())
    20772077                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2078         return zip(tuple(vrefs), tuple(nominal_attributes))
     2078        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20792079
    20802080    def get_p_opt_nominal(self, include_alias=True, ignore_cache=False):
     
    21152115                    vrefs.append(sv.get_value_reference())
    21162116                    nominal_attributes.append(ftype.get_nominal())
    2117             return zip(tuple(vrefs), tuple(nominal_attributes))
     2117            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    21182118           
    21192119        for sv in scalarvariables:
     
    21242124                vrefs.append(sv.get_value_reference())
    21252125                nominal_attributes.append(ftype.get_nominal())
    2126         return zip(tuple(vrefs), tuple(nominal_attributes))
     2126        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    21272127
    21282128#############################
     
    21662166                    vrefs.append(sv.get_value_reference())
    21672167                    initial_values.append(ftype.get_initial_guess())
    2168             return zip(tuple(vrefs), tuple(initial_values))
     2168            return list(zip(tuple(vrefs), tuple(initial_values)))
    21692169           
    21702170        for sv in scalarvariables:
     
    21782178                    vrefs.append(sv.get_value_reference())
    21792179                    initial_values.append(ftype.get_initial_guess())
    2180         return zip(tuple(vrefs), tuple(initial_values))
     2180        return list(zip(tuple(vrefs), tuple(initial_values)))
    21812181
    21822182    def get_dx_initial_guess(self, include_alias=True, ignore_cache=False):
     
    22192219                    vrefs.append(sv.get_value_reference())
    22202220                    initial_values.append(ftype.get_initial_guess())
    2221             return zip(tuple(vrefs), tuple(initial_values))
     2221            return list(zip(tuple(vrefs), tuple(initial_values)))
    22222222           
    22232223        for sv in scalarvariables:
     
    22302230                    vrefs.append(sv.get_value_reference())
    22312231                    initial_values.append(ftype.get_initial_guess())
    2232         return zip(tuple(vrefs), tuple(initial_values))
     2232        return list(zip(tuple(vrefs), tuple(initial_values)))
    22332233
    22342234    def get_x_initial_guess(self, include_alias=True, ignore_cache=False):
     
    22712271                        vrefs.append(sv.get_value_reference())
    22722272                        initial_values.append(ftype.get_initial_guess())
    2273             return zip(tuple(vrefs), tuple(initial_values))
     2273            return list(zip(tuple(vrefs), tuple(initial_values)))
    22742274           
    22752275        for sv in scalarvariables:
     
    22822282                    vrefs.append(sv.get_value_reference())
    22832283                    initial_values.append(ftype.get_initial_guess())
    2284         return zip(tuple(vrefs), tuple(initial_values))
     2284        return list(zip(tuple(vrefs), tuple(initial_values)))
    22852285
    22862286    def get_u_initial_guess(self, include_alias=True, ignore_cache=False):
     
    23242324                        vrefs.append(sv.get_value_reference())
    23252325                        initial_values.append(ftype.get_initial_guess())
    2326             return zip(tuple(vrefs), tuple(initial_values))
     2326            return list(zip(tuple(vrefs), tuple(initial_values)))
    23272327           
    23282328        for sv in scalarvariables:
     
    23362336                    vrefs.append(sv.get_value_reference())
    23372337                    initial_values.append(ftype.get_initial_guess())
    2338         return zip(tuple(vrefs), tuple(initial_values))
     2338        return list(zip(tuple(vrefs), tuple(initial_values)))
    23392339
    23402340    def get_w_initial_guess(self, include_alias=True, ignore_cache=False):
     
    23782378                        vrefs.append(sv.get_value_reference())
    23792379                        initial_values.append(ftype.get_initial_guess())
    2380             return zip(tuple(vrefs), tuple(initial_values))
     2380            return list(zip(tuple(vrefs), tuple(initial_values)))
    23812381           
    23822382        for sv in scalarvariables:
     
    23902390                    vrefs.append(sv.get_value_reference())
    23912391                    initial_values.append(ftype.get_initial_guess())
    2392         return zip(tuple(vrefs), tuple(initial_values))
     2392        return list(zip(tuple(vrefs), tuple(initial_values)))
    23932393
    23942394    def get_p_opt_min(self, include_alias=True, ignore_cache=False):
     
    24302430                    vrefs.append(sv.get_value_reference())
    24312431                    min_values.append(ftype.get_min())
    2432             return zip(tuple(vrefs), tuple(min_values))
     2432            return list(zip(tuple(vrefs), tuple(min_values)))
    24332433           
    24342434        for sv in scalarvariables:
     
    24422442                    vrefs.append(sv.get_value_reference())
    24432443                    min_values.append(ftype.get_min())
    2444         return zip(tuple(vrefs), tuple(min_values))
     2444        return list(zip(tuple(vrefs), tuple(min_values)))
    24452445
    24462446    def get_dx_min(self, include_alias=True, ignore_cache=False):
     
    24822482                    vrefs.append(sv.get_value_reference())
    24832483                    min_values.append(ftype.get_min())
    2484             return zip(tuple(vrefs), tuple(min_values))
     2484            return list(zip(tuple(vrefs), tuple(min_values)))
    24852485           
    24862486        for sv in scalarvariables:
     
    24932493                    vrefs.append(sv.get_value_reference())
    24942494                    min_values.append(ftype.get_min())
    2495         return zip(tuple(vrefs), tuple(min_values))
     2495        return list(zip(tuple(vrefs), tuple(min_values)))
    24962496
    24972497    def get_x_min(self, include_alias=True, ignore_cache=False):
     
    25332533                    vrefs.append(sv.get_value_reference())
    25342534                    min_values.append(ftype.get_min())
    2535             return zip(tuple(vrefs), tuple(min_values))
     2535            return list(zip(tuple(vrefs), tuple(min_values)))
    25362536           
    25372537        for sv in scalarvariables:
     
    25442544                    vrefs.append(sv.get_value_reference())
    25452545                    min_values.append(ftype.get_min())
    2546         return zip(tuple(vrefs), tuple(min_values))
     2546        return list(zip(tuple(vrefs), tuple(min_values)))
    25472547
    25482548    def get_u_min(self, include_alias=True, ignore_cache=False):
     
    25852585                    vrefs.append(sv.get_value_reference())
    25862586                    min_values.append(ftype.get_min())
    2587             return zip(tuple(vrefs), tuple(min_values))
     2587            return list(zip(tuple(vrefs), tuple(min_values)))
    25882588           
    25892589        for sv in scalarvariables:
     
    25972597                    vrefs.append(sv.get_value_reference())
    25982598                    min_values.append(ftype.get_min())
    2599         return zip(tuple(vrefs), tuple(min_values))
     2599        return list(zip(tuple(vrefs), tuple(min_values)))
    26002600
    26012601    def get_w_min(self, include_alias=True, ignore_cache=False):
     
    26382638                    vrefs.append(sv.get_value_reference())
    26392639                    min_values.append(ftype.get_min())
    2640             return zip(tuple(vrefs), tuple(min_values))
     2640            return list(zip(tuple(vrefs), tuple(min_values)))
    26412641           
    26422642        for sv in scalarvariables:
     
    26502650                    vrefs.append(sv.get_value_reference())
    26512651                    min_values.append(ftype.get_min())
    2652         return zip(tuple(vrefs), tuple(min_values))
     2652        return list(zip(tuple(vrefs), tuple(min_values)))
    26532653
    26542654    def get_p_opt_max(self, include_alias=True, ignore_cache=False):
     
    26902690                    vrefs.append(sv.get_value_reference())
    26912691                    max_values.append(ftype.get_max())
    2692             return zip(tuple(vrefs), tuple(max_values))
     2692            return list(zip(tuple(vrefs), tuple(max_values)))
    26932693           
    26942694        for sv in scalarvariables:
     
    27022702                    vrefs.append(sv.get_value_reference())
    27032703                    max_values.append(ftype.get_max())
    2704         return zip(tuple(vrefs), tuple(max_values))
     2704        return list(zip(tuple(vrefs), tuple(max_values)))
    27052705
    27062706    def get_dx_max(self, include_alias=True, ignore_cache=False):
     
    27422742                    vrefs.append(sv.get_value_reference())
    27432743                    max_values.append(ftype.get_max())
    2744             return zip(tuple(vrefs), tuple(max_values))
     2744            return list(zip(tuple(vrefs), tuple(max_values)))
    27452745           
    27462746        for sv in scalarvariables:
     
    27532753                    vrefs.append(sv.get_value_reference())
    27542754                    max_values.append(ftype.get_max())
    2755         return zip(tuple(vrefs), tuple(max_values))
     2755        return list(zip(tuple(vrefs), tuple(max_values)))
    27562756
    27572757    def get_x_max(self, include_alias=True, ignore_cache=False):
     
    27932793                    vrefs.append(sv.get_value_reference())
    27942794                    max_values.append(ftype.get_max())
    2795             return zip(tuple(vrefs), tuple(max_values))
     2795            return list(zip(tuple(vrefs), tuple(max_values)))
    27962796           
    27972797        for sv in scalarvariables:
     
    28042804                    vrefs.append(sv.get_value_reference())
    28052805                    max_values.append(ftype.get_max())
    2806         return zip(tuple(vrefs), tuple(max_values))
     2806        return list(zip(tuple(vrefs), tuple(max_values)))
    28072807
    28082808    def get_u_max(self, include_alias=True, ignore_cache=False):
     
    28452845                    vrefs.append(sv.get_value_reference())
    28462846                    max_values.append(ftype.get_max())
    2847             return zip(tuple(vrefs), tuple(max_values))
     2847            return list(zip(tuple(vrefs), tuple(max_values)))
    28482848           
    28492849        for sv in scalarvariables:
     
    28572857                    vrefs.append(sv.get_value_reference())
    28582858                    max_values.append(ftype.get_max())
    2859         return zip(tuple(vrefs), tuple(max_values))
     2859        return list(zip(tuple(vrefs), tuple(max_values)))
    28602860
    28612861    def get_w_max(self, include_alias=True, ignore_cache=False):
     
    28982898                    vrefs.append(sv.get_value_reference())
    28992899                    max_values.append(ftype.get_max())
    2900             return zip(tuple(vrefs), tuple(max_values))
     2900            return list(zip(tuple(vrefs), tuple(max_values)))
    29012901           
    29022902        for sv in scalarvariables:
     
    29102910                    vrefs.append(sv.get_value_reference())
    29112911                    max_values.append(ftype.get_max())
    2912         return zip(tuple(vrefs), tuple(max_values))
     2912        return list(zip(tuple(vrefs), tuple(max_values)))
    29132913
    29142914    def get_p_opt_islinear(self, include_alias=True, ignore_cache=False):
     
    29492949                    vrefs.append(sv.get_value_reference())
    29502950                    is_linear.append(sv.get_is_linear())
    2951             return zip(tuple(vrefs), tuple(is_linear))
     2951            return list(zip(tuple(vrefs), tuple(is_linear)))
    29522952           
    29532953        for sv in scalarvariables:
     
    29562956                    vrefs.append(sv.get_value_reference())
    29572957                    is_linear.append(sv.get_is_linear())
    2958         return zip(tuple(vrefs), tuple(is_linear))
     2958        return list(zip(tuple(vrefs), tuple(is_linear)))
    29592959
    29602960    def get_dx_islinear(self, include_alias=True, ignore_cache=False):
     
    29942994                    vrefs.append(sv.get_value_reference())
    29952995                    is_linear.append(sv.get_is_linear())
    2996             return zip(tuple(vrefs), tuple(is_linear))
     2996            return list(zip(tuple(vrefs), tuple(is_linear)))
    29972997           
    29982998        for sv in scalarvariables:
     
    30013001                    vrefs.append(sv.get_value_reference())
    30023002                    is_linear.append(sv.get_is_linear())
    3003         return zip(tuple(vrefs), tuple(is_linear))
     3003        return list(zip(tuple(vrefs), tuple(is_linear)))
    30043004
    30053005    def get_x_islinear(self, include_alias=True, ignore_cache=False):
     
    30393039                    vrefs.append(sv.get_value_reference())
    30403040                    is_linear.append(sv.get_is_linear())
    3041             return zip(tuple(vrefs), tuple(is_linear))
     3041            return list(zip(tuple(vrefs), tuple(is_linear)))
    30423042           
    30433043        for sv in scalarvariables:
     
    30463046                    vrefs.append(sv.get_value_reference())
    30473047                    is_linear.append(sv.get_is_linear())
    3048         return zip(tuple(vrefs), tuple(is_linear))
     3048        return list(zip(tuple(vrefs), tuple(is_linear)))
    30493049
    30503050    def get_u_islinear(self, include_alias=True, ignore_cache=False):
     
    30853085                    vrefs.append(sv.get_value_reference())
    30863086                    is_linear.append(sv.get_is_linear())
    3087             return zip(tuple(vrefs), tuple(is_linear))
     3087            return list(zip(tuple(vrefs), tuple(is_linear)))
    30883088           
    30893089        for sv in scalarvariables:
     
    30933093                    vrefs.append(sv.get_value_reference())
    30943094                    is_linear.append(sv.get_is_linear())
    3095         return zip(tuple(vrefs), tuple(is_linear))
     3095        return list(zip(tuple(vrefs), tuple(is_linear)))
    30963096
    30973097    def get_w_islinear(self, include_alias=True, ignore_cache=False):
     
    31323132                    vrefs.append(sv.get_value_reference())
    31333133                    is_linear.append(sv.get_is_linear())
    3134             return zip(tuple(vrefs), tuple(is_linear))
     3134            return list(zip(tuple(vrefs), tuple(is_linear)))
    31353135           
    31363136        for sv in scalarvariables:
     
    31403140                    vrefs.append(sv.get_value_reference())
    31413141                    is_linear.append(sv.get_is_linear())
    3142         return zip(tuple(vrefs), tuple(is_linear))
     3142        return list(zip(tuple(vrefs), tuple(is_linear)))
    31433143       
    31443144    def get_dx_linear_timed_variables(self, include_alias=True,
     
    51135113            values.append(ip.get_value())
    51145114           
    5115         return dict(zip(names, values))
     5115        return dict(list(zip(names, values)))
    51165116       
    51175117    def get_all_parameters(self):
     
    56575657            result = f(ignore_cache=True)
    56585658        # check if function is already in cache
    5659         if not self.cache.has_key(function):
     5659        if function not in self.cache:
    56605660            # function is not in cache so add both function
    56615661            # and return result which is either a dict or
Note: See TracChangeset for help on using the changeset viewer.