query stringlengths 7 9.55k | document stringlengths 10 363k | metadata dict | negatives listlengths 0 101 | negative_scores listlengths 0 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
GET /small_categories/1 GET /small_categories/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @small_categories = SmallCategory.category_tree\n end",
"def get_categories\r\n categories = Taxonomy.get_categories\r\n render json: categories, root: 'categories', adapter: :json, status: :ok\r\n end",
"def show\n @category = current_mall.categories.find(params[:id])\n\n respond_... | [
"0.7403451",
"0.7039488",
"0.6943573",
"0.6831773",
"0.6779547",
"0.6777059",
"0.67678666",
"0.6682012",
"0.6680672",
"0.66804624",
"0.6618794",
"0.6544207",
"0.65387845",
"0.6537628",
"0.6519212",
"0.6511467",
"0.6469702",
"0.6464422",
"0.645643",
"0.6456127",
"0.64559233",
... | 0.0 | -1 |
GET /small_categories/new POST /small_categories/new | def new
@small_category = params[:small_category].blank? ? SmallCategory.new : SmallCategory.new(small_category_params)
@middle_categories = params[:small_category].blank? ? [] : MiddleCategory.belongs_to_select_category(@small_category)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @category = current_mall.categories.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @category }\n end\n end",
"def create\n @category = current_mall.categories.new(params[:category])\n\n if @category.save\n render json: @category, ... | [
"0.7599372",
"0.7436776",
"0.73191315",
"0.7305896",
"0.7305523",
"0.729886",
"0.729886",
"0.729886",
"0.729886",
"0.729886",
"0.729886",
"0.729886",
"0.729886",
"0.729886",
"0.72639686",
"0.721994",
"0.71961164",
"0.7194415",
"0.7190505",
"0.7173566",
"0.7167257",
"0.71672... | 0.75364023 | 1 |
POST /small_categories POST /small_categories.json | def create
@small_category = SmallCategory.new(small_category_params)
@middle_categories = MiddleCategory.belongs_to_select_category(@small_category)
respond_to do |format|
if @small_category.save
format.html { redirect_to @small_category, notice: 'Small category was successfully created.' }
format.json { render :show, status: :created, location: @small_category }
else
format.html { render :new }
format.json { render json: @small_category.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_category payload\n\t\t\t\t\tFreshdesk::Api::Client.convert_to_hash( @connection.post CATEGORIES, payload )\n\t\t\t\tend",
"def create\n @category = current_mall.categories.new(params[:category])\n\n if @category.save\n render json: @category, status: :created\n else\n render json: @... | [
"0.67540145",
"0.67008865",
"0.6649466",
"0.65137607",
"0.6463984",
"0.6255166",
"0.62549263",
"0.62489",
"0.62020236",
"0.6184038",
"0.6100942",
"0.60702384",
"0.60618144",
"0.60126746",
"0.6008584",
"0.59962374",
"0.59774387",
"0.5950301",
"0.59440404",
"0.59300154",
"0.592... | 0.70756996 | 0 |
PATCH/PUT /small_categories/1 PATCH/PUT /small_categories/1.json | def update
respond_to do |format|
if @small_category.update(small_category_params)
format.html { redirect_to @small_category, notice: 'Small category was successfully updated.' }
format.json { render :show, status: :ok, location: @small_category }
else
format.html { render :edit }
format.json { render json: @small_category.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n json_update(category,category_params, Category)\n end",
"def UpdateCategory params = {}\n \n APICall(path: 'categories.json',method: 'PUT',payload: params.to_json)\n \n end",
"def update\n @category = current_mall.categories.find(params[:id])\n\n respond_to do |... | [
"0.7205932",
"0.6982739",
"0.66089904",
"0.65017295",
"0.6484789",
"0.6402913",
"0.63672304",
"0.63492614",
"0.6342305",
"0.6331205",
"0.62922287",
"0.6287212",
"0.62664473",
"0.62326527",
"0.6226831",
"0.62040865",
"0.6201676",
"0.61860716",
"0.6170401",
"0.6161582",
"0.6157... | 0.72819114 | 0 |
DELETE /small_categories/1 DELETE /small_categories/1.json | def destroy
@small_category.destroy
respond_to do |format|
format.html { redirect_to small_categories_url, notice: 'Small category was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @category.destroy\n render json: @category, status: :ok\n end",
"def destroy\n @mostsmallitemcategory = Mostsmallitemcategory.find(params[:id])\n @mostsmallitemcategory.destroy\n\n respond_to do |format|\n format.html { redirect_to mostsmallitemcategories_url }\n format.js... | [
"0.7292224",
"0.7285943",
"0.72328275",
"0.71988976",
"0.71651924",
"0.7128512",
"0.7127183",
"0.7088271",
"0.69978815",
"0.699226",
"0.69675535",
"0.6955662",
"0.6932504",
"0.6927744",
"0.6905976",
"0.6897117",
"0.6885006",
"0.6868557",
"0.6864013",
"0.6857345",
"0.6853729",... | 0.7622474 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_small_category
if params[:id].blank?
@small_category = SmallCategory.find(params[:id])
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def small_category_params
params.require(:small_category).permit(:large_category_code, :middle_category_code, :small_category_code, :small_category_name, :display_order)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.6981537",
"0.67835593",
"0.6748275",
"0.67436063",
"0.6736311",
"0.65937173",
"0.6503359",
"0.6498499",
"0.6482832",
"0.6478776",
"0.645703",
"0.6439998",
"0.63802195",
"0.6377008",
"0.6366287",
"0.632018",
"0.63016284",
"0.63011277",
"0.62932974",
"0.62919617",
"0.6290564... | 0.0 | -1 |
Print the values of the file | def print_file_content file_name
puts "\n==========================================="
puts "Printing the content of the file"
puts "===========================================\n"
# Open file
file = File.open(file_name)
# Print file's content
puts file.read
puts "_____________________________________________\n"
# Close the file
file.close
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fprint(file)\n end",
"def print_all(f)\n\t# print what is read from the file\n\tputs f.read()\n# ends the print_all function definition\nend",
"def print_file(*) end",
"def print_all(f)\t\t\t\t\t\t\t\t#prints the entire file\r\n puts f.read\r\nend",
"def print_info\n self.values.each do |value|\n ... | [
"0.6757947",
"0.6681452",
"0.66658074",
"0.6604294",
"0.64982814",
"0.6474888",
"0.64100283",
"0.6407218",
"0.6379692",
"0.63721097",
"0.6366937",
"0.63589686",
"0.6317189",
"0.6317189",
"0.6317189",
"0.6306917",
"0.62732315",
"0.62394875",
"0.62255955",
"0.62144667",
"0.6211... | 0.63746405 | 9 |
Add lines to file | def add_lines_to_file file_name
# Change the mode of the file in order to add a new line to the existing file
file = File.open(file_name, 'a')
# Ask the user the amount of lines to be added
puts "How many lines would you like to add now?"
number_of_lines = gets.chomp
# According to the amount of lines, ask for each line
number_of_lines.to_i.times do |lines|
print "#{lines + 1}: "
file.write(gets)
end
# Close the file
file.close
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_lines file_path, new_lines\n File.open(file_path, 'w') do |file|\n new_lines.each do |new_line|\n file.puts new_line\n end\n end\n end",
"def add_line_to_file(file, line)\n File.open(file, \"a\") {|f| f.puts(\"#{line}\")}\n end",
"def append_line\n File.open(path, 'w') ... | [
"0.7568495",
"0.7506521",
"0.73799103",
"0.71466124",
"0.7130017",
"0.68509454",
"0.68487877",
"0.68437266",
"0.6832852",
"0.6683078",
"0.66519886",
"0.6649006",
"0.6624918",
"0.655468",
"0.6544069",
"0.6493978",
"0.6493978",
"0.64913505",
"0.6481261",
"0.63838375",
"0.638377... | 0.68783844 | 5 |
Find a way to accumulate the :worldwide_grosses and return that Integer using director_data as input | def gross_for_director(director_data)
grand_total = 0
row_index = 0
column_index = 0
while column_index < directors_database[row_index][:movies].length do
grand_total += directors_database[row_index][:movies][column_index][:worldwide_gross]
column_index += 1
end
grand_total
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gross_for_director(director_data)\n movie_index = 0\n worldwide_grosses = 0\n while movie_index < director_data[:movies].length\n worldwide_grosses += director_data[:movies][movie_index][:worldwide_gross]\n movie_index += 1\n end\nworldwide_grosses\nend",
"def gross_for_director(director_data)\n s... | [
"0.8031094",
"0.79803103",
"0.7979809",
"0.7938483",
"0.7927118",
"0.7893617",
"0.78402203",
"0.77561146",
"0.77524376",
"0.7717609",
"0.76706547",
"0.7670455",
"0.7654349",
"0.7608682",
"0.76027364",
"0.7602346",
"0.7588497",
"0.7581547",
"0.75780565",
"0.7557646",
"0.752664... | 0.7245815 | 37 |
Read node and assert the number of blocks received and final string read. | def assert_read_node(node, assert_nblocks, assert_string, chunksize = 1024)
count = 0
read_str = ''
node.read_stream(chunksize) do |bytes|
read_str += bytes
count += 1
end
assert_equal(assert_nblocks, count)
assert_equal(assert_string, read_str)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read() end",
"def read(&block)\n @read_block = block\n end",
"def read; @connection.readline end",
"def read(maxbytes=1024)\n \"\"\"Buffered read from node, non-blocking.\n maxbytes: maximum number of bytes to return\"\"\"\n count = @readbuf.length\n if count < maxbytes\n data = F... | [
"0.6415364",
"0.6059077",
"0.6001863",
"0.59931433",
"0.597769",
"0.5886506",
"0.58638775",
"0.58447427",
"0.58443344",
"0.58215123",
"0.5793422",
"0.57863724",
"0.57547176",
"0.57250977",
"0.56992275",
"0.569198",
"0.569198",
"0.569198",
"0.569198",
"0.569198",
"0.569198",
... | 0.76814175 | 0 |
List available Ubuntu ISOs | def list_ps_isos(options)
if not options['search'].to_s.match(/[a-z]|[A-Z]|all/)
options['search'] = "ubuntu|debian|purity"
end
list_linux_isos(options)
return
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_ps_isos()\n search_string = \"ubuntu\"\n list_linux_isos(search_string)\n return\nend",
"def update_instace_os\n ssh_command = 'sudo apt-get update &&sudo apt-get dist-upgrade -qq && sudo apt-get autoremove -y'\n result = ''\n Net::SSH.start(get_access_ip, 'ubuntu', keys: @aws_setup_informat... | [
"0.7799593",
"0.6395915",
"0.6305853",
"0.6295106",
"0.62792945",
"0.6254741",
"0.62484974",
"0.61704725",
"0.6116889",
"0.6087367",
"0.6015547",
"0.5999713",
"0.59866023",
"0.5981298",
"0.5974943",
"0.59640175",
"0.5927067",
"0.5871007",
"0.5868547",
"0.5868111",
"0.5863934"... | 0.6830707 | 1 |
Create scope for self reference. | def with!( &blk )
self.instance_eval &blk
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_scope\n sprintf \"%s/%s/signer\", @self_key, @client_id\n end",
"def create_with_scope(name); end",
"def scope\n @scope ||= Scope.new(parent)\n end",
"def subscope\n self.clone\n end",
"def scope; end",
"def scope; end",
"def scope; end",
"def scope; end",
"def sc... | [
"0.7064122",
"0.7053947",
"0.70463556",
"0.69084835",
"0.680576",
"0.680576",
"0.680576",
"0.680576",
"0.680576",
"0.680576",
"0.680576",
"0.680576",
"0.680576",
"0.680576",
"0.6723206",
"0.67225903",
"0.6660576",
"0.65221196",
"0.65164864",
"0.65164864",
"0.64795",
"0.6449... | 0.0 | -1 |
Create scope for self reference with return value. | def with( &blk )
# blk[ self ]
self.instance_eval &blk
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scope() binding end",
"def scope() yield end",
"def scope=(_); end",
"def scope\n Repository.context << self\n\n begin\n return yield(self)\n ensure\n Repository.context.pop\n end\n end",
"def scope; end",
"def scope; end",
"def scope; end",
"def scope; end",
... | [
"0.70492154",
"0.7005944",
"0.6858635",
"0.6824435",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6777215",
"0.6709526",
"0.6705544",
"0.6686524",
"0.66235304",
"0.66221595",
"0.66221595",
"0.66221595"... | 0.0 | -1 |
Vector angle in radians. | def rad
x = self[0]
y = self[1]
if x >= 0 && y >= 0
Math.atan( y.to_f/x )
elsif x < 0 && y >= 0
Math::PI + Math.atan( y.to_f/x )
elsif x < 0 && y < 0
Math::PI + Math.atan( y.to_f/x )
else
2*Math::PI + Math.atan( y.to_f/x )
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle\n v = to_vec\n if v[1] == 0.0\n nil\n else\n v.angle\n end\n end",
"def angle_deg_with( vector )\n angle_with(vector) * RAD_TO_DEG\n end",
"def angle_with( vector )\n Math.acos( max(min(udot(vector),MAX_UDOT_PRODU... | [
"0.7913408",
"0.7820214",
"0.77478164",
"0.77000207",
"0.7615311",
"0.75463444",
"0.75269675",
"0.7437196",
"0.73631984",
"0.72871995",
"0.72649664",
"0.7088439",
"0.7063321",
"0.7063321",
"0.7038377",
"0.7029529",
"0.6993117",
"0.69633585",
"0.6938816",
"0.69376075",
"0.6937... | 0.672352 | 27 |
Vector angle in degrees. | def angle
rad / Math::PI * 180
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle_deg_with( vector )\n angle_with(vector) * RAD_TO_DEG\n end",
"def angle\n v = to_vec\n if v[1] == 0.0\n nil\n else\n v.angle\n end\n end",
"def angle_with( vector )\n Math.acos( max(min(udot(vector),MAX_UDOT_PRODU... | [
"0.82692105",
"0.81728846",
"0.7931938",
"0.7907023",
"0.7707085",
"0.7619307",
"0.76081806",
"0.7536134",
"0.74568915",
"0.7371097",
"0.7371097",
"0.7181609",
"0.709432",
"0.7070992",
"0.7070992",
"0.70384777",
"0.699521",
"0.69310915",
"0.69081914",
"0.6787469",
"0.67344135... | 0.7317625 | 11 |
Vector angle in degress clockwise. | def anglecw
360 - angle
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle_deg_with( vector )\n angle_with(vector) * RAD_TO_DEG\n end",
"def angle_with( vector )\n Math.acos( max(min(udot(vector),MAX_UDOT_PRODUCT), MIN_UDOT_PRODUCT) )\n end",
"def angle\n v = to_vec\n if v[1] == 0.0\n nil\n else\n v.angl... | [
"0.8214546",
"0.7807029",
"0.7625727",
"0.7581855",
"0.74618256",
"0.74170554",
"0.7261384",
"0.7181406",
"0.7181406",
"0.7175556",
"0.71114063",
"0.7101709",
"0.7101709",
"0.7043026",
"0.70115787",
"0.6980978",
"0.6975036",
"0.68705624",
"0.67562675",
"0.66572106",
"0.659186... | 0.6623477 | 20 |
Rotate vector by angle (rad). | def rotate( rad )
ca = Math.cos( rad )
sa = Math.sin( rad )
Vector[ ca*x - sa*y, sa*x + ca*y ]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotate!( angle_rad )\n self.angle += angle_rad\n self\n end",
"def rotate( vector )\n\t\t\t(self.inverse * self.class.new(vector) * self ).vec \n\t\tend",
"def rotate(radians)\n sin = Math.sin radians\n cos = Math.cos radians\n Vector.new cos * @x - sin * @y, sin * @x + cos * @y\n ... | [
"0.76327914",
"0.75118476",
"0.7491918",
"0.7341193",
"0.7296169",
"0.7290703",
"0.70138305",
"0.70096606",
"0.6975382",
"0.6774302",
"0.67328626",
"0.6729128",
"0.6663027",
"0.6594455",
"0.6542747",
"0.65046215",
"0.64978117",
"0.64678395",
"0.64479715",
"0.63984674",
"0.634... | 0.80557853 | 0 |
Convert vec to Pos. | def to_pos
Sivigi::Pos.ini( *self.to_a )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def position(arg_)\n vector_ = _vector(arg_)\n vector_ ? Position.new(self, vector_) : nil\n end",
"def pos_to_coords(pos)\n x = (pos % size)\n y = size - 1 - (pos / size).to_i\n\n Point.new x, y\n end",
"def coords_to_pos(point)\n (size - 1 - point.y) * size + point.x\n end",
"def... | [
"0.6448256",
"0.6326084",
"0.6164925",
"0.59878635",
"0.58127075",
"0.5650395",
"0.561136",
"0.55683386",
"0.5526858",
"0.54820454",
"0.5460322",
"0.54585177",
"0.54454464",
"0.5441385",
"0.53928864",
"0.5262862",
"0.52564585",
"0.52340513",
"0.51947004",
"0.517655",
"0.51714... | 0.6135608 | 3 |
Convert vec to Gpos. | def to_gpos
Point[ self.x, self.y ]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pos_to_a\r\n [ pos.x, pos.y ]\r\n end",
"def vector\n\t\treturn [(end_lng - start_lng), (end_lat - start_lat)]\n\tend",
"def untransformed_vector(v)\r\n v.map{|x| x/@zoom }\r\n end",
"def to_vector\n return @vector_formatted_value if @vector_formatted_value\n\n vals = map(&:to_v... | [
"0.5863842",
"0.53547174",
"0.5345581",
"0.5239151",
"0.52113986",
"0.511595",
"0.5102833",
"0.507054",
"0.5060855",
"0.5058441",
"0.5050033",
"0.5002457",
"0.4983714",
"0.496432",
"0.49347177",
"0.483463",
"0.48279724",
"0.48211268",
"0.48193654",
"0.48163986",
"0.4785162",
... | 0.6606391 | 0 |
Return reference (relative) to self. | def ref
Coord.rel( self )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reference\n @reference\n end",
"def reference(absolute = true)\n absolute ? r_abs : r\n end",
"def ref\n @ref ||= self.node.attributes.to_h[\"ref\"]\n end",
"def relative; end",
"def relative\n return self if relative?\n @relativized ||= relative_path_from root\n en... | [
"0.724916",
"0.67988616",
"0.668189",
"0.6575793",
"0.655947",
"0.64626294",
"0.64463127",
"0.64463127",
"0.64058924",
"0.6351651",
"0.6309069",
"0.6236835",
"0.6182462",
"0.6159372",
"0.61592185",
"0.6142506",
"0.6137051",
"0.610297",
"0.60799104",
"0.6038543",
"0.5994584",
... | 0.8058419 | 0 |
Calculate with op and args. | def calculate( op, a1, a2 = nil )
case op
when :abs; a2
when :rel; a2
when :mul; a1 * a2
when :add; a1 + a2
when :sub; a1 - a2
when :inv; a1 * -1
else 0
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate(op, x, y)\n case op\n when 'plus'\n x.to_f + y.to_f\n when 'minus'\n x.to_f - y.to_f\n when 'divide'\n x.to_f / y.to_f\n when 'multiple'\n x.to_f * y.to_f\n end\nend",
"def input_process (*args)\n if(args.size == 1)\n input = args[0]\n operation = input.initial\n elsif(arg... | [
"0.6802243",
"0.67386746",
"0.67116904",
"0.66826856",
"0.66574097",
"0.6535872",
"0.6529503",
"0.6522885",
"0.65112835",
"0.6503546",
"0.64644724",
"0.6402219",
"0.6389848",
"0.63744324",
"0.6291956",
"0.62689924",
"0.62602925",
"0.6212174",
"0.62082213",
"0.6175043",
"0.617... | 0.7092065 | 0 |
Perform operation with op and val to self. | def operate( op, val = nil )
case val
when Coord
@rel |= true
@ops.push [ op, val ]
when Numeric, NilClass
if @rel == false
@ops[-1][1] = calculate( op, @ops[-1][1], val )
else
@ops.push [ op, val ]
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def oper=(value)\n @oper = value\n end",
"def operation(op, other)\n x = value.__send__(op, other.to_r)\n self.class.new(x, base)\n end",
"def operate(value)\n value\n end",
"def... | [
"0.7048466",
"0.6908954",
"0.6797237",
"0.6465645",
"0.6352474",
"0.6333844",
"0.6293629",
"0.626408",
"0.6255905",
"0.624365",
"0.6200963",
"0.61612594",
"0.60966045",
"0.60838795",
"0.5984352",
"0.5982734",
"0.59773827",
"0.5974858",
"0.59515494",
"0.5937962",
"0.5910983",
... | 0.77737004 | 0 |
Memoize value and update if needed. | def value
if @value
@value
else
@value = resolve( :value )
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_value?; end",
"def memo; end",
"def memo\n end",
"def force!\n return @value if defined?(@value) and @memoized\n @value = Heist.evaluate(@expression, @scope)\n end",
"def memo\n derived_values.last\n end",
"def memoize(key)\n return instance_variable_get(\"@#{key}... | [
"0.69794345",
"0.690663",
"0.68545806",
"0.6799522",
"0.66469467",
"0.65592515",
"0.6446827",
"0.6438204",
"0.6438204",
"0.63986784",
"0.6325129",
"0.6271058",
"0.6162419",
"0.6140298",
"0.610175",
"0.60516554",
"0.60301244",
"0.60164315",
"0.5966094",
"0.59623355",
"0.595802... | 0.0 | -1 |
Unmemoize value, i.e. allow new resolve. | def revalue
@value = nil
@ops.each do |v|
v[1].revalue
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def force!\n return @value if defined?(@value) and @memoized\n @value = Heist.evaluate(@expression, @scope)\n end",
"def lookup_uncached(val); end",
"def lookup_uncached(val); end",
"def unresolve\n change_state(:unresolve)\n end",
"def clean_memoized\n @distance = nil\n @s... | [
"0.7139475",
"0.65577215",
"0.65577215",
"0.6105795",
"0.58836305",
"0.5871588",
"0.5811495",
"0.5803368",
"0.5759188",
"0.57497215",
"0.57142514",
"0.5686897",
"0.5686897",
"0.56103516",
"0.5608445",
"0.56049466",
"0.5598495",
"0.55725574",
"0.55569255",
"0.55513656",
"0.552... | 0.5598476 | 17 |
Resolve the list of operations. | def resolve( method = :resolve )
val = 0
@ops.each do |v|
val = calculate( v[0], val, v[1].send( method ) )
end
val
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def operations\n ops = {}\n spec_with_resolved_refs['definition']['paths'].each do |path, verbs|\n verbs.except('parameters').each do |verb, operation|\n ops[[verb, path]] = operation\n end\n end\n ops\n end",
"def resolve( op )\n # TODO\n end",
"def operations\n un... | [
"0.6646657",
"0.6484989",
"0.6419717",
"0.63941073",
"0.63658935",
"0.63658935",
"0.63129866",
"0.62812144",
"0.620861",
"0.620861",
"0.620861",
"0.620861",
"0.620861",
"0.6076093",
"0.6049982",
"0.6036892",
"0.59961826",
"0.5974864",
"0.59591115",
"0.58958954",
"0.5879469",
... | 0.49972758 | 75 |
Marshal only ops, since value will be resolved anyhow. | def marshal_dump
[ @ops, @rel ]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def marshal_load( data )\n @value = nil\n @ops = data[0]\n @rel = data[1]\n end",
"def pack(value)\n throw \"Not implemented\"\n end",
"def marshal_dump; end",
"def marshal\n @data\n end",
"def value= (val) ; write_attribute(:value, Marshal.dump... | [
"0.63289523",
"0.6265299",
"0.62213576",
"0.5971349",
"0.59075123",
"0.58763254",
"0.58195114",
"0.58055735",
"0.57567585",
"0.5736816",
"0.5736816",
"0.5736816",
"0.5716749",
"0.55943686",
"0.55578506",
"0.5545961",
"0.55401605",
"0.55401605",
"0.5491396",
"0.5471807",
"0.54... | 0.5659076 | 13 |
Marshal load only ops, and reset value to nil. | def marshal_load( data )
@value = nil
@ops = data[0]
@rel = data[1]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(op)\n @ops.unshift(op)\n end",
"def operations=(ops)\n # Clear the current operations\n self.operation_definitions = []\n # Load operations with the set given\n ops.each{|op| operation(*op) }\n end",
"def marshal_dump\n [ @ops, @rel ]\n end",
"def add_tree_data_to_... | [
"0.60617846",
"0.55062324",
"0.55056757",
"0.5441609",
"0.5100858",
"0.50343853",
"0.5001576",
"0.4948668",
"0.4943391",
"0.49080527",
"0.48759237",
"0.48759237",
"0.48625645",
"0.4822915",
"0.48127896",
"0.48086533",
"0.4780703",
"0.4727242",
"0.47192112",
"0.470888",
"0.468... | 0.68567395 | 0 |
Initialize, and default to nil for x, y. | def initialize( x = nil, y = nil )
@x = x
@y = y
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(x = nil, y = nil)\n set(x,y) ;\n end",
"def initialize x, y\n\t\t@x = x\n\t\t@y = y\n\tend",
"def initialize(x = 0, y = 0)\n @x = x\n @y = y\n end",
"def initialize(x = 0, y = 0)\n @x = x\n @y = y\n end",
"def initialize(x, y)\n @x, @y = x, y\n end",
"... | [
"0.77593863",
"0.7714276",
"0.75249875",
"0.75249875",
"0.7506404",
"0.7468124",
"0.7468124",
"0.74493736",
"0.7409078",
"0.73670906",
"0.7366081",
"0.73502046",
"0.7340206",
"0.7329963",
"0.7311726",
"0.7311726",
"0.7311726",
"0.7311726",
"0.72776127",
"0.723264",
"0.723264"... | 0.81413215 | 0 |
Set position value. Options: a.set 2,3 List (x,y) a.set Pos.new(2,3) Other Pos a.set [2,3] Array (x,y) a.set :l, 2 Dir dir, len | def set( *pos )
if pos.length > 1
if pos[0].kind_of? Symbol
self.dir( *pos )
else
@x = Coord.set( pos[0] )
@y = Coord.set( pos[1] )
end
else
pos = pos[0]
if pos.kind_of? Pos
@x, @y = pos.xref, pos.yref
else
@x = Coord.set( pos[0] )
@y = Coord.set( pos[1] )
end
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pos=(val)\n #setter method for position \n row, col = val\n @pos = val\n\n end",
"def pos=(val)\n @pos = val\n\n end",
"def pos=(pos); end",
"def setPosition _obj, _args\n \"_obj setPosition _args;\" \n end",
"def setPos _obj, _args\n \"_obj setPos _args;\... | [
"0.70829475",
"0.7045662",
"0.6937381",
"0.68984836",
"0.6866571",
"0.6862319",
"0.67840755",
"0.675797",
"0.66469884",
"0.6634383",
"0.66020834",
"0.66020834",
"0.65997165",
"0.6495707",
"0.64207315",
"0.6392408",
"0.63411623",
"0.6314484",
"0.6297579",
"0.6297579",
"0.62975... | 0.7459019 | 0 |
Create pos per direction and length (distance). | def dir( dir, len )
case dir
when :u; self.ini( 0, -len )
when :r; self.ini( len, 0 )
when :d; self.ini( 0, len )
when :l; self.ini( -len, 0 )
else; raise RuntimeError, "Unknown dir: #{dir}"
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dir( pos, dir, len )\n @p1.set pos\n @p2.set( @p1.dup + Pos.dir( dir, len ) )\n self\n end",
"def directional_offset(direction)\n return self + Position.new(*direction)\n end",
"def direction\n\t\tpoint_x = end_junction.position.x - start_junction.position.x\n\t\... | [
"0.597966",
"0.5853418",
"0.5838174",
"0.5716898",
"0.5619822",
"0.5612073",
"0.55242026",
"0.55185646",
"0.5495637",
"0.5363215",
"0.53254575",
"0.5316303",
"0.52891016",
"0.52380705",
"0.52265817",
"0.52189505",
"0.5214219",
"0.5209915",
"0.5205149",
"0.5196003",
"0.5176508... | 0.0 | -1 |
Initialize x, y to Coord. | def ini( x, y )
@x = Coord.set( x )
@y = Coord.set( y )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize x, y\n\t\t@x = x\n\t\t@y = y\n\tend",
"def initialize\n self.x, self.y = 0, 0\n end",
"def initialize(x,y)\n @x,@y = x,y\n end",
"def initialize(x, y)\n @x, @y = x, y\n end",
"def initialize(x, y)\n @x, @y = x, y\n end",
"def initialize(x,y)\n @x,@y = x, y\n end",
"de... | [
"0.76871186",
"0.7636964",
"0.7627446",
"0.7580358",
"0.7580358",
"0.7558539",
"0.7548133",
"0.7542709",
"0.7487087",
"0.7477484",
"0.7468319",
"0.7373405",
"0.7373405",
"0.7331127",
"0.7331127",
"0.7331127",
"0.7331127",
"0.7331127",
"0.7331127",
"0.7331127",
"0.7331127",
... | 0.71831906 | 32 |
Return reference to pos. | def ref
Pos.new( self.xref.ref, self.yref.ref )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pos\n @pos\n end",
"def pos\n @position[:current]\n end",
"def pos\n @pos || uninitialized!\n end",
"def pos()\n #This is a stub, used for indexing\n end",
"def pos()\n #This is a stub, used for indexing\n end",
"def position\n return... | [
"0.8029688",
"0.801683",
"0.77850366",
"0.76581365",
"0.76581365",
"0.7620618",
"0.7620618",
"0.76003826",
"0.75630075",
"0.75403637",
"0.7513524",
"0.75076294",
"0.74191576",
"0.7303383",
"0.72831607",
"0.72831607",
"0.72831607",
"0.72664726",
"0.72664726",
"0.72664726",
"0.... | 0.7558552 | 9 |
Get reference to x. | def xref() @x end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getX\n @x\n end",
"def x; return self[0]; end",
"def x #getter method\n\t\t@x\n\tend",
"def x\n @components[:x]\n end",
"def getX() \n @x \n end",
"def x\n self[0]\n end",
"def x\n @virtual_x ||= @x\n end",
"def x\n @x\n end",
"def ref\n Coor... | [
"0.66592205",
"0.6632339",
"0.65823466",
"0.65735894",
"0.6482988",
"0.6467301",
"0.64663076",
"0.6429",
"0.6389732",
"0.63521546",
"0.63521546",
"0.63521546",
"0.6270614",
"0.62560797",
"0.62550795",
"0.6252771",
"0.6158049",
"0.6100572",
"0.605236",
"0.6016223",
"0.5981604"... | 0.6578095 | 3 |
Get reference to y. | def yref() @y end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def y\n object[\"y\"]\n end",
"def getY() @y end",
"def getY\n @y\n end",
"def y\n @y\n end",
"def y\n @components[:y]\n end",
"def y\n @point[1]\n end",
"def y\n self[1]\n end",
"def y; self[Y]; end",
"def y; self[Y]; end",
"def y; self[Y]; end",
"de... | [
"0.7331938",
"0.73107153",
"0.7258337",
"0.718065",
"0.7168593",
"0.6992508",
"0.68818414",
"0.6841281",
"0.6841281",
"0.6841281",
"0.6744945",
"0.6742617",
"0.66553044",
"0.6620901",
"0.6569226",
"0.6545064",
"0.65381444",
"0.6505084",
"0.6485232",
"0.6485232",
"0.64704996",... | 0.76098967 | 0 |
Memoize/evaluate x and return it. | def x!() @x.value end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def function(*x)\n val = (self.memoize ? memoized(*x) : process(*x))\n self.notify_observers(val)\n val\n end",
"def force!\n return @value if defined?(@value) and @memoized\n @value = Heist.evaluate(@expression, @scope)\n end",
"def evaluate(x)\n eval_sum = Ra... | [
"0.6879481",
"0.60169685",
"0.5880134",
"0.55800533",
"0.5575638",
"0.54959494",
"0.5451064",
"0.5312184",
"0.53060174",
"0.5203177",
"0.5191241",
"0.51811516",
"0.5176979",
"0.5176979",
"0.5176979",
"0.5149774",
"0.5120939",
"0.5109867",
"0.50931406",
"0.5066308",
"0.5065582... | 0.51917046 | 10 |
Memoize/evaluate y and return it. | def y!() @y.value end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def y()\n val = @b;\n @n.times {|i|\n val += @wn[i] * @xn[i];\n }\n return val;\n end",
"def y\n @y\n end",
"def force!\n return @value if defined?(@value) and @memoized\n @value = Heist.evaluate(@expression, @scope)\n end",
"def getY() @y... | [
"0.62909657",
"0.56899315",
"0.56087077",
"0.55443203",
"0.54855394",
"0.5452268",
"0.5449481",
"0.5390492",
"0.5377663",
"0.5324438",
"0.528763",
"0.528763",
"0.52580476",
"0.5211075",
"0.5206253",
"0.5204546",
"0.51874894",
"0.5180623",
"0.5179555",
"0.5166414",
"0.51200503... | 0.5791657 | 1 |
Get x without memoize. | def x() @x.resolve end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def x!() @x.value end",
"def x\n @virtual_x ||= @x\n end",
"def x #getter method\n\t\t@x\n\tend",
"def x\n 0\n end",
"def force!\n return @value if defined?(@value) and @memoized\n @value = Heist.evaluate(@expression, @scope)\n end",
"def get_x; \t\t@x \t\t\tend",
"de... | [
"0.66550714",
"0.6312074",
"0.622935",
"0.6162177",
"0.609755",
"0.6072983",
"0.6052767",
"0.6042075",
"0.6034676",
"0.6034676",
"0.6034676",
"0.6016346",
"0.5993629",
"0.5761303",
"0.5761195",
"0.5743128",
"0.57016927",
"0.5630303",
"0.55981845",
"0.55499136",
"0.55499136",
... | 0.51622844 | 54 |
Get y without memoize. | def y() @y.resolve end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def y!() @y.value end",
"def y\n @y\n end",
"def y()\n val = @b;\n @n.times {|i|\n val += @wn[i] * @xn[i];\n }\n return val;\n end",
"def y\n object[\"y\"]\n end",
"def getY() @y end",
"def y\n @data[:y]\n end",
"def y\n attr('y')\n ... | [
"0.7124484",
"0.7036554",
"0.68637264",
"0.67178947",
"0.6655036",
"0.653522",
"0.6474321",
"0.6472025",
"0.6450819",
"0.63326794",
"0.6168236",
"0.6087559",
"0.6087559",
"0.6087559",
"0.60483086",
"0.58961594",
"0.58961594",
"0.58961594",
"0.58769083",
"0.58624107",
"0.58384... | 0.5946574 | 15 |
Get pos without memoize. | def now
ret = self.dup
ret.xset self.x
ret.yset self.y
ret
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pos\n @pos || uninitialized!\n end",
"def get_pos(pos)\n build_pos_hash if @pos_hash.empty?\n @pos_hash[pos_to_sym(pos)]\n end",
"def pos\n @pos\n end",
"def pos()\n #This is a stub, used for indexing\n end",
"def pos()\n #This is a stub, used for indexing\... | [
"0.7253055",
"0.7064949",
"0.6857981",
"0.6750988",
"0.6618672",
"0.6618672",
"0.65503025",
"0.6534243",
"0.6328849",
"0.6315733",
"0.62315214",
"0.62315214",
"0.62315214",
"0.62315214",
"0.62315214",
"0.62315214",
"0.62110925",
"0.6184824",
"0.61828953",
"0.6124668",
"0.6120... | 0.0 | -1 |
Scale pos with val (scalar). | def mul( val )
@x.scale( val )
@y.scale( val )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub_scale _value, _abs=0\n send_cmd(\"sub_scale #{_value} #{_abs}\")\n end",
"def scale=(val)\n self['scale'] = val\n end",
"def scale( value )\n ( value - @min ) / ( @max - @min )\n end",
"def scale(value)\r\n value * @height/2 + @height/4\r\n end",
"def scale_by num\n min ... | [
"0.71672314",
"0.7024166",
"0.69756436",
"0.6831132",
"0.6584895",
"0.6514339",
"0.6496906",
"0.6495034",
"0.6485605",
"0.6451069",
"0.63610125",
"0.6360219",
"0.6344968",
"0.6330591",
"0.6317704",
"0.6301924",
"0.6250885",
"0.6242582",
"0.61771965",
"0.6173948",
"0.6151986",... | 0.6978016 | 2 |
Add pos to self. | def add( *pos )
off = Pos.set( *pos )
@x.add( off.xref )
@y.add( off.yref )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pos=(pos)\n @pos = pos\n end",
"def add_position\n self.position = self.max_position + 1\n end",
"def add point\n self.x += point.x\n self.y += point.y\n self\n end",
"def pos=(val)\n @pos = val\n\n end",
"def add_position(record_id, pos)\n add_record(record... | [
"0.6778627",
"0.6757983",
"0.6651812",
"0.6447198",
"0.63881326",
"0.6343241",
"0.63298446",
"0.63293576",
"0.63124907",
"0.6215541",
"0.612362",
"0.612362",
"0.6114617",
"0.6097052",
"0.6053641",
"0.60187936",
"0.5881991",
"0.5880185",
"0.5857962",
"0.58486646",
"0.58463115"... | 0.7429134 | 0 |
Sub pos from self. | def sub( *pos )
off = Pos.set( *pos )
@x.sub( off.xref )
@y.sub( off.yref )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub(v)\n @x -= v.x\n @y -= v.y\n self\n end",
"def sub(point)\r\n new_point = Marshal.load(Marshal.dump(self))\r\n new_point.x = @x - point.x\r\n new_point.y = @y - point.y\r\n return new_point\r\n end",
"def sub!(point)\r\n @x -= point.x\r\n @y -= point.y\r\n end",
... | [
"0.72088313",
"0.68984944",
"0.6757582",
"0.6559452",
"0.65124196",
"0.6473241",
"0.64175916",
"0.63983715",
"0.636492",
"0.63235694",
"0.63235694",
"0.63235694",
"0.63235694",
"0.62336624",
"0.6219807",
"0.6212103",
"0.6191106",
"0.6149239",
"0.60284656",
"0.60284656",
"0.60... | 0.78448313 | 0 |
Add to pos x. | def xadd( off )
@x.add( off )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def incr_x(val = 1)\n update(y, x + val)\n apply_pos\n end",
"def add!(point)\r\n @x += point.x\r\n @y += point.y\r\n end",
"def add point\n self.x += point.x\n self.y += point.y\n self\n end",
"def move_x(val)\n update(y, val)\n apply_pos\n end",
"def cal... | [
"0.7424591",
"0.70451266",
"0.70324653",
"0.6983138",
"0.67896515",
"0.67663",
"0.6749465",
"0.6749465",
"0.6732131",
"0.6529714",
"0.6472007",
"0.64169484",
"0.6405385",
"0.6383411",
"0.6380267",
"0.6351837",
"0.63476723",
"0.63420814",
"0.6309677",
"0.628183",
"0.62355435",... | 0.7240823 | 1 |
Sub from pos x. | def xsub( off )
@x.sub( off )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub!(point)\r\n @x -= point.x\r\n @y -= point.y\r\n end",
"def sub( *pos )\n off = Pos.set( *pos )\n @x.sub( off.xref )\n @y.sub( off.yref )\n self\n end",
"def delta_x(x_position, x)\n (x - x_position).abs\n end",
"def sub(point)\r\n new_p... | [
"0.6913545",
"0.68053186",
"0.64997256",
"0.647676",
"0.63922215",
"0.6067984",
"0.6062419",
"0.59757864",
"0.5955759",
"0.59381294",
"0.592726",
"0.59014034",
"0.59014034",
"0.580534",
"0.57998484",
"0.5794804",
"0.5788835",
"0.56815505",
"0.56800723",
"0.5679854",
"0.564268... | 0.71948856 | 0 |
Add to pos y. | def yadd( off )
@y.add( off )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def incr_y(val = 1)\n update(y + val, x)\n apply_pos\n end",
"def move_y(val)\n update(val, x)\n apply_pos\n end",
"def update_y(y_speed)\n\t\t@y += y_speed\n\t\t@prawn.y += y_speed \n\tend",
"def at_y new_y\n PIXI::Point.new(self.x ,new_y)\n end",
"def incrementY\n @cu... | [
"0.74474263",
"0.7380965",
"0.6963649",
"0.6813526",
"0.6752925",
"0.65911204",
"0.6525383",
"0.64397955",
"0.63557416",
"0.6291106",
"0.6236544",
"0.6236544",
"0.6219633",
"0.621711",
"0.6187081",
"0.6144402",
"0.61116207",
"0.6067959",
"0.6067959",
"0.6039685",
"0.60393",
... | 0.7074348 | 2 |
Sub from pos y. | def ysub( off )
@y.sub( off )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delta_y(y_position, y)\n (y - y_position).abs\n end",
"def offy(y)\n -(y - self.centery) + (self.height/2)\n end",
"def y\n position.y if position\n end",
"def y\n position.y if position\n end",
"def y\n @position.y\n end",
"def decr_y(val = 1)\n updat... | [
"0.70871574",
"0.6916864",
"0.68201154",
"0.68201154",
"0.67362946",
"0.66436845",
"0.6596068",
"0.6549881",
"0.6442525",
"0.6428692",
"0.6412454",
"0.6401474",
"0.6342259",
"0.62544656",
"0.6227757",
"0.62122136",
"0.62035525",
"0.61972874",
"0.6143068",
"0.61404586",
"0.613... | 0.7292371 | 0 |
To array (without memoize). | def to_a
[ xnow, ynow ]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_a; Array(force) end",
"def to_array\n array = []\n self.each { |x| array.push x }\n return array\n end",
"def to_ary() end",
"def to_a\n @arr\n end",
"def to_ary; []; end",
"def to_array(a)\n a.map { |i| i }\nend",
"def to_array(a)\n a.map { |i| i }\nend",
"def to_a; [A... | [
"0.760591",
"0.7265456",
"0.7174035",
"0.7129604",
"0.70952886",
"0.70543724",
"0.70543724",
"0.7039486",
"0.70039237",
"0.70021766",
"0.69769496",
"0.69387203",
"0.6923159",
"0.690306",
"0.6885702",
"0.6879935",
"0.68601435",
"0.6843791",
"0.6823372",
"0.6819114",
"0.6805037... | 0.0 | -1 |
To string (without memoize). Note: uses SVG required format. | def to_s
"#{xnow},#{ynow}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_svg\n image.to_s\n end",
"def to_svg\n draw\n invert_coords\n \n polygon = @coords.values.map { |c| c.join(',') }.join(' ')\n labels = ''\n \n t.each { |v| labels << vertex_label(v) << vertex_arc(v) << vertex_value(v) }\n t.e... | [
"0.75031406",
"0.69666874",
"0.65928996",
"0.6452099",
"0.63460785",
"0.6321671",
"0.629018",
"0.6278628",
"0.62244374",
"0.6199438",
"0.6178154",
"0.6174905",
"0.6149613",
"0.6138435",
"0.6128",
"0.61260974",
"0.61192197",
"0.6118062",
"0.608767",
"0.6063448",
"0.6049205",
... | 0.0 | -1 |
Move peer away from self if len is positive and towards self if negative. | def offset_peer( peer, len )
v1 = to_vec( peer )
v2 = v1.adjust_len( len )
self.dup + v2.to_pos
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def offset_self( peer, len )\n v1 = to_vec( peer )\n v2 = v1.adjust_len( len )\n peer.dup - v2.to_pos\n end",
"def shrink_ship\n @length -= 1\n end",
"def constrain_length(bob, minlen, maxlen)\n dir = bob.location - @anchor\n d = dir.mag\n # Is it too short?... | [
"0.69202167",
"0.5326212",
"0.5229426",
"0.5167998",
"0.5139578",
"0.51196796",
"0.5030175",
"0.49983466",
"0.49710152",
"0.49670628",
"0.49533507",
"0.4948995",
"0.4929437",
"0.49143746",
"0.4872177",
"0.48691887",
"0.48387122",
"0.4838572",
"0.4822642",
"0.4820054",
"0.4810... | 0.61871576 | 1 |
Move self towards peer if len is positive and away if negative. | def offset_self( peer, len )
v1 = to_vec( peer )
v2 = v1.adjust_len( len )
peer.dup - v2.to_pos
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def offset_peer( peer, len )\n v1 = to_vec( peer )\n v2 = v1.adjust_len( len )\n self.dup + v2.to_pos\n end",
"def go_left(length)\r\n go_to(@location.x - length, @location.y)\r\n end",
"def constrain_length(bob, minlen, maxlen)\n dir = bob.location - @anchor\... | [
"0.6218396",
"0.5333953",
"0.5259777",
"0.51308596",
"0.50653034",
"0.50375545",
"0.50342077",
"0.502084",
"0.499752",
"0.49835598",
"0.49834213",
"0.497396",
"0.4952795",
"0.4944671",
"0.49363628",
"0.4884467",
"0.48704132",
"0.48305312",
"0.4823356",
"0.47910684",
"0.476950... | 0.6891022 | 0 |
Draw (register to be drawed) with block. | def draw( &blk )
register
instance_eval &blk if blk
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw\n get_blocks.each { |block| block.draw }\n end",
"def draw(&block)\n instance_eval(&block)\n end",
"def draw(&block)\n block.call(self)\n end",
"def draw(&block)\n auto_update(false)\n block.call\n auto_update(true)\n end",
"def draw(&block)\n instance_exec ... | [
"0.78714246",
"0.78286016",
"0.7778828",
"0.74810934",
"0.7292734",
"0.64165485",
"0.6395412",
"0.6395412",
"0.6362511",
"0.62869406",
"0.62869406",
"0.62869406",
"0.62869173",
"0.62592626",
"0.62592626",
"0.62592626",
"0.62592626",
"0.62547576",
"0.62140435",
"0.62140435",
"... | 0.8051591 | 0 |
Duplicate and register only if already registered. | def clone
dup
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register\n @is_registered = true\n self\n end",
"def register_for(id); end",
"def registers; end",
"def register_duplicated_card(original_card_id:, to_card_id:)\n Cache.hash_set(\"#{@batch_id}_duplicated_cards\", original_card_id, to_card_id)\n\n remapper = CardDuplicatorMapper::Re... | [
"0.6436384",
"0.63155186",
"0.6254342",
"0.6245958",
"0.61220926",
"0.6102371",
"0.6069538",
"0.6031046",
"0.60077184",
"0.60077184",
"0.60077184",
"0.5991447",
"0.59836096",
"0.59289134",
"0.58840275",
"0.5798638",
"0.5782789",
"0.5747258",
"0.5729977",
"0.57277215",
"0.5709... | 0.0 | -1 |
Output without indent change. | def outo( str )
outi nil, str
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indent_out\n @indent << \" \"\n end",
"def indent\n return unless blank?\n write(' ' * @indentation)\n self\n end",
"def indent()\n #This is a stub, used for indexing\n end",
"def write(output, indent); end",
"def indent; end",
"def indent; end"... | [
"0.7871952",
"0.7340687",
"0.7319696",
"0.73168147",
"0.7241315",
"0.7241315",
"0.7241315",
"0.7241315",
"0.7241315",
"0.71010095",
"0.700953",
"0.697619",
"0.69692975",
"0.69692975",
"0.6855078",
"0.6781341",
"0.6749525",
"0.6749525",
"0.66871226",
"0.66194105",
"0.660124",
... | 0.0 | -1 |
Set output line indent. Return Array with tuplet: indent before output and after output (new indent level). | def setind( ind )
preind = @@outind
postind = @@outind
if ind == nil
# Do nothing
elsif ind[0] == '-'
preind -= ind[1..-1].to_i
elsif ind[0] == '+'
preind += ind[1..-1].to_i
elsif ind[-1] == '-'
postind -= ind[0..-2].to_i
elsif ind[-1] == '+'
postind += ind[0..-2].to_i
end
[ preind, postind ]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indent_each_line!(indent_sequence=\"\\t\")\n\t\treturn self.collect!{ |line|\t\"#{indent_sequence}#{line}\" }\n\tend",
"def indent_out\n @indent << \" \"\n end",
"def indent()\n #This is a stub, used for indexing\n end",
"def indent_for(line); end",
"def a_indent a... | [
"0.7024822",
"0.6632527",
"0.65312463",
"0.65296894",
"0.6471568",
"0.6454585",
"0.6447827",
"0.63395494",
"0.63395494",
"0.63395494",
"0.63395494",
"0.63395494",
"0.620319",
"0.620319",
"0.61628026",
"0.6138659",
"0.6092129",
"0.6033738",
"0.60285217",
"0.6022482",
"0.597516... | 0.0 | -1 |
Output with indent change. | def outi( ind, str )
ind = setind( ind )
@@fh.write( ' ' * ind[0] )
@@fh.puts( str )
@@outind = ind[1]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def indent_out\n @indent << \" \"\n end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent()\n #This is a stub, used for indexing\n end",
"def write(output, indent); end",
"def indent\n return unles... | [
"0.8500742",
"0.8164318",
"0.8164318",
"0.8164318",
"0.8164318",
"0.8164318",
"0.8072576",
"0.79374766",
"0.7870129",
"0.77396274",
"0.77396274",
"0.77123296",
"0.7708797",
"0.7686158",
"0.7499157",
"0.7464052",
"0.73781097",
"0.7370265",
"0.736214",
"0.7272994",
"0.7270599",... | 0.0 | -1 |
Get index of layer or create the layer if not existing. | def getidx( layer )
if ( index = @list.index( layer ) )
index
else
@list.push( layer )
@list.length-1
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_layer(new_layer)\n #first determine if the layer already exists.\n @layers.each do |current_layer|\n if new_layer == current_layer\n return current_layer\n end\n end\n @layers.push(new_layer)\n return @layers.last()\n end",
"def create... | [
"0.5593255",
"0.5512302",
"0.5508986",
"0.54269946",
"0.53159076",
"0.53159076",
"0.53159076",
"0.5225495",
"0.51588815",
"0.51467264",
"0.5124076",
"0.5107695",
"0.509584",
"0.5091763",
"0.50866944",
"0.5082896",
"0.50777406",
"0.5070473",
"0.50573957",
"0.50474936",
"0.5038... | 0.73015237 | 0 |
Insert layer before ref. | def prepend( ref, layer )
idx = getidx( ref )
@list.insert( idx, layer )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append( ref, layer )\n idx = getidx( ref )\n @list.insert( idx+1, layer )\n end",
"def add_layer\n Layer.create(:name => @new_table_name, :table_name => @new_table_name, :geometric_column_name => \"the_geom\")\n end",
"def add_layer\n puts \"made it to PL add layer\"\n ... | [
"0.7075569",
"0.61735755",
"0.6118015",
"0.57681686",
"0.5659282",
"0.5341326",
"0.5330844",
"0.5314995",
"0.5282807",
"0.5264152",
"0.52567655",
"0.5254723",
"0.5203612",
"0.51964927",
"0.51596683",
"0.5156431",
"0.5087862",
"0.508356",
"0.5082965",
"0.5080657",
"0.5079219",... | 0.7967484 | 0 |
Insert layer after ref. | def append( ref, layer )
idx = getidx( ref )
@list.insert( idx+1, layer )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepend( ref, layer )\n idx = getidx( ref )\n @list.insert( idx, layer )\n end",
"def add_layer\n Layer.create(:name => @new_table_name, :table_name => @new_table_name, :geometric_column_name => \"the_geom\")\n end",
"def add_layer\n puts \"made it to PL add layer\"\n ... | [
"0.73196054",
"0.63923514",
"0.632114",
"0.5856198",
"0.5681856",
"0.54762036",
"0.5459355",
"0.5414603",
"0.5309273",
"0.5258892",
"0.52301496",
"0.5215942",
"0.5197408",
"0.5178996",
"0.51778525",
"0.51643485",
"0.51397306",
"0.5126761",
"0.5107408",
"0.50788176",
"0.506947... | 0.75448674 | 0 |
Add layer to list (end). | def add( *layer )
if not( layer.kind_of? Array )
layer = [ layer ]
end
layer.each do |l|
getidx( l )
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append( ref, layer )\n idx = getidx( ref )\n @list.insert( idx+1, layer )\n end",
"def add_layer_object( object )\n layers.push( object )\n end",
"def add_layer(new_layer)\n #first determine if the layer already exists.\n @layers.each do |current_... | [
"0.75796247",
"0.68837535",
"0.67160904",
"0.63931096",
"0.61933374",
"0.610169",
"0.59842294",
"0.5757718",
"0.5757718",
"0.57553095",
"0.57136095",
"0.5669932",
"0.5505538",
"0.54399705",
"0.5256874",
"0.52512425",
"0.5136866",
"0.51232886",
"0.51222926",
"0.51133657",
"0.5... | 0.6244616 | 4 |
Revert to default layer. | def unuse
@use = nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def revert\n end",
"def revert_to_normal\n self.blend_type = 0\n self.color.set(0, 0, 0, 0)\n self.opacity = 255\n update_origin\n end",
"def revert_to_normal\n self.blend_type = 0\n self.color.set(0, 0, 0, 0)\n self.ox = @cw/2\n self.opacity = 255\n end",
"def revert\n @nam... | [
"0.69832027",
"0.65562165",
"0.6550784",
"0.6411792",
"0.61924046",
"0.612731",
"0.6115973",
"0.6093828",
"0.5919952",
"0.5893902",
"0.5884587",
"0.58827704",
"0.5863553",
"0.57950103",
"0.57786745",
"0.57767075",
"0.57372916",
"0.572007",
"0.56918514",
"0.56866133",
"0.56866... | 0.0 | -1 |
Add/use layer and use it temporarely. | def push( layer )
getidx( layer )
@stack.push layer
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_layer(new_layer)\n #first determine if the layer already exists.\n @layers.each do |current_layer|\n if new_layer == current_layer\n return current_layer\n end\n end\n @layers.push(new_layer)\n return @layers.last()\n end",
"def layer(... | [
"0.6825168",
"0.6520572",
"0.6428484",
"0.6428172",
"0.63337016",
"0.63304216",
"0.62657505",
"0.6257021",
"0.61634284",
"0.6102755",
"0.6095096",
"0.6000061",
"0.59901625",
"0.5768783",
"0.5747034",
"0.5716724",
"0.56806874",
"0.56506914",
"0.5644415",
"0.5595558",
"0.555689... | 0.53834844 | 28 |
Stop using temporary layer. | def pop
@stack.pop
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop\n super\n @temp.stop\n end",
"def stop\n @loop = nil\n end",
"def stop\n @run = false\n end",
"def stop()\n @state = STOPPED\n end",
"def stop\n throw @context.stop\n end",
"def stop!\n log \">> Stopping ...\"\n\n @backend.stop!\n end... | [
"0.68132025",
"0.656673",
"0.6563265",
"0.64533615",
"0.64089483",
"0.64070284",
"0.63380957",
"0.6313922",
"0.6274501",
"0.62140924",
"0.62140924",
"0.62140924",
"0.61899996",
"0.61899996",
"0.6176818",
"0.6168487",
"0.6168487",
"0.61563915",
"0.6150373",
"0.61428094",
"0.61... | 0.0 | -1 |
Get currently used layer. | def current
if @stack.any?
@stack[-1]
elsif @use
@use
else
@list[-1]
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current_layer\n @layers.last\n end",
"def layer\n brick.layer\n end",
"def layer\n brick.layer\n end",
"def layers\n @layers ||= Dis::Layers.new\n end",
"def genCurrentLayer\n end",
"def get_layer\n @layer = Layer.find(params[:layer_id])\n end",
"def get_l... | [
"0.765418",
"0.6527998",
"0.6527998",
"0.6335198",
"0.6174351",
"0.60895824",
"0.60895824",
"0.60895824",
"0.6064311",
"0.556616",
"0.55285394",
"0.54837906",
"0.5417362",
"0.54032767",
"0.5388294",
"0.53879106",
"0.5376656",
"0.5358488",
"0.53575456",
"0.5351005",
"0.5349349... | 0.552194 | 11 |
Register self, i.e. mark to be drawed. | def register
@container = Common.container
# layer @container.layer
layer Layer.system.current
Common.register( self )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw( &blk )\n register\n instance_eval &blk if blk\n self\n end",
"def mark!\n\t\t\t\t@marked = true\n\t\t\tend",
"def mark; end",
"def mark(mark)\n @marks << mark\n end",
"def mark(marker)\n raise NotImplementedError\n end",
"def mark\n rai... | [
"0.68942916",
"0.6654947",
"0.6420286",
"0.61844635",
"0.6169693",
"0.5797374",
"0.5776395",
"0.5725025",
"0.56867003",
"0.56867003",
"0.5638921",
"0.5637302",
"0.56299585",
"0.5522723",
"0.552217",
"0.55066735",
"0.5501837",
"0.54936033",
"0.5467721",
"0.5467721",
"0.5467721... | 0.0 | -1 |
Duplicate and register only if already registered. | def clone
ret = self.deep_copy
ret.register if self.registered
ret
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register\n @is_registered = true\n self\n end",
"def register_for(id); end",
"def registers; end",
"def register_duplicated_card(original_card_id:, to_card_id:)\n Cache.hash_set(\"#{@batch_id}_duplicated_cards\", original_card_id, to_card_id)\n\n remapper = CardDuplicatorMapper::Re... | [
"0.6436384",
"0.63155186",
"0.6254342",
"0.6245958",
"0.61220926",
"0.6102371",
"0.6069538",
"0.6031046",
"0.60077184",
"0.60077184",
"0.60077184",
"0.5991447",
"0.59836096",
"0.59289134",
"0.58840275",
"0.5798638",
"0.5782789",
"0.5747258",
"0.5729977",
"0.57277215",
"0.5709... | 0.5677805 | 23 |
Resolve value to absolute value. | def fix_value( val )
Pos.abs( ( @container.pos.x! + val.x! ), ( @container.pos.y! + val.y! ) )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def abs(value)\n numeric_transformation(value) {|n| n.abs}\n end",
"def absolute(a)\n if a >= 0\n return a\n else\n return -a\n end\nend",
"def absolute val\n AbsoluteLocation.new val\n end",
"def absolute(number)\n if number < 0\n number = number * -1\n end\n return numb... | [
"0.77921873",
"0.71667796",
"0.7135441",
"0.7131783",
"0.7123267",
"0.70883185",
"0.7036795",
"0.6988729",
"0.6944063",
"0.693604",
"0.6934624",
"0.6865235",
"0.6822503",
"0.6802368",
"0.67471063",
"0.6682993",
"0.6655577",
"0.6655577",
"0.66251147",
"0.6611468",
"0.6611468",... | 0.5929202 | 50 |
Fix position to absolute value. | def fixpos
@pos = fix_value( @pos )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fix_value( val )\n Pos.abs( ( @container.pos.x! + val.x! ), ( @container.pos.y! + val.y! ) )\n end",
"def run_to_absolute_position!(position)\n self.position_setpoint = position\n\n self.command = :'run-to-abs-pos'\n end",
"def absolute_position(position)\n pos... | [
"0.74160326",
"0.72147644",
"0.6782603",
"0.6721243",
"0.6598496",
"0.6592766",
"0.65293616",
"0.63253224",
"0.6308494",
"0.6262779",
"0.6200365",
"0.61933464",
"0.6086172",
"0.605516",
"0.5968346",
"0.5955411",
"0.5942959",
"0.59105694",
"0.5883965",
"0.5883003",
"0.58799136... | 0.7040067 | 2 |
Make Figure the default element container. | def open
Common.contain( self )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_container(container = 'div')\n return @reference_node.document.create_element(container, :class => \"default-media-display\")\n end",
"def set_figure(figure)\n @figure = figure\n end",
"def default_container\n Container.create_character_default_containers(self.id)\n end",
... | [
"0.6587225",
"0.6235152",
"0.6093526",
"0.58408874",
"0.5688155",
"0.56328964",
"0.55789214",
"0.5524724",
"0.5446921",
"0.5392256",
"0.5392256",
"0.5368136",
"0.53559816",
"0.5288818",
"0.5234942",
"0.515024",
"0.51379955",
"0.5096173",
"0.503974",
"0.50308186",
"0.50294644"... | 0.0 | -1 |
Reject Figure as the default element container. | def close
Common.uncontain
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subfigure_cleanup(xmldoc)\n xmldoc.xpath(\"//example[figure]\").each do |e|\n next unless e.elements.map(&:name).reject do |m|\n %w(name figure).include? m\n end.empty?\n\n e.name = \"figure\"\n end\n end",
"def begin_figure\n # do nothing\n ... | [
"0.5974966",
"0.5755724",
"0.552755",
"0.5329692",
"0.51224756",
"0.5071574",
"0.5023186",
"0.49046728",
"0.48545438",
"0.48049974",
"0.4797133",
"0.4797133",
"0.47969514",
"0.47876033",
"0.47876033",
"0.4783159",
"0.4769464",
"0.4728416",
"0.4727984",
"0.47184056",
"0.471840... | 0.0 | -1 |
Return gap as Pos. | def dirgap( gap = @gap )
if @pack == :d || @pack == :u
Pos.set( 0, gap )
else
Pos.set( gap, 0 )
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_gpos\n Point[ self.x, self.y ]\n end",
"def gap(g)\n\treturn (g[:black]-g[:white]).abs\nend",
"def pos1(pos)\n [pos.first + 1, pos.last + 1]\n end",
"def diff\n @start_position - @position\n end",
"def gap_width\n @gap_width ||= 150\n end",
"def pos\n ... | [
"0.6272659",
"0.6133971",
"0.5812293",
"0.57446617",
"0.573601",
"0.5731171",
"0.57298243",
"0.5728986",
"0.57098967",
"0.5708987",
"0.56808877",
"0.5657876",
"0.5653315",
"0.5635418",
"0.5588881",
"0.55880463",
"0.5575422",
"0.5534228",
"0.54942304",
"0.54524857",
"0.5452485... | 0.64526296 | 0 |
Output figure and contained elements. | def visualize
if @output
STDERR.puts "Refuce to output twice."
exit( false )
end
@output = true
close
Common.openOutput
outo %Q{<?xml version="1.0" encoding="UTF-8"?>}
# No scale:
if Opt['zoom'].given
scaler = 1 / ( Opt['zoom'].value.to_i / 100.0 )
else
scaler = 1
end
if @scale
scaler = scaler * ( 1 / ( @scale / 100.0 ) )
end
outo %Q{<svg xmlns="http://www.w3.org/2000/svg" width="#{size.x!/scaler}#{unit}" height="#{size.y!/scaler}#{unit}" viewBox="0 0 #{size.x!} #{size.y!}">}
# Output marker "templates".
outo %Q{\
<defs>
<marker id="markerCircle" markerWidth="8" markerHeight="8" refX="5" refY="5">
<circle cx="5" cy="5" r="3" style="stroke: none; fill:#{linecolor_o};"/>
</marker>
<marker id="endArrow" markerWidth="13" markerHeight="13" refX="#{10-linewidth}" refY="4"
orient="auto" markerUnits="strokeWidth" >
<path d="M 0 0 L 0 8 L 10 4 L 0 0" style="fill:#{linecolor_o};" />
</marker>
<marker id="startArrow" markerWidth="13" markerHeight="13" refX="#{linewidth}" refY="4"
orient="auto" markerUnits="strokeWidth" >
<path d="M 0 4 L 10 8 L 10 0 L 0 4" style="fill:#{linecolor_o};" />
</marker>
<marker id="endTee" markerWidth="13" markerHeight="13" refX="0" refY="5"
orient="auto" markerUnits="strokeWidth" >
<path d="M 0 0 L 0 10 L 2 10 L 2 0 z" style="fill:#{linecolor_o};" />
</marker>
<marker id="startTee" markerWidth="13" markerHeight="13" refX="0" refY="4"
orient="auto" markerUnits="strokeWidth" >
<path d="M 0 0 L 0 10 L 2 10 L 2 0 z" style="fill:#{linecolor_o};" />
</marker>
</defs>}
if Opt['name'].given
outo %Q{ <title>#{Opt['name'].value}</title>}
else
outo %Q{ <title>Sivigi figure</title>}
end
@items.each do |i|
i.fixpos
end
# Output each layer in turn.
layers = Layer.system.list
layers.each do |layer|
@items.each do |i|
incind 2
i.output( layer )
decind 2
end
end
outo "</svg>"
Common.closeOutput
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export\n figure_node\n end",
"def render(renderer)\n output = Renderer.const_get(renderer).new(@grid.width, @grid.height, @options)\n\n for e in @figures\n output.render(e) \n end\n output.render_finish\n end",
"def display\n puts (\"[\" + @id.name +... | [
"0.67610925",
"0.6144874",
"0.5825809",
"0.5766576",
"0.57376814",
"0.57376814",
"0.5721689",
"0.5721216",
"0.5708473",
"0.57032454",
"0.5698531",
"0.5697347",
"0.5694702",
"0.56801677",
"0.5660047",
"0.5620997",
"0.56018174",
"0.5585924",
"0.5578828",
"0.5562535",
"0.5561827... | 0.6501199 | 1 |
Specify geometry. Options: a.spec [[1,2,3,4]] List of Coords in Array (from Boxline). a.spec [p1,p2] Tuplet of Pos. a.spec [[1,2],[3,4]] Tuplet of Pairs. a.spec [1,2,3,4] List of Coords. | def spec( *args )
if args.length == 1
# Array of 4*Coords in Array.
args = args[0]
@p1.set args[0], args[1]
@p2.set args[2], args[3]
elsif args.length == 2
# 2*Pos or 2*Array
@p1.set args[0]
@p2.set args[1]
elsif args.length == 4
# Array of 4*Coords
@p1.set args[0], args[1]
@p2.set args[2], args[3]
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geometry( b)\n\t\t# over-ride where neeeded, e.g. UONActor\n\tend",
"def create_geometry(p1, p2, view)\n view.model.entities.add_cline(p1,p2)\nend",
"def spec( *args )\n\n if args[0].kind_of? Array\n\n # Coord pairs.\n args.each do |p|\n @path.... | [
"0.5973733",
"0.5909188",
"0.556013",
"0.55367494",
"0.5421315",
"0.5382393",
"0.53179055",
"0.5297301",
"0.5291648",
"0.52527493",
"0.5251642",
"0.5250818",
"0.5244019",
"0.5204729",
"0.52019477",
"0.5130744",
"0.51268363",
"0.5124068",
"0.5076257",
"0.5035754",
"0.5021682",... | 0.6503483 | 0 |
Line (Oned) from position, to dir, with length of len. | def dir( pos, dir, len )
@p1.set pos
@p2.set( @p1.dup + Pos.dir( dir, len ) )
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def line_for_position(position); end",
"def line_for_position(position); end",
"def line_for_position(position); end",
"def from_line\n position.new_line\n end",
"def draw_line(turtle, length)\n new_xpos = turtle[XPOS] + length * DegLut.cos(turtle[ANGLE])\n new_ypos = turtle[YPOS] + length * DegL... | [
"0.63308346",
"0.63308346",
"0.63308346",
"0.63184613",
"0.6233777",
"0.60392374",
"0.59840506",
"0.59547013",
"0.59148085",
"0.5908558",
"0.5875741",
"0.57499003",
"0.57148415",
"0.5633755",
"0.5612764",
"0.56075025",
"0.5604895",
"0.5596811",
"0.5584901",
"0.5571053",
"0.55... | 0.56195575 | 14 |
Spec with pos and optional size. | def spec( pos, size = nil )
self.pos.set pos
self.size( size ) if size
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size\n specs.size\n end",
"def interpret_size(size); end",
"def disk_spec(file_name, size, unit)\n disk = RbVmomi::VIM.VirtualDisk(\n :backing => disk_backing(file_name),\n :controllerKey => 0,\n :key => 0,\n :unitNumber => unit,\n :capacityInKB => size\n )\n\n con... | [
"0.5625031",
"0.56097656",
"0.5349738",
"0.5349337",
"0.5286191",
"0.5286191",
"0.5265664",
"0.5196902",
"0.5148635",
"0.5135018",
"0.51256716",
"0.5120389",
"0.5098303",
"0.50882846",
"0.5061557",
"0.50484735",
"0.5040231",
"0.50385064",
"0.50385064",
"0.50299275",
"0.502899... | 0.7829163 | 0 |
Half of Twod (Box) in length (on specific side). | def half( side )
case side
when :u; size.dup.y * ( 0.5 )
when :d; size.dup.y * ( 0.5 )
when :l; size.dup.x * ( 0.5 )
when :r; size.dup.x * ( 0.5 )
when :v; size.dup.y * ( 0.5 )
when :h; size.dup.x * ( 0.5 )
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def half\n self / 2.0\n end",
"def side_length\n\t\ttop = (@num_sides - 2) * Math::PI\n\t\tangle = top / (2 * @num_sides)\n\t\t@side_length = 2 * Math.cos(angle)\n\tend",
"def left_half\n self[0...length / 2]\n end",
"def perimeter\n return @side_length * 4\n end",
"def perimeter\n\n return ... | [
"0.7132101",
"0.7129838",
"0.68180865",
"0.6495544",
"0.6491788",
"0.64408904",
"0.6311147",
"0.6251254",
"0.61827874",
"0.6154798",
"0.6096931",
"0.6067627",
"0.60671055",
"0.6057269",
"0.59963286",
"0.59611475",
"0.59386253",
"0.5929836",
"0.5906159",
"0.58850527",
"0.58599... | 0.768467 | 0 |
Return shortest path between 2D objects. | def path( peer )
inter1 = self.intersection( peer.pos.to_gpos )
inter2 = peer.intersection( self.pos.to_gpos )
inter1.to_a + inter2.to_a
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shortest_path\n initial_position_obj = { position: start_position, source: {} }\n\n knights_path = [initial_position_obj]\n\n while knights_path.present?\n current_position = knights_path.shift\n\n position = current_position[:position]\n\n if position == end_position\n return pa... | [
"0.73259336",
"0.69249386",
"0.67309946",
"0.66581583",
"0.65764976",
"0.6556298",
"0.65343153",
"0.64520806",
"0.6451722",
"0.64108557",
"0.6364518",
"0.636348",
"0.6360297",
"0.6350279",
"0.63460386",
"0.63330984",
"0.6329381",
"0.6306553",
"0.6221573",
"0.6184092",
"0.6179... | 0.0 | -1 |
Pack box (with gap). Default gap value from container. | def pack( gap = @container.gap )
prev = @container.packpos
dir = @container.dir
x = prev.xnow + @container.dirgap( gap ).xnow
y = prev.ynow + @container.dirgap( gap ).ynow
case dir
when :u; y -= ( self.half( dir ) ); prev.ysub( size.y )
when :d; y += ( self.half( dir ) ); prev.yadd( size.y )
when :l; x -= ( self.half( dir ) ); prev.xsub( size.x )
when :r; x += ( self.half( dir ) ); prev.xadd( size.x )
end
pos x, y
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pack_box\n\t\t# @packages = ActiveShipping::Package.new((WEIGHT * 16), DIMENSIONS, UNITS)\n\t\t@packages = ActiveShipping::Package.new((WEIGHT * 16), DIMENSIONS, UNITS)\n\tend",
"def dirgap( gap = @gap )\n if @pack == :d || @pack == :u\n Pos.set( 0, gap )\n else\n ... | [
"0.62113345",
"0.53768235",
"0.52078843",
"0.51971763",
"0.5146912",
"0.5142526",
"0.5132387",
"0.50354576",
"0.49677074",
"0.49352536",
"0.4897558",
"0.4886678",
"0.4857107",
"0.48304275",
"0.47914293",
"0.4790896",
"0.47635373",
"0.4756967",
"0.47541735",
"0.47521693",
"0.4... | 0.6852484 | 0 |
Anchor defines horizontal alignment. | def anchor( val )
case val
when :c; @anchor = :middle
when :l; @anchor = :start
when :r; @anchor = :end
else @anchor = :start
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def horizontal_alignment=(value)\n @horizontal_alignment = value\n end",
"def center_horizontally\n @horizontal_align = :center\n return self\n end",
"def align_left\n @horizontal_align = :left\n return self\n end",
"def horizontal_alignment\n ... | [
"0.6619588",
"0.6537926",
"0.64983475",
"0.6483496",
"0.64606476",
"0.6440203",
"0.6303686",
"0.6221703",
"0.60617864",
"0.6060209",
"0.6017041",
"0.6017041",
"0.59571767",
"0.59327894",
"0.5874444",
"0.5868951",
"0.5835356",
"0.578393",
"0.5778056",
"0.5774424",
"0.5741637",... | 0.6439711 | 6 |
Baseline defines vertical alignment. | def baseline( val )
case val
when :d; @baseline = "text-before-edge"
when :u; @baseline = "text-after-edge"
else @baseline = "middle"
# else @baseline = "auto"
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vertical_alignment=(value)\n @vertical_alignment = value\n end",
"def center_vertically\n @vertical_align = :center\n return self\n end",
"def vertical_alignment\n return @vertical_alignment\n end",
"def process_vertical_alignment text\n ... | [
"0.63007337",
"0.6197349",
"0.6187221",
"0.58407813",
"0.57401645",
"0.57057065",
"0.5704819",
"0.5687073",
"0.5622278",
"0.5622278",
"0.5607333",
"0.55612797",
"0.55331844",
"0.5413765",
"0.5398613",
"0.5379534",
"0.5365901",
"0.53563994",
"0.53222084",
"0.5209072",
"0.52024... | 0.66620016 | 0 |
Return selected position on the line. | def point( mu, di )
v = @p1.to_vec( @p2 )
u = v.unit
ol = v.length
nl = u * (ol*mu/di)
p = @p1.dup.add( nl.to_pos )
p
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current_line_pos\n pos - col\n end",
"def position\n\t\t\tif @selected\n\t\t\t\t@selected.position\n\t\t\telse\n\t\t\t\tCP::ZERO_VEC_2\n\t\t\tend\n\t\tend",
"def position\r\n self.line.ordered_samples.to_a.index(self)\r\n end",
"def line(pos=pos())\n lines[line_index(pos)]\n end",
"... | [
"0.7247159",
"0.7028625",
"0.70146406",
"0.69300306",
"0.6890067",
"0.6890067",
"0.6890067",
"0.68721235",
"0.6858951",
"0.6836391",
"0.6818827",
"0.67833364",
"0.6754968",
"0.6752148",
"0.6745566",
"0.66970074",
"0.66934776",
"0.66424227",
"0.66420925",
"0.6519581",
"0.64937... | 0.0 | -1 |
Clockwise degree angle. Return nil if horizontal. | def angle
v = to_vec
if v[1] == 0.0
nil
else
v.angle
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def anglecw\n 360 - angle\n end",
"def angle_deg\n angle * RAD_TO_DEG\n end",
"def angle\n @angle\n end",
"def angle()\n a, c = @view__.angle, @context__\n c ? c.fromDegrees__(a) : a * Processing::GraphicsContext::DEG2RAD__\n end",
"def angle\n rad / Ma... | [
"0.7144321",
"0.70212007",
"0.6777788",
"0.6733935",
"0.6597447",
"0.6465666",
"0.64255744",
"0.6396847",
"0.633604",
"0.6335805",
"0.63222855",
"0.6272857",
"0.6270708",
"0.6269654",
"0.6262321",
"0.62555486",
"0.6222304",
"0.6175018",
"0.6130631",
"0.6114853",
"0.6104403",
... | 0.69141585 | 2 |
Create Polyline with specified Pos. Either poses, paired x,y in Array or and flat list of alternating x and y. | def spec( *args )
if args[0].kind_of? Array
# Coord pairs.
args.each do |p|
@path.push Pos.ini( p[0], p[1] )
end
else
if args[0].kind_of? Pos
# List of pos.
@path = args
else
# Odd index in Array
odd = false
x = nil
y = nil
# Alternating x, y.
args.each do |p|
if odd
@path.push Pos.ini( x, p )
else
x = p
end
odd = not( odd )
end
end
end
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygon *points, color\n points << points.first\n points.each_cons(2) do |p1, p2|\n w.line(*p1, *p2, color)\n end\n end",
"def open_ended_polyline(arr)\n 0.upto(arr.length - 2) { |i|\n @draw.line(arr[i][0], arr[i][1], arr[i+1][0], arr[i+1][1])\n }\n end",
"def polyline points, op... | [
"0.65861195",
"0.62324595",
"0.5883178",
"0.5865406",
"0.5752523",
"0.56346464",
"0.55692536",
"0.55092967",
"0.5508099",
"0.5475811",
"0.5458567",
"0.54460037",
"0.5442056",
"0.5441562",
"0.5441562",
"0.5402155",
"0.53604156",
"0.5359691",
"0.5352969",
"0.5285667",
"0.517761... | 0.0 | -1 |
Output Label depending of the host for the label. | def output( h )
if h.kind_of? Box
output_box( h )
elsif h.kind_of? Line
output_line( h )
elsif h.kind_of? Ellipse
output_ellipse( h )
else
raise RuntimeError, "Unknown host type for label: \"#{h.class}\"..."
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label\n raise \"Label provider key :label must be set to produce the text of the message!\" unless @data[:label]\n @data[:label]\n end",
"def label\n @label || \"unknown\"\n end",
"def label\r\n\t\t\tname.match(/\\?$/) ? name : name + \":\"\r\n\t\tend",
"def label\r\n\t\tname.match(/\\?$... | [
"0.6777884",
"0.6649725",
"0.65610534",
"0.6517758",
"0.64785755",
"0.64244574",
"0.64028466",
"0.63864446",
"0.6361542",
"0.63469845",
"0.6343722",
"0.6324074",
"0.6276882",
"0.62755644",
"0.62662053",
"0.6248702",
"0.6248379",
"0.61935204",
"0.6171098",
"0.6163651",
"0.6160... | 0.7028212 | 0 |
Return side middle position. | def side( spot )
ret = nil
case spot
when :u; ret = xy1
when :d; ret = xy2
when :l; ret = x1y
when :r; ret = x2y
else; raise RuntimeError, "Unknown side spot: #{spot}"
end
ret
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def middle\n len = self.size\n return nil if len.zero?\n div = len.div(2)\n if len.modulo(2).zero?\n [self[div-1],self[div]] \n else\n self[div]\n end\n end",
"def find_center(side)\n position = side / 2\n position = position - 1 if side.even?\n [position, position... | [
"0.7706839",
"0.76545215",
"0.75536",
"0.7475587",
"0.737205",
"0.73179346",
"0.7273181",
"0.7166686",
"0.715029",
"0.7045435",
"0.7005575",
"0.69935006",
"0.69713885",
"0.6968082",
"0.69412374",
"0.69322515",
"0.6906469",
"0.6873034",
"0.68556446",
"0.68509024",
"0.68240035"... | 0.0 | -1 |
Return side middle position. | def corner( spot )
case spot
when :ul; x1y1
when :ur; x2y1
when :dl; x1y2
when :dr; x2y2
else; raise RuntimeError, "Unknown corner spot: #{spot}"
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def middle\n len = self.size\n return nil if len.zero?\n div = len.div(2)\n if len.modulo(2).zero?\n [self[div-1],self[div]] \n else\n self[div]\n end\n end",
"def find_center(side)\n position = side / 2\n position = position - 1 if side.even?\n [position, position... | [
"0.7706839",
"0.76545215",
"0.75536",
"0.7475587",
"0.737205",
"0.73179346",
"0.7273181",
"0.7166686",
"0.715029",
"0.7045435",
"0.7005575",
"0.69935006",
"0.69713885",
"0.6968082",
"0.69412374",
"0.69322515",
"0.6906469",
"0.6873034",
"0.68556446",
"0.68509024",
"0.68240035"... | 0.0 | -1 |
Return selected side position. | def sidepos( side, relpos )
t = nil
case side
when :u;
t = x1y1
t.xset ( t.x + ( size.x.to_f * relpos[0] / relpos[1] ) ).coord
when :d;
t = x1y2
t.xset ( t.x + ( size.x.to_f * relpos[0] / relpos[1] ) ).coord
when :l;
t = x1y1
t.yset ( t.y + ( size.y.to_f * relpos[0] / relpos[1] ) ).coord
when :r;
t = x2y1
t.yset ( t.y + ( size.y.to_f * relpos[0] / relpos[1] ) ).coord
end
t
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def position\n\t\t\tif @selected\n\t\t\t\t@selected.position\n\t\t\telse\n\t\t\t\tCP::ZERO_VEC_2\n\t\t\tend\n\t\tend",
"def get_part_pos side\n\t\tcase side\n\t\twhen :left\n\t\t\treturn @pos\n\t\twhen :right\n\t\t\treturn @pos + Settings.screen[:w].to_f\n\t\twhen :center\n\t\t\treturn @pos + (Settings.screen[:w... | [
"0.74389994",
"0.72263074",
"0.7150666",
"0.6731097",
"0.66076833",
"0.65153563",
"0.6426452",
"0.6244872",
"0.6142166",
"0.6068772",
"0.60562336",
"0.6017671",
"0.6000449",
"0.5972638",
"0.5972638",
"0.5952727",
"0.59268713",
"0.5921302",
"0.5916609",
"0.5914409",
"0.5894369... | 0.5956603 | 15 |
Return side as segment. | def sideline_seg( side )
l = nil
case side
when :u; l = Gseg.new_by_pos( x1y1, x2y1 )
when :d; l = Gseg.new_by_pos( x1y2, x2y2 )
when :l; l = Gseg.new_by_pos( x1y1, x1y2 )
when :r; l = Gseg.new_by_pos( x2y1, x2y2 )
else; l = nil
end
l
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def side\n @side\n end",
"def s; @side.to_s[0,1]; end",
"def to_s\n @segment\n end",
"def segment_0; segments[0]; end",
"def sides\n return @sides if defined?(@sides)\n\n @sides = []\n (-vertices.length...0).each do |i|\n @sides << Segment.new(vertices[i], ve... | [
"0.66778725",
"0.65652037",
"0.63058144",
"0.62598675",
"0.62123895",
"0.61913645",
"0.60639125",
"0.60014045",
"0.5938618",
"0.59272546",
"0.5889578",
"0.5882869",
"0.5794548",
"0.576764",
"0.57413423",
"0.57393974",
"0.57370067",
"0.57113457",
"0.5638519",
"0.5631956",
"0.5... | 0.7412723 | 0 |
Intersections point between pos of box and to position, i.e. nearest point on the boundary of box. | def intersection( to )
# Bullet line between box center and to-point.
bline = Gseg.new( self.pos.to_gpos, to )
# Find which side of self intersects with bline.
side = nil
[ :r, :l, :u, :d ].each do |sidesym|
trial = self.sideline_seg( sidesym )
if trial.intersects_with?( bline )
side = trial
break
end
end
side.intersection_point_with( bline )
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection( to )\n cp = self.pos.to_gpos\n\n line = cp.to_vec( to )\n uline = line.unit\n radius = uline * size.x\n\n ( cp.to_vec + radius ).to_gpos\n end",
"def inBox(box, point)\n # Make a box with the point and the SE corner of the box.\n ... | [
"0.6613177",
"0.6563344",
"0.6366014",
"0.6223385",
"0.6217528",
"0.61185145",
"0.6108325",
"0.6095805",
"0.6007504",
"0.60055494",
"0.5980908",
"0.5955075",
"0.59471357",
"0.5913592",
"0.5910926",
"0.58921593",
"0.58409953",
"0.5812569",
"0.58019173",
"0.5788717",
"0.5746899... | 0.7136454 | 0 |
Intersections point between pos of ellipse and to position, i.e. nearest point on the boundary of ellipse. | def intersection( to )
cp = self.pos.to_gpos
sp = self.size.to_gpos
line = cp.to_vec( to )
n = line.rad
a = sp.x
b = sp.y
div = Math.sqrt( ( b*Math.cos(n) ) ** 2 + ( a*Math.sin(n) ) ** 2 )
px = ( a * b * Math.cos(n) ) / div
py = ( a * b * Math.sin(n) ) / div
cp.to_vec + Gvec[ px, py ]
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection( to )\n cp = self.pos.to_gpos\n\n line = cp.to_vec( to )\n uline = line.unit\n radius = uline * size.x\n\n ( cp.to_vec + radius ).to_gpos\n end",
"def intersectPoint p\n if real_close_point(x,y,p.x,p.y) then self\n else ... | [
"0.66868067",
"0.654279",
"0.6235435",
"0.6221205",
"0.6155804",
"0.60254276",
"0.6005317",
"0.59659255",
"0.59584975",
"0.5929705",
"0.59080786",
"0.58887506",
"0.58045477",
"0.5802929",
"0.57552546",
"0.5701176",
"0.5643806",
"0.56364316",
"0.5607892",
"0.5598385",
"0.55659... | 0.62898195 | 2 |
Set or get radius (size.x=radius,size.y=radius). | def radius( r = nil )
if r
@size = Pos.ini( r, r )
else
@size.xnow
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def radius=(r); @@R = r; end",
"def radius=(radius)\n @elementHash[:radius] = radius\n end",
"def set_Radius(value)\n set_input(\"Radius\", value)\n end",
"def set_Radius(value)\n set_input(\"Radius\", value)\n end",
"def radius=(_radius)\n reset_caches unle... | [
"0.77142215",
"0.7602395",
"0.75097317",
"0.75097317",
"0.7229616",
"0.70709527",
"0.70469224",
"0.6999672",
"0.6879799",
"0.6854494",
"0.6854494",
"0.6590198",
"0.65464807",
"0.65351117",
"0.6523468",
"0.64446944",
"0.6350157",
"0.6350157",
"0.62954175",
"0.62926507",
"0.627... | 0.79078007 | 0 |
Intersections point between pos of circle and to position, i.e. nearest point on the boundary of circle. | def intersection( to )
cp = self.pos.to_gpos
line = cp.to_vec( to )
uline = line.unit
radius = uline * size.x
( cp.to_vec + radius ).to_gpos
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def point_in_circle(p, c)\n difference_v = T_VECTORS.pop.set(p) - c.position\n radius_sq = c.r * c.r\n distance_sq = difference_v.lengthsq\n T_VECTORS.push(difference_v)\n # If the distance between is smaller than the radius then the point is inside the circle.\n distance_... | [
"0.70118517",
"0.6943953",
"0.66205573",
"0.6582994",
"0.6422962",
"0.63664657",
"0.6363466",
"0.62776595",
"0.6267395",
"0.6204196",
"0.6173485",
"0.60975075",
"0.6009996",
"0.59980637",
"0.595834",
"0.59476256",
"0.5923241",
"0.59069836",
"0.5893221",
"0.5890918",
"0.588869... | 0.7048404 | 0 |
GET /category_maps GET /category_maps.json | def index
@category_maps = CategoryMap.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_category_map\n @category_map = CategoryMap.find(params[:id])\n end",
"def set_category_map\n @category_map = CategoryMap.find(params[:id])\n end",
"def index\n @categories = Array.new\n Category.all.each do |c|\n @categories << [c.name, c.name]\n end\n\n keywords = Array.ne... | [
"0.69002527",
"0.68737835",
"0.6801163",
"0.6625911",
"0.652543",
"0.64775175",
"0.64222896",
"0.6415985",
"0.6376579",
"0.63712335",
"0.63555",
"0.6348914",
"0.63314855",
"0.62371397",
"0.61705047",
"0.61521804",
"0.6149229",
"0.6133664",
"0.6083039",
"0.60648996",
"0.605512... | 0.7688057 | 1 |
GET /category_maps/1 GET /category_maps/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @category_maps = CategoryMap.all\n end",
"def index\n @category_maps = CategoryMap.all\n end",
"def set_category_map\n @category_map = CategoryMap.find(params[:id])\n end",
"def set_category_map\n @category_map = CategoryMap.find(params[:id])\n end",
"def index\n @categor... | [
"0.7544909",
"0.7544909",
"0.6942066",
"0.6868206",
"0.66563946",
"0.6641279",
"0.6530394",
"0.6516241",
"0.6431177",
"0.63688284",
"0.6326775",
"0.632146",
"0.62847304",
"0.62672824",
"0.6243972",
"0.6223414",
"0.6220586",
"0.6208144",
"0.62076163",
"0.61853397",
"0.61723185... | 0.0 | -1 |
POST /category_maps POST /category_maps.json | def create
@category_map = CategoryMap.new(category_map_params)
category_map = params["category_map"]
category = category_map["category"].to_i
respond_to do |format|
if @category_map.save
format.html do
if category == CategoryMap::DIARY
redirect_to '/diaries/new'
elsif category == CategoryMap::TRAVEL
redirect_to '/travel_journals/new'
elsif category == CategoryMap::MISC
redirect_to '/miscs/new'
end
end
# format.html { redirect_to '/diaries/new'}
format.json { render :show, status: :created, location: @category_map }
else
format.html { render :new }
format.json { render json: @category_map.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @category_map = CategoryMap.new(category_map_params)\n\n respond_to do |format|\n if @category_map.save\n format.html { redirect_to @category_map, notice: 'Category map was successfully created.' }\n format.json { render :show, status: :created, location: @category_map }\n ... | [
"0.77544147",
"0.74833596",
"0.68120265",
"0.66894853",
"0.6637736",
"0.65854806",
"0.6462527",
"0.6462527",
"0.63965106",
"0.6169199",
"0.6117966",
"0.6117966",
"0.6079098",
"0.6079098",
"0.60622233",
"0.6061422",
"0.6020181",
"0.6012433",
"0.6008961",
"0.5937357",
"0.588431... | 0.6946011 | 2 |
PATCH/PUT /category_maps/1 PATCH/PUT /category_maps/1.json | def update
respond_to do |format|
if @category_map.update(category_map_params)
format.html { redirect_to @category_map, notice: 'Category map was successfully updated.' }
format.json { render :show, status: :ok, location: @category_map }
else
format.html { render :edit }
format.json { render json: @category_map.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n json_update(category,category_params, Category)\n end",
"def update\n respond_to do |format|\n if @map.update_attributes(params[:map])\n format.html { redirect_to @map, notice: 'Map was successfully updated.' }\n format.json { head :no_content }\n else\n format.... | [
"0.6996288",
"0.64068866",
"0.6392463",
"0.6382653",
"0.63097715",
"0.6293212",
"0.62537235",
"0.6224916",
"0.618316",
"0.6170555",
"0.616416",
"0.6145979",
"0.61429894",
"0.61118525",
"0.6110556",
"0.60765404",
"0.6067608",
"0.6059834",
"0.6033137",
"0.6028997",
"0.5971643",... | 0.7460467 | 1 |
DELETE /category_maps/1 DELETE /category_maps/1.json | def destroy
@category_map.destroy
respond_to do |format|
format.html { redirect_to category_maps_url, notice: 'Category map was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deleteCategoryMappings( category_id, category_type, mapped_id)\n params = Hash.new\n params['category_id'] = category_id\n params['category_type'] = category_type\n params['mapped_id'] = mapped_id\n return doCurl(\"delete\",\"/category/mappings\",params)\n end",
"def destroy\n @map.destroy... | [
"0.75101846",
"0.74545836",
"0.7221581",
"0.7220619",
"0.7220619",
"0.7220619",
"0.7218137",
"0.7165147",
"0.71380705",
"0.7100819",
"0.7083049",
"0.70810133",
"0.7079169",
"0.70750386",
"0.7060797",
"0.70439553",
"0.69863564",
"0.69541824",
"0.6942856",
"0.6912092",
"0.69120... | 0.7744735 | 1 |
Use callbacks to share common setup or constraints between actions. | def set_category_map
@category_map = CategoryMap.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_... | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576"... | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def category_map_params
params.require(:category_map).permit(:User_id, :category)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n... | [
"0.6981537",
"0.67835593",
"0.6748275",
"0.67436063",
"0.6736311",
"0.65937173",
"0.6503359",
"0.6498499",
"0.6482832",
"0.6478776",
"0.645703",
"0.6439998",
"0.63802195",
"0.6377008",
"0.6366287",
"0.632018",
"0.63016284",
"0.63011277",
"0.62932974",
"0.62919617",
"0.6290564... | 0.0 | -1 |
Update the fields of a board. Supply a hash of string keyed data retrieved from the Trello API representing a board. | def update_fields(fields)
@id = fields['id']
@name = fields['name']
@description = fields['desc']
@closed = fields['closed']
@url = fields['url']
@organization_id = fields['idOrganization']
self
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @board = Board.find(params[:id])\n \n fields = params[:board]\n \n respond_to do |format|\n if @board.update_attributes(fields)\n format.html { redirect_to @board, notice: 'Board was successfully updated.' }\n format.json { head :no_content }\n else\n form... | [
"0.70261055",
"0.6320766",
"0.62558705",
"0.60817105",
"0.6064315",
"0.6038929",
"0.6025302",
"0.6010144",
"0.600107",
"0.600107",
"0.600107",
"0.600107",
"0.5999543",
"0.5999543",
"0.5998909",
"0.59884495",
"0.59768206",
"0.5952784",
"0.5952784",
"0.59454507",
"0.5912116",
... | 0.54850477 | 46 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.