Adjust the funding progress filter to be a factor of 10
16001
def __normalize_progress(self):
        

        progress = self['funding_progress']
        if progress % 10 != 0:
            progress = round(float(progress) / 10)
            progress = int(progress) * 10

            self['funding_progress'] = progress
622302
function updateStepProgressIO() {
    io.stepProgress = stepEl.map((el, i) => {
      const marginTop = stepOffsetHeight[i] - offsetMargin;
      const marginBottom = -viewH + offsetMargin;
      const rootMargin = `${marginTop}px 0px ${marginBottom}px 0px`;
      const threshold = createThreshold(stepOffsetHeight[i]);
      const options = { rootMargin, threshold };
      // console.log(options);
      const obs = new IntersectionObserver(intersectStepProgress, options);
      obs.observe(el);
      return obs;
    });
  }
453427
def funding_info2marc(self, key, value):
    """"""
    return {
        'a': value.get('agency'),
        'c': value.get('grant_number'),
        'f': value.get('project_number'),
    }
1082489
private void adjustReplicationFactorForURI(HttpPut httpPut) throws URISyntaxException{
        String queryString = httpPut.getURI().getQuery();
        if(!StringUtils.isEmpty(queryString) && queryString.contains("op=CREATE") && (queryString.contains("replication=") || !StringUtils.isEmpty(m_blockReplication))){
            rateLimitedLogWarn(m_logger, "Set block replication factor in the target system.");
            if(!StringUtils.isEmpty(m_blockReplication) && !queryString.contains("replication=")){
                StringBuilder builder = new StringBuilder(128);
                builder.append(queryString).append("&replication=").append(m_blockReplication);
                URI oldUri = httpPut.getURI();
                URI newUri = new URI(oldUri.getScheme(), oldUri.getAuthority(),oldUri.getPath(), builder.toString(), oldUri.getFragment());
                httpPut.setURI(newUri);
            }
        }
    }
884310
def _twofilter_smoothing_ON(self, t, ti, info, phi, lwinfo, return_ess,
                               modif_forward, modif_info):
        
        if modif_info is not None:
            lwinfo += modif_info
        Winfo = rs.exp_and_normalise(lwinfo)
        I = rs.multinomial(Winfo)
        if modif_forward is not None:
            lw = self.wgt[t].lw + modif_forward
            W = rs.exp_and_normalise(lw)
        else:
            W = self.wgt[t].W
        J = rs.multinomial(W)
        log_omega = self.model.logpt(t + 1, self.X[t][J], info.hist.X[ti][I])
        if modif_forward is not None:
            log_omega -= modif_forward[J]
        if modif_info is not None:
            log_omega -= modif_info[I]
        Om = rs.exp_and_normalise(log_omega)
        est = np.average(phi(self.X[t][J], info.hist.X[ti][I]), axis=0,
                         weights=Om)
        if return_ess:
            return (est, 1. / np.sum(Om**2))
        else:
            return est
1323320
private int adjustAlpha(int color, float factor) {
        int alpha = Math.round(Color.alpha(color) * factor);
        int red = Color.red(color);
        int green = Color.green(color);
        int blue = Color.blue(color);
        return Color.argb(alpha, red, green, blue);
    }
1209534
function writeProgress(id, total, completed) {
    var percent = Math.round(10 * (100 * completed) / total) / 10;
    if(id == lastProgressId) {
        readline.cursorTo(process.stdout, 0);
        readline.clearLine(process.stdout, 0);
    } else {
        lastProgressId = id;
        process.stdout.write('\n');
    }
    var progressTitles = {
        projects: 'Indexing Projects',
        chunks: 'Indexing Chunks',
        ta: 'Indexing translationAcademy',
        resources: 'Indexing Resources',
        container: 'Downloading Containers',
        catalog: 'Indexing Catalogs',
        langnames: 'Indexing Target Languages',
        'temp-langnames': 'Indexing Temporary Target Languages',
        'approved-temp-langnames': 'Indexing Approved Temporary Target Languages',
        'new-language-questions': 'Indexing Questionnaire'
    };
    process.stdout.write((progressTitles[id] || id) + ' [' + total + '] ' + percent + '%');
}
823860
def apply(cls, args, run):
        """"""
        try:
            priority = float(args)
        except ValueError:
            raise ValueError("The PRIORITY argument must be a number! "
                             "(but was '{}')".format(args))
        run.meta_info['priority'] = priority
10233
def __reorganize_funding(self):
        
        _map = {"agency": "Funding_Agency_Name", "grant": "Grant"}
        try:
            _l = []
            for item in self.noaa_data_sorted["Funding_Agency"]:
                _tmp = {}
                for lpd_name, noaa_name in _map.items():
                    val = ""
                    if lpd_name in item:
                        val = item[lpd_name]
                    _tmp[noaa_name] = val
                _l.append(_tmp)
            self.noaa_data_sorted["Funding_Agency"] = _l
        except Exception:
            pass
        return
1108033
def round_float(float, places)
      factor = Float(10 * places)
      Float((float * factor).round / factor)
    end
1210500
def more_time(self, factor=1):
        
        base_increase = int(self.timelimit_hard / 10)

        new_time = self.timelimit + base_increase*factor
        print('qadapter: trying to increase time')
        if new_time < self.timelimit_hard:
            self.set_timelimit(new_time)
            print('new time set: ', new_time)
            return new_time

        self.priority = -1

        raise self.Error("increasing time is not possible, the hard limit has been reached")
1027631
def run_filter_calculation(self):
        """"""
        inputs = {
            'cif': self.inputs.cif,
            'code': self.inputs.cif_filter,
            'parameters': self.inputs.cif_filter_parameters,
            'metadata': {
                'options': self.inputs.options.get_dict(),
            }
        }

        calculation = self.submit(CifFilterCalculation, **inputs)
        self.report('submitted {}<{}>'.format(CifFilterCalculation.__name__, calculation.uuid))

        return ToContext(cif_filter=calculation)
1121455
def filter_value(old: float, new: float, factor: float) -> float:
    
    r_factor: float = 1 - factor
    return old * r_factor + new * factor
1218635
def p_term_mult_factor(self, args):
        '  '
        op = 'multiply' if args[1].attr == '*' else 'divide'
        return AST(op, [args[0], args[2]])
52962
function _fnReDraw( oSettings )
		{
			if ( oSettings.oFeatures.bSort )
			{
				/* Sorting will refilter and draw for us */
				_fnSort( oSettings, oSettings.oPreviousSearch );
			}
			else if ( oSettings.oFeatures.bFilter )
			{
				/* Filtering will redraw for us */
				_fnFilterComplete( oSettings, oSettings.oPreviousSearch );
			}
			else
			{
				_fnCalculateEnd( oSettings );
				_fnDraw( oSettings );
			}
		}
691268
def progress(self, percent, tag, summary):
        

        if self.progress_updates:
            self.progress_updates(percent, tag, summary)
1157418
private static void adjustQuality(Map<String, Float> pFormatQuality, String pFormat, float pFactor) {
        Float oldValue = pFormatQuality.get(pFormat);
        if (oldValue != null) {
            pFormatQuality.put(pFormat, oldValue * pFactor);
            //System.out.println("New vallue after multiplying with " + pFactor + " is " + pFormatQuality.get(pFormat));
        }
    }