コード例 #1
0
    def makeAll(self, toCut=False):
        parts = []
        fh = self.feetHolder()
        lh = self.legHolder(toCut)
        s = self.seat(toCut)
        b = self.back(toCut)
        r = self.rod()

        fh.rotate(Base.Vector(0,0,0), Base.Vector(0,1,0), -(90+self.alpha))
        tx = (-math.cos(math.radians(90 - self.alpha)) + math.cos(self.r_alpha))*self.thickness
        tz = (math.sin(math.radians(90 - self.alpha)) + math.sin(self.r_alpha))*self.thickness
        fh.translate(Base.Vector(tx,0,tz))
        lh.rotate(Base.Vector(0,0,0), Base.Vector(0,1,0), -(self.alpha))
        tx = math.cos(self.r_alpha)*self.legHolderLength  
        tz= math.sin(self.r_alpha)*(self.legHolderLength) -self.thickness 
        s.rotate(Base.Vector(0,0,self.thickness), Base.Vector(0,1,0), self.alphaseat)
        s.translate(Base.Vector(tx,0,tz))
        b.rotate(Base.Vector(0,0,0), Base.Vector(0,1,0), -(70))
        tz += -self.seatLength*math.sin(self.r_alphaseat)+(1-math.cos(self.r_alpha))*self.thickness 
        tx += self.seatLength*math.cos(self.r_alphaseat) +math.sin(self.r_alpha)*self.thickness
        b.translate(Base.Vector(tx,0,tz))
        
        util.concat(parts, fh)
        util.concat(parts, lh)
        util.concat(parts, s)
        util.concat(parts, b)
        
        tr = Base.Vector(215,0,45)
        for p in parts:
            p.translate(tr)
        r.translate(Base.Vector(200,0,400))
        util.concat(parts, r)

        return parts
コード例 #2
0
 def visit_function(self, function_):
     function = copy.deepcopy(function_)
     tokens = function.tokens[:cpp.get_declaration_end_index(
         function.name, function.tokens)]
     index, offset = cpp.find_function_name(function.name, tokens)
     cpp_file_parser.replace_in_tokens(function.classname,
                                       self.data.interface_type,
                                       tokens[:index])
     function_name = cpp_file_parser.get_function_name_for_type_erasure(
         function)
     code = util.concat(tokens[:index], ' ') + function_name + ' ( '
     cpp_file_parser.replace_in_tokens(function.classname, 'HandleBase',
                                       tokens[index:])
     code += cpp_file_parser.const_specifier(
         function) + self.data.interface_type + ' & '
     for arg in cpp.get_function_arguments(function):
         code += ' , ' + arg.in_declaration()
     code += util.concat(
         tokens[cpp.get_arguments_end_index(function.name, tokens):cpp.
                get_declaration_end_index(function.name, tokens)], ' ')
     if not code.startswith('virtual '):
         code = 'virtual ' + code
     if not code.endswith('= 0'):
         code += ' = 0'
     code += ' ;'
     self.scope.add(
         cpp_file_parser.get_function_from_text(function.classname,
                                                function_name,
                                                function.return_str, code))
コード例 #3
0
ファイル: walls.py プロジェクト: frol2103/FreeCadProjects
def allParts():
    parts = []
    util.concat(parts,mainWalls())
    return util.concats([
        util.common(houseBox(),parts),
        stairs() \
                .common(houseBox()) \
                .withTexture('/home/francois/Downloads/wall-1733680_1920.jpg')
        ])
コード例 #4
0
 def showAll(self,pnt=Base.Vector(0,0,0),dir=Base.Vector(0, 0, 1)):
     parts = []; 
     util.concat(parts,self.makeAll())
     doc=FreeCAD.activeDocument() 
     grp=doc.addObject("App::DocumentObjectGroup", "middle") 
     for p in parts:
         o =  doc .addObject("Part::Feature", "Part")
         o.Shape = p
         grp.addObject(o) 
     pass 
コード例 #5
0
ファイル: cpp.py プロジェクト: lubkoll/friendly-type-erasure
def find_function_name(name, tokens):
    ntokens_for_name_and_bracket = get_name_size_in_tokens(name) + 1
    name_tokens = [SimpleToken(tokens[i].spelling) for i in range(ntokens_for_name_and_bracket)]
    if util.concat(name_tokens) == name + '(':
        return 0, ntokens_for_name_and_bracket

    for i in range(ntokens_for_name_and_bracket, len(tokens)):
        name_tokens.pop(0)
        name_tokens.append(SimpleToken(tokens[i].spelling))
        if util.same_signature(util.concat(name_tokens, ' '), name + '('):
            return i-ntokens_for_name_and_bracket+1, ntokens_for_name_and_bracket
コード例 #6
0
ファイル: chassis.py プロジェクト: frol2103/FreeCadProjects
    def __init__(self,axisLength = TruckParams.axis['length'], axleFront = 0, axleBack = 2):
        self.axisLength = axisLength
        self.p_axles = []
        self.p_axis = self.makeAxis()

        for i in range (axleFront):
            xOff = TruckParams.axle['fxoffset'] + i * (TruckParams.wheel['radius']*2 + TruckParams.axle['betweenMargin'])
            util.concat(self.p_axles,self.makeAxle(xOff))

        for i in range (axleBack):
            xOff = self.axisLength - TruckParams.axle['bxoffset'] - i * (TruckParams.wheel['radius']*2 + TruckParams.axle['betweenMargin'])
            util.concat(self.p_axles,self.makeAxle(xOff))
コード例 #7
0
ファイル: WB.py プロジェクト: frol2103/FreeCadProjects
 def showAll(self,pnt=Base.Vector(0,0,0),dir=Base.Vector(0, 0, 1)):
     util.clear()
     parts = [];
     util.concat(parts,self.makeDrawerHolder())
     util.concat(parts,self.makeShelf1())
     doc=FreeCAD.activeDocument()
     grp=doc.addObject("App::DocumentObjectGroup", "Workbench")
     for p in parts:
         o =  doc.addObject("Part::Feature", "Part")
         o.Shape = p
         grp.addObject(o) 
     pass
コード例 #8
0
def get_table_return_type(function):
    index, offset = cpp.find_function_name(function.name, function.tokens)
    return_type = util.concat(function.tokens[:index], ' ')
    if return_type in ['const ' + function.classname + ' & ',
                       function.classname + ' & ']:
        return 'void '
    if return_type == function.classname + ' ':
        return

    if returns_this(function):
        return 'void '

    return util.concat(function.tokens[:index], ' ')
コード例 #9
0
def find_function_name(name, tokens):
    ntokens_for_name_and_bracket = get_name_size_in_tokens(name) + 1
    name_tokens = [
        SimpleToken(tokens[i].spelling)
        for i in range(ntokens_for_name_and_bracket)
    ]
    if util.concat(name_tokens) == name + '(':
        return 0, ntokens_for_name_and_bracket

    for i in range(ntokens_for_name_and_bracket, len(tokens)):
        name_tokens.pop(0)
        name_tokens.append(SimpleToken(tokens[i].spelling))
        if util.same_signature(util.concat(name_tokens, ' '), name + '('):
            return i - ntokens_for_name_and_bracket + 1, ntokens_for_name_and_bracket
コード例 #10
0
 def makeTrailerChassis(self):
     parts = [];
     util.concat(parts,self.makeFloor())
     util.concat(parts,self.makeAxis())
     util.concat(parts,self.makePivot())
     util.concat(parts,self.makeBackAxle(2))
     return parts;
コード例 #11
0
ファイル: windows.py プロジェクト: frol2103/FreeCadProjects
def allWindows():
    parts = []
    util.concat(parts,gardenWindows())
    util.concat(parts,windowDoor())
    util.concat(parts,hallDoor())
    util.concat(parts,workplanWindow())
    return parts
コード例 #12
0
ファイル: control_flow.py プロジェクト: felixzhuologist/n2t
def func_call(func_label, nargs):
    return_address = get_func_end_label(func_label)
    return concat(
        # push dummy value onto stack to allocate space for return value when nargs = 0
        load_constant_into_d(0),
        push_d_onto_stack(),
        incr_sp(),
        push_stack_frame(return_address),
        set_segment_to_sp('ARG'),
        concat(load_constant_into_d(5), ['@ARG', 'M=M-D']),
        concat(load_constant_into_d(int(nargs) + 1), ['@ARG', 'M=M-D']),
        set_segment_to_sp('LCL'),
        goto(func_label),
        label(return_address),
    )
コード例 #13
0
    def visit_function(self,function_):
        function = copy.deepcopy(function_)
        tokens = function.tokens[:cpp.get_declaration_end_index(function.name, function.tokens)]
        index, offset = cpp.find_function_name(function.name, function.tokens)
        cpp_file_parser.replace_in_tokens(function.classname, self.data.interface_type, tokens[:index])
        function_name = cpp_file_parser.get_function_name_for_type_erasure(function)
        code = util.concat(tokens[:index], ' ') + function_name + ' ( '
        cpp_file_parser.replace_in_tokens(function.classname, 'HandleBase', tokens[index:])
        code += cpp_file_parser.const_specifier(function) + self.data.interface_type + ' & ' + self.data.interface_variable + ' '
        for arg in cpp.get_function_arguments(function):
            if 'HandleBase' in arg.type():
                cpp_file_parser.replace_in_tokens('HandleBase', self.data.handle_base_type, arg.tokens)
            code += ' , ' + arg.in_declaration()
        code += util.concat(tokens[cpp.get_arguments_end_index(function.name, tokens):
        cpp.get_declaration_end_index(function.name, tokens)], ' ')

        if code.startswith('virtual '):
            code = code[len('virtual '):]
        if code.endswith(' = 0'):
            code = code[:-len(' = 0')]

        code += 'override { '
        contains_class_ref = util.concat(tokens[:index], ' ') in ['const ' + self.data.interface_type + ' & ',
                                                                  self.data.interface_type + ' & ']
        if not contains_class_ref:
            code += function.return_str
        code += 'value_ . ' + function.name + ' ( '

        arguments = cpp.get_function_arguments(function)
        for arg in arguments:
            if arg.type() == 'const HandleBase & ':
                code += 'static_cast < ' + 'const ' + self.data.handle_type + ' & > ( '
                code += arg.name() + ' ) . value_ '
            elif arg.type() == 'HandleBase & ':
                code += 'static_cast < ' + self.data.handle_type + ' & > ( '
                code += arg.name() + ' ) . value_ '
            else:
                code += arg.in_single_function_call()
            if arg is not arguments[-1]:
                code += ' , '

        code += ' ) ; '
        if contains_class_ref:
            code += 'return ' + self.data.interface_variable + ' ;'
        code += ' }'

        self.scope.add(cpp_file_parser.get_function_from_text(function.classname, function_name,
                                                  function.return_str, code))
コード例 #14
0
    def visit_function(self,function):
        if self.in_private_section:
            return

        code = util.concat(function.tokens[:cpp.get_declaration_end_index(function.name, function.tokens)], ' ')
        code += ' { assert ( ' + self.data.impl_member + ' ) ; ' + function.return_str
        if self.data.copy_on_write:
            if cpp.is_const(function):
                code += 'read ( ) . '
            else:
                code += 'write ( ) . '
        else:
            code += self.data.impl_member + ' -> '
        code += cpp_file_parser.get_function_name_for_type_erasure(function) + ' ( * this '
        arguments = cpp.get_function_arguments(function)
        for arg in arguments:
            code += ' , '
            if self.scope.get_open_scope().name + ' &' in arg.type():
                code += ' * ' + arg.in_single_function_call() + ' . ' + self.data.impl_member + ' '
            elif self.scope.get_open_scope().name + ' *' in arg.type():
                    code += arg.in_single_function_call() + ' -> ' + self.data.impl_member
            else:
                code += arg.in_single_function_call()
        code += ' ) ; }'

        self.scope.add(cpp_file_parser.get_function_from_text(function.classname, function.name, function.return_str, code))
コード例 #15
0
    def visit_function(self,function_):
        function = copy.deepcopy(function_)

        name = cpp_file_parser.get_function_name_for_type_erasure(function)
        function_pointer_alias = name + '_function'

        function_pointer_alias_definition = 'using ' + function_pointer_alias + ' = '
        index, offset = cpp.find_function_name(function.name, function.tokens)
        returns_self = util.contains(function.tokens[:index], function.classname)
        returns_self_by_reference = cpp.contains_sequence(function.tokens[:index], [cpp.SimpleToken(function.classname), cpp.SimpleToken('&')])
        if returns_self:
            cpp_file_parser.replace_in_tokens(function.classname, self.data.interface_type, function.tokens[:index])
        function_pointer_alias_definition += util.concat(function.tokens[:index], ' ')
        function_pointer_alias_definition += '( * ) ( '
        if returns_self_by_reference:
            interface_type = ('const ' if cpp.is_const(function) else '') + self.data.interface_type + ' &'
            function_pointer_alias_definition += interface_type + ' , '
        function_pointer_alias_definition += 'void * '

        arguments = cpp.get_function_arguments(function)
        adjust_table_arguments_tokens(function.classname, arguments)
        for arg in arguments:
            function_pointer_alias_definition += ' , ' + arg.in_declaration()

        # Seems to be redundant, TODO Verify
        #start_index = cpp_file_parser.get_arguments_end_index(function.name, function.tokens)
        #end_index = cpp_file_parser.get_declaration_end_index(function.name, function.tokens)
        #for token in function.tokens[start_index:end_index]:
        #    if token.spelling not in ['const','noexcept']:
        #        function_pointer_alias_definition += token.spelling + ' '
        function_pointer_alias_definition += ');'

        self.scope.add(cpp_file_parser.get_alias_from_text(function_pointer_alias, function_pointer_alias_definition))
        self.scope.add(cpp.Variable(function_pointer_alias + ' ' + name + ';'))
コード例 #16
0
ファイル: graph.py プロジェクト: celestial-intellect/bitdrill
 def id_str(self, u):
     def repl(char):
         if char in string.punctuation:
             return '_'
         else:
             return char
     return util.concat(map(repl, str(u)))
コード例 #17
0
    def adadelta(allparams,
                 nat_stepsize,
                 num_epochs,
                 seq_len,
                 num_seqs=None,
                 rho=0.95,
                 epsilon=1e-6,
                 num_samples=1,
                 permute=True):
        natparams, params = allparams[:1], allparams[1:]
        sum_gsq = zeros_like(params)  # accumulated sq. grads
        sum_usq = zeros_like(params)  # accumulated sq. updates
        accumulate = lambda a, b: add(scale(rho, a), scale(1 - rho, b))

        for epoch in xrange(num_epochs):
            vals = []
            batches, num_batches = split_into_batches(data, seq_len, num_seqs)
            for y in batches:
                val, grad = scale(
                    1. / num_datapoints,
                    val_and_grad(y, num_batches, num_samples, *allparams))
                natgrad, grad = grad[:1], grad[1:]
                sum_gsq = accumulate(sum_gsq, square(grad))
                diag_scaling = div(sqrt(add_scalar(epsilon, sum_usq)),
                                   sqrt(add_scalar(epsilon, sum_gsq)))
                update = mul(diag_scaling, grad)
                sum_usq = accumulate(sum_usq, square(update))

                natparams = add(natparams, scale(nat_stepsize, natgrad))
                params = add(params, update)
                allparams = concat(natparams, params)
                vals.append(val)

                if callback: callback(epoch, vals, natgrad, allparams)
        return allparams
コード例 #18
0
ファイル: control_flow.py プロジェクト: felixzhuologist/n2t
def func_def(func_label, nvars):
    return concat(
        label(func_label),
        set_segment_to_sp('LCL'),
        push_constant(_, '0') *
        int(nvars)  # this can be optimized by writing 0 directly
    )
コード例 #19
0
    def visit_function(self, function):
        if self.in_private_section:
            return

        code = util.concat(
            function.tokens[:cpp.get_declaration_end_index(
                function.name, function.tokens)], ' ')
        code += ' { assert ( ' + self.data.impl_member + ' ) ; ' + function.return_str
        if self.data.copy_on_write:
            if cpp.is_const(function):
                code += 'read ( ) . '
            else:
                code += 'write ( ) . '
        else:
            code += self.data.impl_member + ' -> '
        code += cpp_file_parser.get_function_name_for_type_erasure(
            function) + ' ( * this '
        arguments = cpp.get_function_arguments(function)
        for arg in arguments:
            code += ' , '
            if self.scope.get_open_scope().name + ' &' in arg.type():
                code += ' * ' + arg.in_single_function_call(
                ) + ' . ' + self.data.impl_member + ' '
            elif self.scope.get_open_scope().name + ' *' in arg.type():
                code += arg.in_single_function_call(
                ) + ' -> ' + self.data.impl_member
            else:
                code += arg.in_single_function_call()
        code += ' ) ; }'

        self.scope.add(
            cpp_file_parser.get_function_from_text(function.classname,
                                                   function.name,
                                                   function.return_str, code))
コード例 #20
0
ファイル: pop.py プロジェクト: felixzhuologist/n2t
def pop_heap(segment, index):
    return concat(
        load_constant_into_d(index),
        [f'@{segment}', 'D=M+D'],  # load addr into D
        ['@R13', 'M=D'],  # store addr into mem
        decr_sp(),
        load_stack_top_into_d(),
        ['@R13', 'A=M', 'M=D'])
コード例 #21
0
ファイル: windows.py プロジェクト: frol2103/FreeCadProjects
def windowsToCut():
    return util.concat(
            map(lambda x: x.box(),workplanWindow()),
            box(150,150,windowHeight) \
                .transO(v(width-150, 
                    length-150,
                    wallMinHeight - 50 - windowHeight))
            )
コード例 #22
0
ファイル: chassis.py プロジェクト: frol2103/FreeCadProjects
 def makeAxle(self,xOffset,directed=False):
     parts = []
     pnt=Base.Vector(xOffset, TruckParams.wheel['width'],TruckParams.wheel['radius']-TruckParams.axle['side']/2)
     p = Part.makeBox(TruckParams.axle['side'],TruckParams.axle['width'],TruckParams.axle['side'],pnt) 
     w1 = self.makeWheel(pnt + Base.Vector(TruckParams.axle['side']/2.0, -TruckParams.wheel['width'],TruckParams.axle['side']/2.0))
     w2 = self.makeWheel(pnt + Base.Vector(TruckParams.axle['side']/2.0, TruckParams.axle['width'],TruckParams.axle['side']/2.0))
     if directed:
         pntMidSteering = Base.Vector(pnt.x + TruckParams.axle['side']/2,pnt.y + TruckParams.axle['width']/2,pnt.z+TruckParams.axle['side']-TruckParams.steering['axlePenetration'])
         h = Part.makeCylinder(TruckParams.steering['stickRadius'],TruckParams.steering['axlePenetration']+TruckParams.axis['height'],
                 pntMidSteering)
         p = p.cut(h)
         Part.show(h)
         self.p_axis = self.p_axis.cut(h)
         util.concat(parts,self.makeSteeringStick(pntMidSteering))
     
     parts += [p,w1,w2]
     return parts
コード例 #23
0
ファイル: control_flow.py プロジェクト: felixzhuologist/n2t
def func_return():
    return concat(
        decr_sp(),
        load_stack_top_into_d(),
        ['@ARG', 'A=M', 'M=D'],  # *ARG = D
        ['@ARG', 'D=M', '@SP', 'M=D+1'],  # SP = ARG + 1
        unpack_stack_frame(),
        ['@R13', 'A=M', '0;JMP']  # JMP *R13
    )
コード例 #24
0
def showAll(pnt=Base.Vector(0, 0, 0), dir=Base.Vector(0, 0, 1)):
    util.clear()
    parts = [partFromVectors([O, x(1000), xy(1000, 1000), y(1000)], O - z(thickness))]

    util.concat(parts, util.translate(chair(), x(0)))
    # util.concat(parts,util.translate(chair('sym'), x(1500)))
    # util.concat(parts,util.translate(chair('tri'), x(3000)))

    doc = FreeCAD.activeDocument()
    grp = doc.addObject("App::DocumentObjectGroup", "Workbench")
    print(parts)
    for p in parts:
        o = doc.addObject("Part::Feature", "Part")
        if(hasattr(p, 'delegate')):
            o.Shape = p.delegate
        else:
            o.Shape = p
        grp.addObject(o)
    pass
コード例 #25
0
    def nesterov(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        vs = [shared_zeros_like(p) for p in params]

        def make_update(p, g, v):
            v_new = gamma*v - rate*g
            p_new = p + gamma**2*v - (1.+gamma)*rate*g
            return [(v, v_new), (p, p_new)]

        return concat(make_update(p, g, v) for p,g,v in zip(params, grads, vs))
コード例 #26
0
    def rmsprop(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        sumsq = [shared_zeros_like(p) for p in params]

        def make_update(p, g, c):
            c_new = rho*c + (1.-rho)*g**2
            p_new = p - rate * g / T.sqrt(c_new + epsilon)
            return [(c, c_new), (p, p_new)]

        return concat(make_update(p, g, c) for p, g, c in zip(params, grads, sumsq))
コード例 #27
0
    def momentum_sgd(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        vs = [shared_zeros_like(p) for p in params]

        def make_update(p, g, v):
            v_new = gamma*v - rate*g
            p_new = p + v_new
            return [(v, v_new), (p, p_new)]

        return concat(make_update(p, g, v) for p,g,v in zip(params, grads, vs))
コード例 #28
0
def showAll(pnt=Base.Vector(0, 0, 0), dir=Base.Vector(0, 0, 1)):
    parts = []
    #util.clear()
    util.concat(parts,chair())
    doc = FreeCAD.activeDocument()
    grp = doc.addObject("App::DocumentObjectGroup", "Workbench")
    util.concat(parts,side(doc,grp))



    print(parts)
    for p in parts:
        o = doc.addObject("Part::Feature", "Part")
        if(hasattr(p, 'delegate')):
            o.Shape = p.delegate
        else:
            o.Shape = p
        grp.addObject(o)
    pass
コード例 #29
0
    def rmsprop(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        sumsq = [shared_zeros_like(p) for p in params]

        def make_update(p, g, c):
            c_new = rho * c + (1. - rho) * g**2
            p_new = p - rate * g / T.sqrt(c_new + epsilon)
            return [(c, c_new), (p, p_new)]

        return concat(
            make_update(p, g, c) for p, g, c in zip(params, grads, sumsq))
コード例 #30
0
    def nesterov(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        vs = [shared_zeros_like(p) for p in params]

        def make_update(p, g, v):
            v_new = gamma * v - rate * g
            p_new = p + gamma**2 * v - (1. + gamma) * rate * g
            return [(v, v_new), (p, p_new)]

        return concat(
            make_update(p, g, v) for p, g, v in zip(params, grads, vs))
コード例 #31
0
    def momentum_sgd(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        vs = [shared_zeros_like(p) for p in params]

        def make_update(p, g, v):
            v_new = gamma * v - rate * g
            p_new = p + v_new
            return [(v, v_new), (p, p_new)]

        return concat(
            make_update(p, g, v) for p, g, v in zip(params, grads, vs))
コード例 #32
0
 def visit_function(self,function_):
     function = copy.deepcopy(function_)
     tokens = function.tokens[:cpp.get_declaration_end_index(function.name, function.tokens)]
     index, offset = cpp.find_function_name(function.name, tokens)
     cpp_file_parser.replace_in_tokens(function.classname, self.data.interface_type, tokens[:index])
     function_name = cpp_file_parser.get_function_name_for_type_erasure(function)
     code = util.concat(tokens[:index], ' ') + function_name + ' ( '
     cpp_file_parser.replace_in_tokens(function.classname, 'HandleBase', tokens[index:])
     code += cpp_file_parser.const_specifier(function) + self.data.interface_type + ' & '
     for arg in cpp.get_function_arguments(function):
         code += ' , ' + arg.in_declaration()
     code += util.concat(tokens[cpp.get_arguments_end_index(function.name, tokens):
     cpp.get_declaration_end_index(function.name, tokens)], ' ')
     if not code.startswith('virtual '):
         code = 'virtual ' + code
     if not code.endswith('= 0'):
         code += ' = 0'
     code += ' ;'
     self.scope.add(cpp_file_parser.get_function_from_text(function.classname, function_name,
                                                           function.return_str, code))
コード例 #33
0
def get_handle_interface_function(data, function):
    code = util.concat(
        function.tokens[:cpp_file_parser.get_declaration_end_index(
            function.name, function.tokens)], ' ')
    code += ' { assert ( ' + data.impl_member + ' ) ; ' + function.return_str + ' ' + data.impl_member + ' -> ' + function.name + ' ( '
    arguments = cpp_file_parser.get_function_arguments(function)
    for arg in arguments:
        code += arg.in_single_function_call()
        if arg is not arguments[-1]:
            code += ' , '
    return code + ' ) ; }'
コード例 #34
0
def binary_comp(comp):
    return concat(
        decr_sp(),
        load_stack_top_into_d(),
        decr_sp(),
        ['@SP', 'A=M', 'D=M-D'],
        if_else(
            comparator=comp,
            true_block=['@SP', 'A=M',
                        'M=-1'],  # recall: in HW -1 represents true, 0 false
            false_block=['@SP', 'A=M', 'M=0']),
        incr_sp())
コード例 #35
0
    def adadelta(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        sum_gsq = [shared_zeros_like(p) for p in params]  # accumulated sq. grads
        sum_usq = [shared_zeros_like(p) for p in params]  # accumulated sq. updates

        def make_update(p, g, cg2, cu2):
            cg2_new = rho*cg2 + (1.-rho)*g**2
            ud = -T.sqrt(cu2 + epsilon) / T.sqrt(cg2_new + epsilon) * g
            cu2_new = rho*cu2 + (1.-rho)*ud**2
            p_new = p + ud
            return [(cg2, cg2_new), (cu2, cu2_new), (p, p_new)]

        return concat(make_update(p, g, g2, up2)
                    for p, g, g2, up2 in zip(params, grads, sum_gsq, sum_usq))
コード例 #36
0
ファイル: control_flow.py プロジェクト: felixzhuologist/n2t
def unpack_stack_frame():
    """
  precondition: LCL points to right after the stack frame
  postcondition: stack frame values written into lcl, arg, this, that
    return address is written into R13
  """
    return concat(
        pop_segment_pointer('THAT'),
        pop_segment_pointer('THIS'),
        pop_segment_pointer('ARG'),
        # set R13 = *(LCL - 2) before overwritting LCL
        ['@LCL', 'D=M', '@R13', 'M=D-1', 'M=M-1', 'A=M', 'D=M', '@R13', 'M=D'],
        pop_segment_pointer('LCL'),
    )
コード例 #37
0
def apply_ctc_loss(floss, output, target: List[List[int]]):
    target_lengths = length_tensor(target)
    target = concat(target)
    target = torch.Tensor(target)
    target = target.long()
    target = target.view((-1, ))
    target = target.to(device)

    # Calculate lengths
    input_lengths = torch.full((output.shape[1], ),
                               output.shape[0],
                               dtype=torch.long)

    return floss(output, target, input_lengths, target_lengths)
コード例 #38
0
def add_comments(scope, comments):
    new_content = []
    for entry in scope.content:
        if cpp.is_namespace(entry):
            add_comment(new_content, 'namespace ' + entry.name, comments)
            add_comments(entry, comments)
        elif cpp.is_class(entry) or cpp.is_struct(entry):
            add_comment(new_content, entry.type + ' ' + entry.name, comments)
            add_comments(entry, comments)
        elif entry.type in [cpp.FUNCTION, cpp.CONSTRUCTOR, cpp.DESTRUCTOR, cpp.FUNCTION_TEMPLATE, cpp.ASSIGNMENT_OPERATOR]:
            add_comment(new_content, entry.get_declaration(), comments)
        elif entry.type == cpp.ALIAS:
            add_comment(new_content, util.concat(entry.tokens, ' '), comments)
        new_content.append(entry)
    scope.content = new_content
コード例 #39
0
    def visit_class(self,class_):
        if cpp.is_forward_declaration(class_):
            return util.concat(class_.tokens, ' ')
        str = ''
        self.current_class = class_.get_name( )
        for entry in class_.content:
            if entry.type == cpp.ALIAS:
                self.current_class_aliases.append(entry.name)

        for entry in class_.content:
            str += entry.visit(self)

        self.current_class = None
        self.current_class_aliases = []
        return str
コード例 #40
0
    def visit_class(self, class_):
        if cpp.is_forward_declaration(class_):
            return util.concat(class_.tokens, ' ')
        str = ''
        self.current_class = class_.get_name()
        for entry in class_.content:
            if entry.type == cpp.ALIAS:
                self.current_class_aliases.append(entry.name)

        for entry in class_.content:
            str += entry.visit(self)

        self.current_class = None
        self.current_class_aliases = []
        return str
コード例 #41
0
    def adam(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        ms = [shared_zeros_like(p) for p in params]
        vs = [shared_zeros_like(p) for p in params]
        t = theano.shared(floatX(1))

        def make_update(p, g, m, v, t):
            m_new = beta_1*m + (1.-beta_1)*g
            v_new = beta_2*v + (1.-beta_2)*g**2
            mhat = m / (1.-beta_1**t)
            vhat = v / (1.-beta_2**t)
            p_new = p - alpha * mhat / (T.sqrt(vhat) + epsilon)
            return [(m, m_new), (v, v_new), (p, p_new)]

        return [(t, t+1)] + concat(
            make_update(p, g, m, v, t) for p,g,m,v in zip(params, grads, ms, vs))
コード例 #42
0
    def process_variable_declaration(self,data,cursor):
        tokens = clang_util.get_tokens(data.tu, cursor)
        if tokens[-1].spelling != clang_util.semicolon and self.scope.get_open_scope().get_tokens():
            tokens = clang_util.get_all_variable_tokens(tokens, self.scope.get_open_scope().get_tokens())

        variable_declaration = util.concat(tokens, ' ')
        # in case that an underlying type is specified,
        # clang interprets enums at variables.
        # filter out these cases:
        if 'enum ' in variable_declaration:
            #TODO try to find a workaround for this
            return
        if clang_util.get_tokens(data.tu, cursor)[0].spelling == 'static':
            self.scope.add(cpp.StaticVariable(variable_declaration))
        else:
            self.scope.add(cpp.Variable(variable_declaration))
コード例 #43
0
def toso(graf):
  # implementasi pendekatan topological sort
  # dengan decrease and conquer (rekursi)

  # basis
  if(len(graf)==1):
    return graf
  # rekuren
  else:
    # akan dipilih simpul tanpa sisi masuk
    for data in graf:
      if len(data["masuk"])==0:
        simpul = data["simpul"]
        # decreasing
        decrease = updategraf(removefromgraf(graf, simpul), simpul)
        # conquering + recursion
        return concat([data], toso(decrease))
コード例 #44
0
    def adam(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        ms = [shared_zeros_like(p) for p in params]
        vs = [shared_zeros_like(p) for p in params]
        t = theano.shared(floatX(1))

        def make_update(p, g, m, v, t):
            m_new = beta_1 * m + (1. - beta_1) * g
            v_new = beta_2 * v + (1. - beta_2) * g**2
            mhat = m / (1. - beta_1**t)
            vhat = v / (1. - beta_2**t)
            p_new = p - alpha * mhat / (T.sqrt(vhat) + epsilon)
            return [(m, m_new), (v, v_new), (p, p_new)]

        return [(t, t + 1)] + concat(
            make_update(p, g, m, v, t)
            for p, g, m, v in zip(params, grads, ms, vs))
コード例 #45
0
    def adadelta(cost, params):
        grads = T.grad(cost=cost, wrt=params)
        sum_gsq = [shared_zeros_like(p)
                   for p in params]  # accumulated sq. grads
        sum_usq = [shared_zeros_like(p)
                   for p in params]  # accumulated sq. updates

        def make_update(p, g, cg2, cu2):
            cg2_new = rho * cg2 + (1. - rho) * g**2
            ud = -T.sqrt(cu2 + epsilon) / T.sqrt(cg2_new + epsilon) * g
            cu2_new = rho * cu2 + (1. - rho) * ud**2
            p_new = p + ud
            return [(cg2, cg2_new), (cu2, cu2_new), (p, p_new)]

        return concat(
            make_update(p, g, g2, up2)
            for p, g, g2, up2 in zip(params, grads, sum_gsq, sum_usq))
コード例 #46
0
    def adam(allparams,
             nat_stepsize,
             stepsize,
             num_epochs,
             seq_len,
             num_seqs=None,
             b1=0.9,
             b2=0.999,
             eps=1e-8,
             num_samples=1):
        natparams, params = allparams[:1], allparams[1:]
        m = zeros_like(params)
        v = zeros_like(params)
        i = 0
        accumulate = lambda rho, a, b: add(scale(1 - rho, a), scale(rho, b))

        for epoch in xrange(num_epochs):
            vals = []
            batches, num_batches = split_into_batches(data, seq_len, num_seqs)
            for y in batches:
                val, grad = scale(
                    1. / num_datapoints,
                    val_and_grad(y, num_batches, num_samples, *allparams))
                natgrad, grad = grad[:1], grad[1:]

                m = accumulate(b1, grad, m)  # first moment estimate
                v = accumulate(b2, square(grad), v)  # second moment estimate
                mhat = scale(1. / (1 - b1**(i + 1)), m)  # bias correction
                vhat = scale(1. / (1 - b2**(i + 1)), v)
                update = scale(stepsize, div(mhat, add_scalar(eps,
                                                              sqrt(vhat))))

                natparams = add(natparams, scale(nat_stepsize, natgrad))
                params = add(params, update)
                allparams = concat(natparams, params)
                vals.append(val)
                i += 1

                if callback: callback(epoch, vals, natgrad, allparams)

        return allparams
コード例 #47
0
def adam(gradfun, allparams, num_iters, step_size, b1=0.9, b2=0.999, eps=1e-8):
    natparams, params = allparams[:1], allparams[1:]
    m = zeros_like(params)
    v = zeros_like(params)
    i = 0
    accumulate = lambda rho, a, b: add(scale(1-rho, a), scale(rho, b))
 
    for i in xrange(num_iters):
        grad = gradfun(allparams, i)
        natgrad, grad = grad[:1], grad[1:]
 
        m = accumulate(b1, grad, m)          # first moment estimate
        v = accumulate(b2, square(grad), v)  # second moment estimate
        mhat = scale(1./(1 - b1**(i+1)), m)  # bias correction
        vhat = scale(1./(1 - b2**(i+1)), v)
        update = scale(step_size, div(mhat, add_scalar(eps, sqrt(vhat))))
 
        natparams = sub(natparams, scale(step_size, natgrad))
        params = sub(params, update)
        allparams = concat(natparams, params)
 
    return allparams
コード例 #48
0
ファイル: cpp.py プロジェクト: lubkoll/friendly-type-erasure
 def get_declaration(self):
     return util.concat(self.tokens[:get_declaration_end_index(self.name, self.tokens)], ' ')
コード例 #49
0
ファイル: chassis.py プロジェクト: frol2103/FreeCadProjects
    def getParts(self):
        parts = []
        util.concat(parts, self.p_axis)
        util.concat(parts, self.p_axles)

        return parts;
コード例 #50
0
ファイル: chassis.py プロジェクト: frol2103/FreeCadProjects
 def addSteering(self, xOffset = 40):
     util.concat(self.p_axles,self.makeAxle(xOffset,True))
コード例 #51
0
ファイル: cpp.py プロジェクト: lubkoll/friendly-type-erasure
def returns_class_ref(classname,function):
    index, offset = find_function_name(function.name, function.tokens)
    return util.concat(function.tokens[:index], ' ') in ['const ' + classname + ' & ',
                                                         classname + ' & ']
コード例 #52
0
    def visit_function(self, function_):
        function = copy.deepcopy(function_)
        tokens = function.tokens[:cpp.get_declaration_end_index(
            function.name, function.tokens)]
        index, offset = cpp.find_function_name(function.name, function.tokens)
        cpp_file_parser.replace_in_tokens(function.classname,
                                          self.data.interface_type,
                                          tokens[:index])
        function_name = cpp_file_parser.get_function_name_for_type_erasure(
            function)
        code = util.concat(tokens[:index], ' ') + function_name + ' ( '
        cpp_file_parser.replace_in_tokens(function.classname, 'HandleBase',
                                          tokens[index:])
        code += cpp_file_parser.const_specifier(
            function
        ) + self.data.interface_type + ' & ' + self.data.interface_variable + ' '
        for arg in cpp.get_function_arguments(function):
            if 'HandleBase' in arg.type():
                cpp_file_parser.replace_in_tokens('HandleBase',
                                                  self.data.handle_base_type,
                                                  arg.tokens)
            code += ' , ' + arg.in_declaration()
        code += util.concat(
            tokens[cpp.get_arguments_end_index(function.name, tokens):cpp.
                   get_declaration_end_index(function.name, tokens)], ' ')

        if code.startswith('virtual '):
            code = code[len('virtual '):]
        if code.endswith(' = 0'):
            code = code[:-len(' = 0')]

        code += 'override { '
        contains_class_ref = util.concat(tokens[:index], ' ') in [
            'const ' + self.data.interface_type + ' & ',
            self.data.interface_type + ' & '
        ]
        if not contains_class_ref:
            code += function.return_str
        code += 'value_ . ' + function.name + ' ( '

        arguments = cpp.get_function_arguments(function)
        for arg in arguments:
            if arg.type() == 'const HandleBase & ':
                code += 'static_cast < ' + 'const ' + self.data.handle_type + ' & > ( '
                code += arg.name() + ' ) . value_ '
            elif arg.type() == 'HandleBase & ':
                code += 'static_cast < ' + self.data.handle_type + ' & > ( '
                code += arg.name() + ' ) . value_ '
            else:
                code += arg.in_single_function_call()
            if arg is not arguments[-1]:
                code += ' , '

        code += ' ) ; '
        if contains_class_ref:
            code += 'return ' + self.data.interface_variable + ' ;'
        code += ' }'

        self.scope.add(
            cpp_file_parser.get_function_from_text(function.classname,
                                                   function_name,
                                                   function.return_str, code))
コード例 #53
0
ファイル: cpp.py プロジェクト: lubkoll/friendly-type-erasure
def is_defaulted(function):
    return len(function.tokens) > 5 and util.concat(function.tokens[-3:], ' ') == '= default ; '
コード例 #54
0
    def visit_function(self,function_):
        function = copy.deepcopy(function_)
        name = cpp_file_parser.get_function_name_for_type_erasure(function)
        index, offset = cpp.find_function_name(function.name, function.tokens)
        returns_self = util.contains(function.tokens[:index], function.classname)
        returns_self_by_reference = cpp.contains_sequence(function.tokens[:index],
                                                          [cpp.SimpleToken(function.classname), cpp.SimpleToken('&')])
        if returns_self:
            cpp_file_parser.replace_in_tokens(function.classname, self.data.interface_type, function.tokens[:index])
        arguments = copy.deepcopy(cpp.get_function_arguments(function))

        wrapper = 'static ' + util.concat(function.tokens[:index], ' ')
        wrapper += name + ' ( '
        if returns_self_by_reference:
            wrapper += cpp_file_parser.const_specifier(function) + self.data.interface_type + ' & ' + self.data.interface_variable + ' , '
        wrapper += ' void * impl '
        for arg in arguments:
            if cpp_file_parser.contains(function.classname, arg.tokens):
                wrapper += ' , void * ' + arg.tokens[-1].spelling
            else:
                wrapper += ' , ' + arg.in_declaration()
        wrapper += ' ) '
        if 'noexcept' in function.tokens[cpp.get_arguments_end_index(function.name, function.tokens):
                                         cpp.get_declaration_end_index(function.name, function.tokens)]:
            wrapper += 'noexcept '

        wrapper += '{ '
        returns_class_ref = cpp.returns_class_ref(self.data.interface_type, function)
        if not returns_class_ref:
            wrapper +=  function.return_str + ' '
        wrapper += 'static_cast '
        const = 'const ' if cpp.is_const(function) else ''
        if self.for_reference_wrapper:
            wrapper += '< std :: reference_wrapper < Impl > * > ( impl ) -> get ( ) . '
        else:
            wrapper += '< ' + const + ' Impl * > ( impl ) -> '
        wrapper += function.name + ' ( '
        for arg in arguments:
            if cpp_file_parser.contains(function.classname, arg.tokens):
                typename = util.concat(arg.tokens[:-1], ' ')
                typename = typename.replace(' ' + function.classname + ' ', ' Impl ')

                if self.for_reference_wrapper:
                    if typename.endswith('* '):
                        wrapper += '& '
                    wrapper += 'static_cast < std :: reference_wrapper < Impl > * > ( ' + arg.in_single_function_call()
                    wrapper += ' ) -> get ( )'
                else:
                    if typename.endswith('& '):
                        wrapper += '* '
                    wrapper += 'static_cast< ' + ('const ' if cpp.is_const(function) else '')
                    wrapper += 'Impl * > ( ' + arg.in_single_function_call() + ' )'
            else:
                wrapper += arg.in_single_function_call()
            if arg is not arguments[-1]:
                wrapper += ' ,  '
        wrapper += ' ) ; '
        if returns_class_ref:
            wrapper += 'return interface ; '
        wrapper += '}'

        self.scope.add(cpp_file_parser.get_function_from_text('execution_wrapper', name, function.return_str,
                                                              wrapper))
コード例 #55
0
def test(model, test_X, test_y, label_set):
	data_set_size = len(test_X)
	pred_res = model.predict(test_X)
	if type(test_y) is list:
		top_nbs = [[2, 10, 10, 6], [2, 10, 10, 10]]
		thresholds = [[0.2,0.2,0.2,0.2], [0.3,0.3,0.3,0.3],[0.4, 0.4, 0.4, 0.4]]
		# top_nbs = product(range(6,11), repeat=4)
		# thresholds = [[0.2,0.2,0.2,0.2],[0.4,0.4,0.4,0.3]]
		test_y = concat(test_y)
		test_y = [flatten([n_hot_decoder(j, label_set[idx]) for idx,j in enumerate(i)]) for i in test_y]
		pred_res = concat(pred_res)
	else:
		top_nbs = [5, 10]
		thresholds = np.arange(0,0.5,0.2)
		test_y = [n_hot_decoder(i, label_set) for i in test_y]
	top_recall_f1 = (0,None,None)
	top_f1 = (0,None,None)

	for top_nb in top_nbs:
		for threshold in thresholds:
			decode_res = decode(pred_res, label_set, top_nb, threshold)
			precision = 0
			recall = 0
			test_len = 0.0
			pred_len = 0.0
	
			n1 = 0
			n2 = 0
			for i in range(data_set_size):
				test_set = set(test_y[i])
				pred_set = set(decode_res[i])
				#print(test_set)

				test_len += len(test_set)
				pred_len += len(pred_set)
				
				if len(pred_set) == 0 and len(test_set) == 0:
					precision += 1.0
					recall += 1.0
					continue
				if len(test_set) == 0 or len(pred_set)== 0:
					continue

				common_set = test_set & pred_set
				cnt = len(common_set)
				precision += float(cnt) / len(pred_set)
				recall += float(cnt) / len(test_set)

			precision /= data_set_size
			recall /= data_set_size
			test_len /= data_set_size
			pred_len /= data_set_size
			f1 = 2 * precision * recall / (precision + recall)
			if recall+f1 > top_recall_f1[0]:
				top_recall_f1 = (recall+f1, top_nb, threshold)
			if f1 > top_f1[0]:
				top_f1 = (f1, top_nb, threshold)
			print('(top %s, threshold %s) Precision: %.3lf' % (top_nb, threshold, precision))
			print('(top %s, threshold %s) Recall: %.3lf' % (top_nb, threshold, recall))
			print('(top %s, threshold %s) f1: %.3lf' % (top_nb, threshold, f1))
			print('(top %s, threshold %s) test_len %.2lf, pred_len %.2lf\n' % (top_nb, threshold, test_len, pred_len))			
	print('top (recall+f1)', top_recall_f1)
	print('top f1', top_f1)
コード例 #56
0
ファイル: tractor.py プロジェクト: frol2103/FreeCadProjects
	def showAll(self,pnt=Base.Vector(0,0,0),dir=Base.Vector(0, 0, 1)):
		parts = [];
		util.concat(parts,self.makeFloor())
		util.concat(parts,self.makeBackAxle())
		util.concat(parts,self.makeFront())
		util.concat(parts,self.makeBack())
		util.concat(parts,self.makeTop())
		util.concat(parts,self.makePlate())
		util.concat(parts,self.makeAxis())
		util.concat(parts,self.makeSteeringAxle())
		util.concat(parts,self.makeBackAxle())
	 	util.concat(parts,self.makeSteeringStick())
	 	util.concat(parts,self.make5Wheel())
	 	util.concat(parts,self.makeSeats())
		doc=FreeCAD.activeDocument() 
		grp=doc.addObject("App::DocumentObjectGroup", "Tractor") 
		for p in parts:
			o =  doc.addObject("Part::Feature", "Part")
			o.Shape = p
			grp.addObject(o) 
		pass 
コード例 #57
0
ファイル: side.py プロジェクト: frol2103/FreeCadProjects
    def makeSide(self):

        parts = []

        util.concat(parts,self.makeMane())
        util.concat(parts,self.makeHead())
        util.concat(parts,self.makeVCurveL())
        util.concat(parts,self.makePatin())
        util.concat(parts,self.makeVCurveR())
        util.concat(parts,self.makeBack())
        
        w = Part.Wire(parts)
        f = Part.Face(w)
        p = f.extrude(Base.Vector(0,self.thickness,0))
        return p
コード例 #58
0
def binary_op(op):
    return concat(decr_sp(), load_stack_top_into_d(), decr_sp(),
                  ['@SP', 'A=M', f'M=M{op}D'], incr_sp())
コード例 #59
0
def unary_op(op):
    return concat(decr_sp(), ['@SP', 'A=M', f'M={op}M'], incr_sp())
コード例 #60
0
ファイル: __main__.py プロジェクト: jonahs99/bar
#!/usr/bin/python

from asyncio import run

from config import bar
from util import async_map, drain, concat


def echo(text):
    print(text, flush=True)


if __name__ == '__main__':
    run(drain(async_map(echo, concat(bar))))