How to scale two ranges knowing the 0 point value? - math

I need to scale something like [MINs, 0, MAXs] to [MINa, STARTa, MAXa]
So, given MINs, MAXs, MINa, STARTa, MAXa: I need f that solves:
f(MINs) = MINa
f(0) = STARTa
f(MAXs) = MAXa
Any ideas on how to get f?
As an example:
MINa = -80, STARTa = 10, MAXa = 110, MINs = -32768, MAXs = 32767

Related

find unique neighbour pairs between two point clouds in R

Given two point clouds I want to find for each point from the first point cloud the nearest neighbour from the second point cloud. Also, each pair of neighbours should be unique. The solution was already given here for Python. However, I was wondering if a similar approach exists for R (I'd like to avoid the suggested cvxpy library from the Python solution which requires the pyscipopt library which again requires the installation of the SCIP Optimization Suite).
Some example code with two point clouds:
set.seed(666)
# Example data
px = runif(210, min = 0, max = 100)
py = runif(210, min = 0, max = 100)
pc1 = cbind(x = px[1:100], y = py[1:100])
pc2 = cbind(x = px[101:210], y = py[101:210])
plot(pc1, pch = 16, col = 1)
points(pc2, pch = 16, col = 2)
# Calculate distance matrix
# library(pdist)
# d = pdist(pc1, pc2)
# d = as.matrix(d)
# Find closest neighbour
library(FNN)
nn = get.knnx(pc2, pc1, k = 1)
for(i in 1:nrow(pc1)) lines(x = c(pc1[i,1], pc2[nn$nn.index[i,1],1]),
y = c(pc1[i,2], pc2[nn$nn.index[i,1],2]))
As shown in the image above, I'm capable of finding the nearest neighbour for each point from Point Cloud 1 (black) to Point Cloud 2 (red). Yet, multiple points from Point Cloud 2 are assigned to the same point from Point Cloud 1. Any idea how to find unique pairs with minimal overall distances instead?
Edit:
I tried another approach by finding the closest pair iteratively and removing that pair from the following queries:
# Approach 2:
pairs = matrix(NA, ncol = 4, nrow = nrow(pc1)) #storage for pairs
colnames(pairs) = c("x(pc1)", "y(pc1)", "x(pc2)", "y(pc2)")
pc2_copy = pc2 # copy of Point Cloud 2 which will shrink each iteration
for(i in 1:nrow(pc1)){
nn = get.knnx(pc2_copy, pc1[i,,drop = FALSE], k = 1)
pairs[i,1:2] = pc1[i,1:2,drop = FALSE]
pairs[i,3:4] = pc2_copy[nn$nn.index[1,1],1:2,drop = FALSE]
pc2_copy = pc2_copy[-c(nn$nn.index[1,1]),] #remove the corresponding point from the matrix
}
plot(pc1, pch = 16, col = 1)
points(pc2, pch = 16, col = 2)
for(i in 1:nrow(pairs)) lines(x = pairs[i,c(1,3)], y = pairs[i, c(2,4)])
While this gives me unique pairs, I don't believe this is anywhere near an ideal solution (in my real data example some distances are very little while others are immense with an obviously much better solution by eye).

The package RcppHungarian will solve this type of assignment problem using the Hungarian algorithm:
set.seed(666)
# Example data
px = runif(210, min = 0, max = 100)
py = runif(210, min = 0, max = 100)
pc1 = cbind(x = px[1:100], y = py[1:100])
pc2 = cbind(x = px[101:210], y = py[101:210])
nn <- RcppHungarian::HungarianSolver(
proxy::dist( # distance matrix
pc1, pc2, method = "euclidean"
)
)$pairs
any(duplicated(nn[,2]))
#> [1] FALSE
plot(pc1, pch = 16, col = 1)
points(pc2, pch = 16, col = 2)
for(i in 1:nrow(pc1)) lines(x = c(pc1[i,1], pc2[nn[i,2],1]),
y = c(pc1[i,2], pc2[nn[i,2],2]))

Function based on lists not working as expected

I'm trying build this function that takes two lists and a single input.
What I have so far:
CLV_general <- function(profit, alpha, r){
CLV = 0
t = length(profit)
for (i in 1:length(profit)){
for (p in profit){m = p}
for (t in 0:t){T = t}
for(a in alpha){A = a}
clv = (m*A)/((1 +r)^T)
CLV = CLV + clv
}
return(CLV)
}
Calling the function is based off:
alpha = c(1, .96, .92, .88, .84, .80)
profits = c(100, 100, 100, 100, 100,100)
CLV_general(profits, alpha, .10)
But returns a value of 270.9475 but it should return of value of:
> (100*1/((1+.10)^0)) + (100*.96/((1+.10)^1)) + (100*.92/((1+.10)^2)) + (100*.88/((1+.10)^3)) + (100*.84/((1+.10)^4)) + (100*.80/((1+.10)^5))
[1] 436.4683
The function is based off of the formula SUM(Mt*At/((1+r)^t) where Mt is each value sequential value in profits above, A is sequential value of alpha above, rate is constant and t is time 0 to length of profits or alpha.
I've been stuck on this for like 5 hours and I'm just missing SOMETHING. Thanks!!!

This seems to be a vectorised operation. Try :
CLV_general <- function(profit, alpha, r){
sum((profit*alpha/((1 + r)^(seq_along(alpha) - 1))))
}
alpha = c(1, .96, .92, .88, .84, .80)
profits = c(100, 100, 100, 100, 100,100)
CLV_general(profits, alpha, .10)
#[1] 436.4683

R : Changing values of variables after certain time

the question I am trying to ask is how to I change one of the values of my variables (noted as LO$M in my list) after I pass a certain time.
The thing I am trying to achieve is that after 20,000 seconds passing I would like to change my value of Lac to the value of Lac at time 20,0000 +10,000
So at t = 20,000, Lac = Lac + 10,000
The issue I am having with my code is that within my if command I have if tt>= 20000, but this leads to the issue that every value of Lac after 20,000 being increased by 10,000 when what i want is that the FIRST value after 20,000 be increased by 10,000.
Basically, after 20,000 of my experiment passing I am trying to inject 10,000 more Lac into the experiment.
My code is given below:
LO = list()
LO$M = c(i = 1, ri = 0, I = 50, Lac = 20, ILac = 0, o = 1, Io = 0, RNAP = 100, RNAPo = 0, r = 0, z = 0)
LO$Pre = matrix(c(1,0,0,0,0,0,0,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,0,
0,0,1,1,0,0,0,0,0,0,0,
0,0,0,0,1,0,0,0,0,0,0,
0,0,1,0,0,1,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,
0,0,0,0,0,1,0,1,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,
0,0,0,0,0,0,0,0,1,0,0,
0,0,0,0,0,0,0,0,0,1,0,
0,0,0,1,0,0,0,0,0,0,1,
0,1,0,0,0,0,0,0,0,0,0,
0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,1,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,1,0,
0,0,0,0,0,0,0,0,0,0,1), ncol=11, byrow=TRUE)
LO$Post = matrix(c(1,1,0,0,0,0,0,0,0,0,0,
0,1,1,0,0,0,0,0,0,0,0,
0,0,0,0,1,0,0,0,0,0,0,
0,0,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,0,
0,0,1,0,0,1,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,
0,0,0,0,0,1,0,1,0,0,0,
0,0,0,0,0,1,0,1,0,1,0,
0,0,0,0,0,0,0,0,0,1,1,
0,0,0,0,0,0,0,0,0,0,1,
0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,
0,0,0,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0), ncol=11, byrow=TRUE)
LO$h = function(x,t,th=c(0.02,0.1,0.005,0.1,1,0.01,0.1,0.01,0.03,0.1,1e-05,0.01,0.002,0.01,0.001))
{
with(as.list(c(x, th)), {
return(c(th[1]*i, th[2]*ri, th[3]*I*Lac, th[4]*ILac, th[5]*I*o, th[6]*Io, th[7]*o*RNAP,
th[8]*RNAPo, th[9]*RNAPo, th[10]*r, th[11]*Lac*z, th[12]*ri, th[13]*I,
th[13]*ILac, th[14]*r, th[15]*z))
})
}
gillespie1 = function (N, n, ...)
{
tt = 0
x = N$M
S = t(N$Post - N$Pre)
u = nrow(S)
v = ncol(S)
tvec = vector("numeric", n)
xmat = matrix(ncol = u, nrow = n + 1)
xmat[1, ] = x
for (i in 1:n) {
h = N$h(x, tt, ...)
tt = tt + rexp(1, sum(h))
j = sample(v, 1, prob = h)
x = x + S[, j]
tvec[i] = tt
xmat[i + 1, ] = x
if( tt >=20000){
x[4] = x[4] +10000
}
}
return(list(t = tvec, x = xmat))
}
newout = gillespie1(LO,200000)
matplot(newout$x[,4], type="l", lwd=0.25, col="grey")
I don't have a high enough reputation to attach images, but it should look something like this:
https://gyazo.com/0ffd940a22df23b2ccfdf4a17e85dca8
Sorry if this isn't clear. Thanks

In this example, you have the function myTask(). When you call execMyTask(), you will execute myTask()once, and after that, you will execute it at random intervals between 1 to max_wait milliseconds. When you get tired, you can kill the task with tclTaskDelete().
library(tcltk2)
myTask <- function() cat("some task!\n")
id = "execMyTask"
execMyTask <- function(max_wait = 3000) {
id <- toString(match.call()[[1]])
myTask()
wait = sample(1:max_wait, 1)
cat("Waiting", wait, "miliseconds\n") # replace with your function
if (is.null(tclTaskGet(id))) {
tclTaskSchedule(wait=wait, execMyTask(), id=id, redo = TRUE)
} else {
tclTaskChange(wait=wait, execMyTask(), id=id, redo = TRUE)
}
}
execMyTask()
tclTaskDelete(id)
So far, there is a little problem with this approach, because we can not supply arguments to the function fun in tclTaskChange().

How to create a dataframe representing a 10000 points unit square?

I have to create a dataframe representing a unit square, shaped by 10 000 points. In orderd to achieve that, I need all the combinations between (coordinates) x and y, where each one goes from 0 to 1,00. The result should be something like this:
x y
1 0,01 0,01
2 0,01 0,02
n 0,12 0,04
10000 1,00 1,00
I would be very glad if you can help me.

10 000 points are just a 100x100 square.
Here I fix the value of y and describe the 100 values of x for this possibility.
To do this:
df<-data.frame(
x = rep(seq(from = 0, to = 1, length.out = 100), times = 100)
y = rep(seq(from = 0, to = 1, length.out = 100), each = 100)
)
Using #Heroka's suggestion, for the same output:
df<- expand.grid(x = seq(from = 0, to = 1, length.out = 100),
y = seq(from = 0, to = 1, length.out = 100)
)

How draw a circle in Lua?

How can draw a circle by drawing point?
local x, y = 0, 0
for i = 1, 360 do
drawPoint( (x*i), (y*i) )
end
I'm bad at math.
local x, y = 0, 0
for i = 1, 360 do
drawPoint( math.cos(i)*(10)+x, math.sin(i)*(10)+y )
end
Ok I did it; But I have some questions:
How do I know the appropriate number place number 40 in the a loop?
How do I know width, and radius? Which represents the number 10 in the loop.

Let's say x and y is your centre co-ordinate and r is the radius. Now:
local x, y, r = 0, 0, 1
for i = 1, 360 do
local angle = i * math.pi / 180
local ptx, pty = x + r * math.cos( angle ), y + r * math.sin( angle )
drawPoint( ptx, pty )
end

Resources