## Is there a function to query/add values from a tab/sheet and keep fixed even if deleted or changed from the reference sheet/tab?

I have a sheet with dynamic values entered by a team. These data can change daily (deleted or changed or added more data) like list of names who are willing to participate in an event. I want to make a separate sheet or tab that will query or list all the data that were entered and not to disappear even if they were deleted later by the team.
Lets say Tab A is Data_Entry
and Tab B is my admin sheet that contains all data entered.

## fixed point theorems – Using sequence of consecutive approxims solve the equation 10x^3+10x-1=0 with the exact to 0,0001

In this task I have to use Banach fixed-point theorem. I started with transforming the equation :
x=1/10*(x^2+1), then F(x)=1/10*(x^2+1) ang 0<F(x)<1/10 for all x in R. And then:
d(F(x),F(y))= |1/10*(x^2+1) – 1/10*(y^2+1)|=1/10 * ((y+x)/(X^2+1)*(y^2+1)) * |x-y| <= 1/50 |x-y|, so L=1/50 and we have a contaction with const L=1/50
Can anyone explain me why L=1/50 because I don’t understand that step.

## encryption – How to send a fixed size encrypted message to be broadcast to multiple (known) recipients without letting the broadcaster decrypt the message

I am creating a network with three layers. A sender layer, A gateway layer, and a Receiver layer; each having different platforms. See diagram below

All platforms have published their public keys on a trusted public database server (not shown on the diagram).

A sender S wants to send a message to the receiver layer but it can only send the message via one of the platforms in the Gateway layer. Let’s call it G.

The message contains a public section that can be accessed by anyone and a private section that should be accessible only by the receiver layer. Something like below

``````{
"public"  : { <public data>  },
"private" : { <private data - encrypted> }
}
``````

Every time S sends a message to G; G uses the public section of the message to verify the authenticity of the sender and to identify a subset of Receivers { R1, R2 … Rp } where p <= n; and broadcasts the message to the “p” receivers.

How does S encrypt the message such that only {R1, R2 … Rp} are able to decrypt the message and not G?

Some additional forces that exist are as follows:

• Sender platforms layer can have 1-100000000 independent devices each having its own key pair
• The gateway platforms could range from a 1-500 platforms
• The receiver layer could have 1-10000000 platforms each having its own key pair

Any ideas on how to achieve this? I can do this using two Gateways, G1 and G2 where one G1 broadcasts the public key of S and G2 broadcasts the message. The receiver can check if the broadcaster of the key is different from the broadcaster of the message and return an “INSECURE_TRANSACTION” error of sorts. But is there a way to make it work using only one Gateway? Any help would be appreciated.

## How can a machine with fixed output for all inputs be considered a Turing machine?

To clarify, this machine T′ with the fixed output for all inputs is a Turing machine? – Shashank V M

@ShashankVM, Yes, T′ is a Turing machine. – D.W.♦ (When can a deterministic finite-state-automata (DFSA) along with its input sequence be said to be a part of another DFSA?)

From what I understand, a machine with fixed output for all inputs is a Turing machine.

Consider this thought experiment, I have a “machine” which is a wall with a slit through which I can pass a tape in. The “output” of this machine is on the wall, i.e. it is painted on the wall as a fixed string $$S$$, which for the purpose of this experiment is “Hello”. So no matter what is written on the tape, the output of this “machine” is “Hello”. From what I understand this “machine” is a Turing machine.

Is my understanding correct or am I missing something?

Because I find it hard to believe that this wall with a slit can be considered a Turing machine, when a supercomputer is considered a Deterministic Finite State Automaton.

Also I cannot see how this “machine” can emulate any another Turing machine or do any useful computation.

## forms – Set an optional field to a fixed value

I’ve got a edit form in which the user can change a number of properties from an item. In certain conditions, there is an optional time field which the user can set. But it cannot be set to an actual value in the UI, the user can only specify that it must be set to ‘Now’ (a backend then later in the process will determine what ‘Now’ actually is with margins and so).

I am looking for a good design for this. Of course I can use a checkbox with “Use current time” or something, but that looks weird in this case.

What I’ve come up with is this:
(real form and design is very different and specific, mockup just to show the idea):

The optional field here is ‘Due time’. When it’s present and has no value, the ‘Due time’ header is shown with a grey ‘Unknown’ value below. A ‘Now’ button can be pressed and that changes the value to ‘Now’ after which the button disappears. User can Update the rest of the item or Cancel it by using the form buttons. We’ve got a Now/Clock icon and button in some other places in our app, so that might be familiar to the user.

What do you guys think? Is this a weird interaction? If don’t think I see this much so I am doubting.

## sdl2 – Will using a fixed point library in C++ give me 100% deterministic replays?

I’m working on a scrolling arcade shooter in C++ with SDL2 and I’d like to have a replay function so players can save, share, and replay good runs. I understand that floating point math is not consistent from CPU to CPU, so saving inputs with frame counters won’t give you stable replays. I saw someone mention that fixed point math is a possible solution, so I’m currently working on a C++ engine using Libfixmath `fix16_t` datatypes in place of anything that would be a floating point.

Should this give me 100% deterministic replays across hardware if I save the random seed? From my understanding of how a fixed point math library works that should be the case, but I would like some confirmation before I bank my entire engine around this. Really my only concern is that I’m using literal floats to set the starting values for some things, like `fix16_from_float(1.2)` to set the player’s movement speed and I’m not entirely sure if CPU inconsistency could mess up that initial value and thus defeat the purpose. If so, could I solve the problem by using `fix16_from_int()` paired with some Libfixmath arithmetic to get the same non-integer values without ever using floats? I don’t quite have a complete grasp on how literals are stored into a compiled program.

I am also a tad worried about performance with potentially hundreds of onscreen bullets using high level fixed point math every frame, but I’ll have to see how much impact that has when I get to it.

## How do I select a fixed lens for my APS-C sensor camera for a specific field of view/zoom

50mm is 50mm.

Your 16-50mm lens has actual focal lengths ranging from 16-50mm. That gives an angle of view on your APS-C camera of a 16-50mm lens on an APS-C camera, which is also the “equivalent” angle of view given by a 24-75mm on a FF camera.

When your 16-50mm APS-C lens is zoomed to 50mm on your APS-C camera, you get the angle of view of a 50mm lens on an APS-C camera. That’s the same angle of view you’d get using a 75mm lens on a FF camera.

When a 50mm FF lens is used on your APS-C camera, you get the angle of view of a 50mm lens on an APS-C camera. It’s the same angle of view as you get using a 50mm APS-C lens on your APS-C camera. The only time you need to worry about conversion factor is if you want to get the same angle of view using a different sensor size.

The larger image circle of the FF lens doesn’t spread the same angle of view over a larger image circle, it provides a wider angle of view over a larger image circle. The center 28mm diameter portion of the FF lens’ image circle shows the same thing as the entire 28mm wide image circle cast by the APS-C lens. The extra 8mm on either side of the larger image circle shows things that are outside of the smaller image circle’s coverage. But the center 28mm of both lenses’ image circles show the exact same thing.¹

ANY 50mm lens, either made for APS-C cameras or FF cameras, will give you the same 50mm angle of view on the same 1.5X APS-C camera. This will be the same angle of view that one would get using a 75mm lens on a FF sensor. You only need to get a 75mm lens if you’re also going to change to a FF camera and want the same angle of view that you get with your 50mm lens on your APS-C camera.

¹ This is assuming both lenses are actually the same focal length, use the same projection, and share the same geometric distortion characteristics. In practice, one 50mm lens may actually be 48mm and another 50mm lens may be 52mm in focal length. Both would be marketed as 50mm lenses.

## centos – SELinux setting default boolean value throws error, “could not convert system_u:object_r:systemd_sleep_exec_t:s0 to sid”. How is this fixed?

Environment: Digital Ocean Droplet, CentOS 8

The State of `httpd_can_network_relay` is set to on. However the Default is set to off.

``````\$ sudo semanage boolean -l | grep httpd_can_network_relay

httpd_can_network_relay        (on   ,  off)  Allow httpd to can network relay
``````

However when I attempt to set the default to on I get an error. I’m not sure how to approach this.

``````\$ sudo setsebool httpd_can_network_relay 1 -P

libsepol.context_from_record: type systemd_sleep_exec_t is not defined

libsepol.context_from_record: could not create context structure

libsepol.context_from_string: could not create context structure

libsepol.sepol_context_to_sid: could not convert system_u:object_r:systemd_sleep_exec_t:s0 to sid

invalid context system_u:object_r:systemd_sleep_exec_t:s0
``````

Note:
All repos are up to date with dnf.

``````\$ dnf repolist
appstream                                               CentOS Linux 8 - AppStream
baseos                                                  CentOS Linux 8 - BaseOS
epel                                                    Extra Packages for Enterprise Linux 8 - x86_64
epel-modular                                            Extra Packages for Enterprise Linux Modular 8 - x86_64
extras                                                  CentOS Linux 8 - Extras
nginx-stable                                            nginx stable repo
nodesource                                              Node.js Packages for Enterprise Linux 8 - x86_64
``````

## reference request – Theorem classifying fixed point sets of an isometry of the three sphere

Let $$T:S^3rightarrow S^3$$ be an isometry of finite order. Then the set $$S^T={xin S^3|Tx=x}$$ of fixed points is either empty, or a pair of antipodal points, or a great circle, or a great sphere.

Is there a reference for this in some well-known textbook or paper? Thanks in advance!

Edit: Having received a couple of answers containing proofs, I would like to clarify that I know proofs for this and I am specifically looking for a source which can be cited instead of providing a proof (due to space considerations). This question is literally a reference request.

## camera – Is there a place to discuss fixed cam 3d games? (Eg. Resident Evil 1 etc)

Does anybody know if there’s a Discord or a website or a forum where folks discuss Fixed Cam 3D games in detail? I’m really not into Facebook, so ideally I’m not looking for a FB page, etc.

Resident Evil’s obviously a key reference, but I’m also looking to talk about stuff like Alone in the Dark, Obscure, Life is Strange, Telltale’s Walking Dead, White Night, Tormented Souls, Heavy Rain, Fear the Dark Unknown, City of Lost Children, Summerford, Simulacrum, some of the Puppetcombo games etc…?

I’m just really curious to know if there’s somewhere people discuss or debate those games – they’re not exactly common and they’re often made in the survival horror genre, but I think they offer some interesting challenges in both cinematography and interaction design, while also offering a particular visual language for creators.

Ehh – just think they’re cool. =] Any thoughts?