Example #1
0
    def uint32x2(number1, number2=None, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(), "Constant.uint32x2")

        return Constant._uint32xN(name, prename, 2, number1, number2)
Example #2
0
    def uint32x16(number1,
                  number2=None,
                  number3=None,
                  number4=None,
                  number5=None,
                  number6=None,
                  number7=None,
                  number8=None,
                  number9=None,
                  number10=None,
                  number11=None,
                  number12=None,
                  number13=None,
                  number14=None,
                  number15=None,
                  number16=None,
                  name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(
                inspect.stack(), "Constant.uint32x16"))

        return Constant._uint32xN(name, 16, number1, number2, number3, number4,
                                  number5, number6, number7, number8, number9,
                                  number10, number11, number12, number13,
                                  number14, number15, number16)
Example #3
0
    def uint64(number, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(), "Constant.uint64")

        return Constant._uint64xN(name, prename, 1, number)
Example #4
0
    def float32x4(number1, number2=None, number3=None, number4=None, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(), "Constant.float32x4")

        return Constant._float32xN(name, prename, 4, number1, number2, number3, number4)
Example #5
0
    def uint32x16(number1,
                  number2=None,
                  number3=None,
                  number4=None,
                  number5=None,
                  number6=None,
                  number7=None,
                  number8=None,
                  number9=None,
                  number10=None,
                  number11=None,
                  number12=None,
                  number13=None,
                  number14=None,
                  number15=None,
                  number16=None,
                  name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(),
                                                   "Constant.uint32x16")

        return Constant._uint32xN(name, prename, 16, number1, number2, number3,
                                  number4, number5, number6, number7, number8,
                                  number9, number10, number11, number12,
                                  number13, number14, number15, number16)
Example #6
0
    def float32(number, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(), "Constant.float32")

        return Constant._float32xN(name, prename, 1, number)
Example #7
0
    def float32x2(number1, number2=None, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(),
                                                   "Constant.float32x2")

        return Constant._float32xN(name, prename, 2, number1, number2)
Example #8
0
    def float64(number, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(),
                                                   "Constant.float64")

        return Constant._float64xN(name, prename, 1, number)
Example #9
0
    def uint32(number, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(),
                                                   "Constant.uint32")

        return Constant._uint32xN(name, prename, 1, number)
Example #10
0
    def uint32x4(number1, number2=None, number3=None, number4=None, name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(),
                                                   "Constant.uint32x4")

        return Constant._uint32xN(name, prename, 4, number1, number2, number3,
                                  number4)
Example #11
0
    def float32x4(number1, number2=None, number3=None, number4=None, name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.float32x4"))

        return Constant._float32xN(name, 4, number1, number2, number3, number4)
Example #12
0
    def float64(number, name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.float64"))

        return Constant._float64xN(name, 1, number)
Example #13
0
    def float32x4(number1, number2=None, number3=None, number4=None, name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.float32x4"))

        return Constant._float32xN(name, 4, number1, number2, number3, number4)
Example #14
0
    def float64(number, name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.float64"))

        return Constant._float64xN(name, 1, number)
Example #15
0
    def uint32x2(number1, number2=None, name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.uint32x2"))

        return Constant._uint32xN(name, 2, number1, number2)
Example #16
0
    def uint32x2(number1, number2=None, name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.uint32x2"))

        return Constant._uint32xN(name, 2, number1, number2)
Example #17
0
    def float32x8(number1, number2=None, number3=None, number4=None,
                  number5=None, number6=None, number7=None, number8=None,
                  name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(), "Constant.float32x8")

        return Constant._float32xN(name, prename, 8,
                                   number1, number2, number3, number4, number5, number6, number7, number8)
Example #18
0
    def uint32x8(number1, number2=None, number3=None, number4=None,
                 number5=None, number6=None, number7=None, number8=None,
                 name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.uint32x8"))

        return Constant._uint32xN(name, 8,
                                  number1, number2, number3, number4, number5, number6, number7, number8)
Example #19
0
 def __init__(self, name=None):
     from peachpy.name import Name
     if name is None:
         import inspect
         self.name = (Name(prename=parse_assigned_variable_name(inspect.stack(), "Label")),)
     elif isinstance(name, tuple):
         assert all(isinstance(part, Name) for part in name), \
             "Name must a string or a tuple or Name objects"
         self.name = name
     else:
         Name.check_name(name)
         self.name = (Name(name=name),)
Example #20
0
    def uint16x8(number1, number2=None, number3=None, number4=None,
                 number5=None, number6=None, number7=None, number8=None,
                 name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.uint16x8"))

        return Constant._uint16xN(name, 8,
                                  number1, number2, number3, number4, number5, number6, number7, number8)
Example #21
0
 def __init__(self, name=None):
     from peachpy.name import Name
     if name is None:
         import inspect
         self.name = (Name(prename=parse_assigned_variable_name(
             inspect.stack(), "Label")), )
     elif isinstance(name, tuple):
         assert all(isinstance(part, Name) for part in name), \
             "Name must a string or a tuple or Name objects"
         self.name = name
     else:
         Name.check_name(name)
         self.name = (Name(name=name), )
Example #22
0
    def uint32x16(number1, number2=None, number3=None, number4=None,
                  number5=None, number6=None, number7=None, number8=None,
                  number9=None, number10=None, number11=None, number12=None,
                  number13=None, number14=None, number15=None, number16=None,
                  name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(), "Constant.uint32x16")

        return Constant._uint32xN(name, prename, 16,
                                  number1, number2, number3, number4, number5, number6, number7, number8,
                                  number9, number10, number11, number12, number13, number14, number15, number16)
Example #23
0
    def uint32x16(number1, number2=None, number3=None, number4=None,
                  number5=None, number6=None, number7=None, number8=None,
                  number9=None, number10=None, number11=None, number12=None,
                  number13=None, number14=None, number15=None, number16=None,
                  name=None):
        if name is not None:
            Name.check_name(name)
            name = Name(name=name)
        else:
            import inspect
            name = Name(prename=parse_assigned_variable_name(inspect.stack(), "Constant.uint32x16"))

        return Constant._uint32xN(name, 16,
                                  number1, number2, number3, number4, number5, number6, number7, number8,
                                  number9, number10, number11, number12, number13, number14, number15, number16)
Example #24
0
 def __init__(self, name=None):
     from peachpy.name import Name
     if name is None:
         import inspect
         prename = parse_assigned_variable_name(inspect.stack(), "Loop")
         if prename is None:
             prename = parse_with_variable_name(inspect.stack(), "Loop")
         self.name = (Name(prename=prename),)
     elif isinstance(name, tuple):
         assert all(isinstance(part, Name) for part in name), \
             "Name must a string or a tuple or Name objects"
         self.name = name
     else:
         Name.check_name(name)
         self.name = (Name(name=name),)
     self.begin = Label(self.name + (Name(name="begin"),))
     self.end = Label(self.name + (Name(name="end"),))
Example #25
0
 def __init__(self, name=None):
     from peachpy.name import Name
     if name is None:
         import inspect
         prename = parse_assigned_variable_name(inspect.stack(), "Loop")
         if prename is None:
             prename = parse_with_variable_name(inspect.stack(), "Loop")
         self.name = (Name(prename=prename), )
     elif isinstance(name, tuple):
         assert all(isinstance(part, Name) for part in name), \
             "Name must a string or a tuple or Name objects"
         self.name = name
     else:
         Name.check_name(name)
         self.name = (Name(name=name), )
     self.begin = Label(self.name + (Name(name="begin"), ))
     self.end = Label(self.name + (Name(name="end"), ))
Example #26
0
    def float32x8(number1,
                  number2=None,
                  number3=None,
                  number4=None,
                  number5=None,
                  number6=None,
                  number7=None,
                  number8=None,
                  name=None):
        prename = None
        if name is None:
            import inspect
            prename = parse_assigned_variable_name(inspect.stack(),
                                                   "Constant.float32x8")

        return Constant._float32xN(name, prename, 8, number1, number2, number3,
                                   number4, number5, number6, number7, number8)