Having a function check a column and perform a task every time an entry satisfies a condition

Question

So I have a matrix (technically a table)

     points = Table[{x, f[x]}, {x, Range[0, 2, .1]}];

Which gives something like this in matrixform

\begin{array}{cc} 0. & 1. \\ 0.1 & 0.99 \\ 0.2 & 0.960013 \\ 0.3 & 0.910219 \\ 0.4 & 0.841638 \\ \end{array}

Lets call values in the first column $v$ and values in the second column $w$ Now I want to define a function $g(x)$ that checks the value every row in the second column (the $w's$ (1,.99,.960013...)) to see if $.5x \leq w \leq .5(x+1)$ and when this is true I want it to define a third function $h$ with $h(v) = .5(x+1)$ and leave $h$ undefined everywhere else. (note that v should be from the row whose second column satisfied the inequality: i.e. v and w should be from the same row)

Any ideas on how to do this (perhaps I can figure out how to define $h$, but I don't know how to have $g$ check EVERY row of the second column for EVERY $x$ that $g(x)$ is evaluated at).

I imagine g will be something like

    g[x_]:= If[.5x<=(check all values of second column here)<=.5(x+1), 
    h(corresponding v) = .5*(x+1), Undefined] /;  Element[x, Reals]

Where I have Element[x,Reals] because I want to restrict x (although I will likely restrict it to something like {0,1,2,3,4,5....,100}

Answer 1

If my interpretation of your question is right (and that is quite uncertain), then the following definition of g should work for you. If my interpretation is wrong, perhaps this will help you to revise your question, so that a correct interpretation might more obvious. Note that I had to generate my own array for points since you did not provide one.

With[{points = Table[{x, 1./(1. + .5 x)}, {x, 0, 2, .1}]}, 
  g[x_Real, h_Symbol] :=
    (If[0. <= 2. #[[2]] - x <= 1., h[#[[1]]] = .5 x + .5] & /@ points;)]

With this, evaluating g for various values of x gives

Clear[a]; g[0., a]; DownValues[a]

{HoldPattern[a[2.]] :> 0.5}

Clear[b]; g[.5, b]; DownValues[b]

{HoldPattern[b[0.7]] :> 0.75, HoldPattern[b[0.8]] :> 0.75, 
 HoldPattern[b[0.9]] :> 0.75, HoldPattern[b[1.]] :> 0.75, 
 HoldPattern[b[1.1]] :> 0.75, HoldPattern[b[1.2]] :> 0.75, 
 ...
 HoldPattern[b[1.9]] :> 0.75, HoldPattern[b[2.]] :> 0.75}

Clear[c]; g[1., c]; DownValues[c]

{HoldPattern[c[0.]] :> 1., HoldPattern[c[0.1]] :> 1., 
 HoldPattern[c[0.2]] :> 1., HoldPattern[c[0.3]] :> 1., 
 HoldPattern[c[0.4]] :> 1., HoldPattern[c[0.5]] :> 1., 
 ...
 HoldPattern[c[1.9]] :> 1., HoldPattern[c[2.]] :> 1.}

Clear[d]; g[1.5, d]; DownValues[d]

{HoldPattern[d[0.]] :> 1.25, HoldPattern[d[0.1]] :> 1.25, 
 HoldPattern[d[0.2]] :> 1.25, HoldPattern[d[0.3]] :> 1.25, 
 ...
 HoldPattern[d[0.5]] :> 1.25, HoldPattern[d[0.6]] :> 1.25}

Clear[e]; g[2., e]; DownValues[e]

{HoldPattern[e[0.]] :> 1.5}

The discrete functions a, b, c, d, e all have the value of 5{x + 1) for each value of points[[i, 1]] where points[[i, 2]] satisfies your inequality for the given x.

Update

I write this to address an issue raised in a comment below. It appears that my use of concise operator notation is confusing. I will rewrite g, spelling out all the non-arithmetic operators appearing in its body. This will make it easy for anyone working out how g operates to look up its constituent functions in the docs to get more info.

With[{points = Table[{x, 1./(1. + .5 x)}, {x, 0, 2, .1}]},
  g[x_Real, h_Symbol] :=
    Map[
      Function[{pt}, 
        If[LessEqual[0., 2. Part[pt, 2] - x, 1.], h[Part[pt, 1]] = 0.5 + 0.5 x]],
      points];]

Map takes two arguments (ignoring level specs for now), the 1st a being a function of one variable (here a pure function) and the 2nd being a list (here points). It calls the function once for each element in the list, binding the formal argument pt to the list element. Hence, for each call pt is bound to one of the pairs {v, w} from the list. Therefore, Part[pt, 1] is v and Part[pt, 2] is w.

Answer 2

I was going to do something similar to m_goldberg, but since he has already done that, I'll add a version that uses an Association instead of assigning DownValues, which could be a problem if there are many assignments.

Our sample list:

points = Transpose@{Range[0, 1, 0.1], RandomReal[{0, 1}, 11]}

Then, we define the function g that assigns the values to h, which takes the form of an Association:

Clear[h, g]
h = Association[];
g[x_] := Module[{}
  , AppendTo[h, x -> Association[]]
  ; Scan[
   If[
     0.5 x <= Last@# <= 0.5 (x + 1)
     , AppendTo[h[x], First@# -> 0.5 (x + 1)]
     ] &
   , points]
  ]

Then, for instance if we run g[0.5] and then g[0.3], we get:

h can act as a normal function despite being an Association. That is, let's suppose we're looking at the case where x = 0.5, and we're interested in a couple of values of v. Then

h[0.5, 0.2]
h[0.5, 0.1]
(* 0.75 *)
(* Missing["KeyAbsent", 0.1] *)

If you don't like the Missing behavior, we could always overload the function h in a clever way, or perhaps we could define a new function. We can even plot it:

DiscretePlot[h[0.5, v], {v, 0, 1, 0.1}]

Answer 3

I think that you want your h to be a function of both v and x as shown in March's answer using associations.

A small modification to m_golderber's answer enables this to happen.

points = Table[{x, 1./(1. + .5 x)}, {x, 0, 2, .1}]

Add x to the argument for h.

g[x_Real,h_Symbol] := (If[0. <= 2. #[[2]] - x <= 1.,
    h[#[[1]], x] = .5 x + .5] & /@ points;)

Now applying this

g[0., h]; DownValues[h]
(* {HoldPattern[h[2.]] :> 0.5} *)

and continuing

g[.5, h]; DownValues[h]
(* {HoldPattern[h[0.7]] :> 0.75, HoldPattern[h[0.8]] :> 0.75, 
 HoldPattern[h[0.9]] :> 0.75, HoldPattern[h[1.]] :> 0.75, 
 HoldPattern[h[1.1]] :> 0.75, HoldPattern[h[1.2]] :> 0.75, 
 HoldPattern[h[1.3]] :> 0.75, HoldPattern[h[1.4]] :> 0.75, 
 HoldPattern[h[1.5]] :> 0.75, HoldPattern[h[1.6]] :> 0.75, 
 HoldPattern[h[1.7]] :> 0.75, HoldPattern[h[1.8]] :> 0.75, 
 HoldPattern[h[1.9]] :> 0.75, HoldPattern[h[2.]] :> 0.75} *)

Finishing the sample of x values.

g[1.0, h]; g[1.5, h]; g[2.0, h];

Summary of DownValues