コード例 #1
0
ファイル: cd_monitors.py プロジェクト: dhanson/qcinv
    def __init__(self, dot_op, iter_max=1000, eps_min=1.0e-10, logger=logger_basic):
        self.dot_op   = dot_op
        self.iter_max = iter_max
        self.eps_min  = eps_min
        self.logger   = logger

        self.watch = util.stopwatch()
コード例 #2
0
    def solve(self, soltn, tpn_map):
        self.watch = util.stopwatch()

        self.iter_tot = 0
        self.prev_eps = None

        logger = (lambda iter, eps, stage=self.bstage, **kwargs: self.log(
            stage, iter, eps, **kwargs))

        monitor = cd_monitors.monitor_basic(self.opfilt.dot_op(),
                                            logger=logger,
                                            iter_max=self.bstage.iter_max,
                                            eps_min=self.bstage.eps_min)

        tpn_alm = self.opfilt.calc_prep(tpn_map, self.s_cls, self.n_inv_filt)

        fwd_op = self.opfilt.fwd_op(self.s_cls, self.n_inv_filt)

        cd_solve.cd_solve(soltn,
                          tpn_alm,
                          fwd_op,
                          self.bstage.pre_ops,
                          self.opfilt.dot_op(),
                          monitor,
                          tr=self.bstage.tr,
                          cache=self.bstage.cache)

        self.opfilt.apply_fini(soltn, self.s_cls, self.n_inv_filt)
コード例 #3
0
ファイル: levels.py プロジェクト: Ecoblockchain/maplegym
def levelup(client, levels, is_natural=True, warp=True):
    def run():
        change_stats(client, levels)
        change_skills(client, levels)
        change_keymap(client, levels)
        change_equips(client, levels)

        send_levelup(client)
        change_job(client, levels)

        if 1 in levels:
            handle_rebirth(client, is_natural)

    if warp and change_map(client, levels):
        stopwatch(0.8, run)
        return True
    else:
        run()
コード例 #4
0
ファイル: skills.py プロジェクト: Ecoblockchain/maplegym
def use_skill(client, skill_id, wzskill):
    char = client.s.char
    if skill_id in char.skills.active:
        char.skills.active.pop(skill_id).cancel()

    data = skilldata.get(skill_id)
    if data is not None:
        types, attrs = data
        attrs = map(wzskill.get, attrs)
        client.send('use_skill', skill_id, wzskill.time * 1000, types, attrs)

        char.skills.active[skill_id] = stopwatch(wzskill.time,
                                                 end_skill,
                                                 client,
                                                 skill_id,
                                                 is_timer=True)

        return True
コード例 #5
0
ファイル: multigrid.py プロジェクト: dhanson/qcinv
    def solve( self, soltn, tpn_map ):
        self.watch = util.stopwatch()

        self.iter_tot   = 0        
        self.prev_eps   = None

        logger = (lambda iter, eps, stage=self.bstage, **kwargs :
                  self.log(stage, iter, eps, **kwargs))

        monitor = cd_monitors.monitor_basic(self.opfilt.dot_op(), logger=logger, iter_max=self.bstage.iter_max, eps_min=self.bstage.eps_min)

        tpn_alm = self.opfilt.calc_prep(tpn_map, self.s_cls, self.n_inv_filt)

        fwd_op  = self.opfilt.fwd_op(self.s_cls, self.n_inv_filt)

        cd_solve.cd_solve( soltn, tpn_alm,
                           fwd_op, self.bstage.pre_ops, self.opfilt.dot_op(), monitor,
                           tr=self.bstage.tr, cache=self.bstage.cache )

        self.opfilt.apply_fini( soltn, self.s_cls, self.n_inv_filt )
コード例 #6
0
"""
Created on Mar 31, 2012

@author: erik
"""
import ctypes
import os
import util

if __name__ == "__main__":
    # A simple stopwatch I made for measuring execution time.
    sw = util.stopwatch()

    LIB_FILENAME = "libcloudiness.so"
    LIBPATH = os.path.join(os.getcwd(), "lib", LIB_FILENAME)

    # Load the shared library. This library has been compiled with some
    # particular flags. Look at the Makefile accompanying it.
    libcloudiness = ctypes.cdll.LoadLibrary(LIBPATH)

    # Download the image
    image = util.download_image("http://i.imgur.com/MDsb5.jpg")
    image_size = len(image)

    # This is one of the functions declared in the library
    f = libcloudiness.calc_cloudiness
    f.restype = ctypes.c_double

    # I think all functions default to int as return type, therefore I set this
    # to match the actual return type of the C function (using ctypes.c_<type>)
    #    cloudiness.restype = ctypes.c_double
コード例 #7
0
ファイル: server_ela035.py プロジェクト: Languafe/PyTinker
    def do_GET(self):
        
        try:
            client_hostname = self.headers["Client-Hostname"]
            
            # get permission from C3Server
            if not self.server.get_serve_permission(client_hostname):
                # send 503 service unavailable response
                self.send_response(httplib.SERVICE_UNAVAILABLE,
                                   self.responses[httplib.OK][0])
                msg = "Can't serve you. C3 told me not to."
                self.send_header("Content-Type", "text/plain")
                self.send_header("Content-Length", len(msg))
                self.end_headers()
                self.wfile.write(msg)
                return
            
            # permission was granted! proceed
            
            # read parameters which are found as headers in the HTTP request
            cloudiness_forecast_time = self.headers["Cloudiness-Forecast-Time"]
            cloudiness_sample_size = self.headers["Cloudiness-Sample-Size"]
            
            sample_size = int(cloudiness_sample_size)
            
            forecast_dt = datetime.datetime.strptime(cloudiness_forecast_time,
                                                     '%Y-%m-%dT%H:%M')
            
            if forecast_dt.hour == 23 and forecast_dt.minute == 45:
                pass
            # sample size defines how many surrounding images should be used
            # when doing the cloudiness calculation and finding an average
            if sample_size > 0:
                sample_times = date_helper.get_surrounding_datetimes_n_years(
                                     forecast_dt,
                                     constants.WTHR_IMG_FREQ_MINS,
                                     constants.WTHR_IMG_FREQ_MINS * sample_size,
                                     sample_size)
                
                # OLD VARIANT: ONLY SAMPLE SAME YEAR
#                sample_times = get_surrounding_datetimes(forecast_dt,
#                                   constants.WTHR_IMG_FREQ_MINS,
#                                   constants.WTHR_IMG_FREQ_MINS * sample_size)
            else:
                sample_times = [forecast_dt]
            
            sw = util.stopwatch()
            sw.start()
            
            # temporary dict to hold time/cloudiness key/value pairs
            t_c_temp_dict = {}
            
            # temporary dict to hold time/raw-image key/value pairs
            t_img_temp_dict = {}
            
            # for each sample time, check cache for cloudiness value
            # download image and calc if not there
            actual_image = None
            for t in sample_times:
                # Check cache.
                t_c_temp_dict[t] = self._getCachedCloudinessValue(t)
                if t_c_temp_dict[t] != None:
                    continue # Cache hit!
                else:
                    # No cigar. Have to download image and calculate.
                    t_img_temp_dict[t] = self.server.dl_weather_image(t)
                    if not t_img_temp_dict[t]: continue # couldn't get image
                    if t == forecast_dt:
                        actual_image = t_img_temp_dict[t]
            
            sw.stop()
            time_taken_imgdl = sw.getresult_ms()
            
            cloudiness_values = []
            for c in t_c_temp_dict.itervalues():
                if c != None:
                    cloudiness_values.append(c)
                else:
                    pass
            
            sw.start()
            # Calculate the cloudiness values for all images.
            img = None
            for t, img in t_img_temp_dict.iteritems():
                if img: # Might be None, if the server replied 404 Not Found
                    cloudiness_value = self.server.get_image_cloudiness(img)
                    cloudiness_values.append(cloudiness_value)
                    self._saveCloudinessValue(t, cloudiness_value)
                    self._saveCloudyImage(cloudiness_value, img)
            sw.stop()
            time_taken_calc = sw.getresult_ms()
            
            if len(cloudiness_values) == 0:
                pass
            
            # the average cloudiness value
            cloudiness_value = float(sum(cloudiness_values) / 
                                     len(cloudiness_values))
            
            # TODO: find an image that matches the forecasted cloudiness value
            if not img:
                # first check image cache
                img = self._getCachedCloudyImage(cloudiness_value)
                
                if img:
                    print "Reqtime: %s - Cloudy image cache hit!" % str(cloudiness_forecast_time)
                else:
                    # actually have to download an image...
                    while img == None:
                        print "Reqtime: %s - Cache fail, having to DL..." % str(cloudiness_forecast_time)
                        t = forecast_dt
                        img = self.server.dl_weather_image(t)
                        t = date_helper.add_minutes(t,
                                                constants.WTHR_IMG_FREQ_MINS)
            forecasted_image = img
            
            if not forecasted_image:
                print "I have no image to return!"
                raise Exception
            
            actual_cloudiness = self._getCachedCloudinessValue(forecast_dt)

            # in case of cache-hit, the actual image is not in memory
            if actual_image == None:
                sw.start()
                actual_image = self.server.dl_weather_image(forecast_dt)
                sw.stop()
                time_taken_imgdl += sw.getresult_ms()
                if actual_image == None:
                    actual_image = self._getCachedCloudyImage(actual_cloudiness)
                    if actual_image == None:
                        actual_image = forecasted_image
            
            # send reponse back to client
            # the payload is a blob containing both images.. their sizes
            # defined in HTTP headers Blob1-Size and Blob2-Size
            self.send_response(httplib.OK, self.responses[httplib.OK][0])
            self.send_header("Content-Type", "ela035/2ximageblob")
            self.send_header("Content-Length",
                             len(forecasted_image) + len(actual_image))
            self.send_header("Blob1-Size", len(forecasted_image))
            self.send_header("Blob2-Size", len(actual_image))
            self.send_header("Cloudiness-Forecast", str(cloudiness_value))
            self.send_header("Actual-Cloudiness", str(actual_cloudiness))
            self.send_header("Image-Download-Time", str(time_taken_imgdl))
            self.send_header("Calc-Time", str(time_taken_calc))
            self.end_headers()
            self.wfile.write(forecasted_image)
            self.wfile.write(actual_image)
            
            self.server.imgdltime = time_taken_imgdl
            self.server.cloudcalctime = time_taken_calc
            
        except Exception as e:
            print e
            msg = "Internal server error :-("
            self.send_response(httplib.INTERNAL_SERVER_ERROR,
                           self.responses[httplib.INTERNAL_SERVER_ERROR][0])
            self.send_header("Content-Length", len(msg))
            self.end_headers()
            self.wfile.write(msg)