file – What are the benefits of real-time collaboration using a SharePoint document library versus OneDrive?

The OneDrive for Business and SharePoint Online document libraries support the same features in terms of co-authoring, versioning, and a few other features. There is no reason why you can not work with both, but the intention of each product is different.

OneDrive for Business is designed for your "personal" working documents, with occasional sharing and collaboration.

SharePoint Online Team sites are designed for group-based collaboration, within a team, a v-team, a department, and so on.

Apart from that, you can use any of the answers to your real-time co-authoring question.

oracle – How to ingest real-time data from transaction tables in a flat table

We have transaction tables in Oracle and we need this data to be transferred in real time to another Oracle flat table in another database. The performance of the report is excellent with the table placed in this flat table.
We are currently using Golden Gate for replication on the other database and the use of the materialized view, but due to some problems, we need to switch to another way of feeding / maintaining this flat table. What options do we have?
This is a pretty basic requirement, but the solutions I can see are for batch processing. Moreover, if there are other solutions, you think they would better serve this purpose. Replacing the target database with another is also an option, as more reports of this type may be provided later.

Real-Time Price for Basic Attention Token (BAT) – Brave Cryptocurrency

[IMG]

Price for each installation of Brave Browser
[IMG]

* – Use a proxy tool for a real-time price

Install Brave Browser

https://bit.ly/_brave_browser

java – Real-time dashboard to monitor the program's execution

We have a unix system in which scheduled scripts run every day and return success or failure. Whenever we have to connect to the server and check the run file to get the run status. I planned to create the dashboard on which we will be able to check the running status in the web page itself. I need your suggestion on how we can read this data and display it on a dashboard in real time.
I am a beginner for all technologies related to the Web. I planned to implement using springmvc, angluar.

python – real-time double-pendulum graph

I've made a small application that integrates a matplotlib dynamic plot in tkinter which allows control through the tkinter MISTLETOE. The code is in Github. He also uses numpy and scipy to solve the ordinary differential equations for a double pendulum.

To change the initial theta, simply drag the bobs to another position …

screen frame

I would appreciate the review for comments and improvements and have a question: why climax work for the canvas_pendulum (line 54)

cls.canvas_pendulum.get_tk_widget (). configure (highlightthickness = 1)

but not for canvas_graphs (line 72)?

cls.canvas_graphs.get_tk_widget (). configure (highlightthickness = 1, bg = & # 39; yellow & # 39;)

Add the following packages to your environment

pip install numpy matplotlib scipy
import system
import tkinter as tk
import time
import numpy as np
import matplotlib.pyplot as a plt
since matplotlib import patches as mpl_patches
from the matplotlib import lines as mpl_lines
from matplotlib.backends.backend_tkagg, import, figureCanvasTkAgg
from scipy.integrate import ode

TWOPI = 2 * np.pi
PI = np.pi

FIG_SIZE_PENDULUM = (5, 5)
X_MIN, X_MAX = -10, 10
Y_MIN, Y_MAX = -10, 10
TICK_INTERVAL = 1.5

FIG_SIZE_GRAPHS = (5, 1)

update_label_interval_ms = 150
fps = 24
seconds_per_frame = 1 / fps
time_window_graphs = 20
update_graph_interval_s = 0.25


MplMap class ():
& # 39; & # 39; & # 39; map consisting of two digits: fig_pendulum and fig_graphs
fig_pendulum: has an ax showing the movements of the pendulum
fig_graphs: has two axes showing theta1 and theta2 graphs
& # 39; & # 39; & # 39;
@classmethod
Def (cls, root, fig_size_pendulum, fig_size_graphs) parameters:
# define the outline of the parcel, including the axes going through the origin
cls.root = root

cls.fig_pendulum, cls.ax_pendulum = plt.subplots (figsize = fig_size_pendulum)
cls.ax_pendulum.set_xlim (X_MIN, X_MAX)
cls.ax_pendulum.set_ylim (Y_MIN, Y_MAX)
cls.ax_pendulum.set_aspect (1)
tick_range = np.arange (
round (X_MIN + (10 * abs (X_MIN)% TICK_INTERVAL * 10) / 10, 1),
X_MAX + 0.1, step = TICK_INTERVAL)
cls.ax_pendulum.set_xticks (tick_range)
cls.ax_pendulum.set_yticks ([])
cls.ax_pendulum.tick_params (axis = x, which => major, labelsize = 6)
cls.ax_pendulum.spines['left'].set_color (& # 39; no)
cls.ax_pendulum.spines['right'].set_color (& # 39; no)
cls.ax_pendulum.spines['bottom'].set_position (& # 39; zero & # 39;)
cls.ax_pendulum.spines['top'].set_color (& # 39; no)
cls.fig_pendulum.tight_layout ()
cls.canvas_pendulum = FigureCanvasTkAgg (cls.fig_pendulum, master = cls.root)
cls.canvas_pendulum.get_tk_widget (). configure (highlightthickness = 1)

cls.fig_graphs, (cls.ax_graph_1, cls.ax_graph_2) = plt.subplots (
1, 2, figsize = fig_size_graphs)
cls.ax_graph_1.set_ylim (-180, 180)
cls.ax_graph_1.set_yticks ([-180, -90, 0, 90, 180])
cls.ax_graph_1.tick_params (axis = "y", which = "major", labelsize = 6)
cls.ax_graph_1.tick_params (axis = x, which = major, labelsize = 6)
cls.ax_graph_1.grid (True)

cls.ax_graph_2.set_ylim (-190, 190)
cls.ax_graph_2.set_yticks ([-180, -90, 0, 90, 180])
cls.ax_graph_2.tick_params (axis = "y", which = "major", labelsize = 6)
cls.ax_graph_2.tick_params (axis = x, which => major, labelsize = 6)
cls.ax_graph_2.grid (True)

cls.fig_graphs.tight_layout ()
cls.canvas_graphs = FigureCanvasTkAgg (cls.fig_graphs, master = cls.root)
cls.canvas_graphs.get_tk_widget (). configure (highlightthickness = 1, bg = & # 39; yellow & # 39;)

@classmethod
def get_cnvs_pendulum (cls):
returns cls.canvas_pendulum

@classmethod
def get_cnvs_graphs (cls):
returns cls.canvas_graphs


DoublePendulum class (MplMap):
Class & # 39; & # 39; & # 39; class definition methods for Pendulum for positions and movements of a double
pendulum
& # 39; & # 39; & # 39;
def __init __ (self, _a1, _a2):
# Physical constants and initial settings
auto.g = 9.8
self.damping1 = 0.0 # damping factor bob1
self.damping2 = 0.0 # Coupling factor bob2
self.length_r1 = 5.0
self.length_r2 = 2.5
self.mass_bob1 = 5.0
self.mass_bob2 = 2.5
self.color_bob1 = & # 39; green & # 39;
self.color_bob2 = & # 39; red & # 39;
self.plotsize = 1.10 * (self.length_r1 + self.length_r2)

# Initial state
if _a1 and _a2:
self.theta1_initial = np.radians (_a1)
self.theta2_initial = np.radians (_a2)
other:
self.theta1_initial = + 120/180 * np.pi
self.theta2_initial = + 180/180 * np.pi
self.theta1_dot_initial = 0
self.theta2_dot_initial = 0
self.theta1 = self.theta1_initial
self.theta2 = self.theta2_initial
self._time = 0

_x1, _y1 = self.calc_xy (self.length_r1, self.theta1_initial)
self.bob1 = mpl_patches.Circle ((x1, _y1), 0,2 + self.m1 * 0,02,
fc = self.color_bob1, alpha = 1, zorder = 2)
self.bob1.set_picker (0)
self.ax_pendulum.add_patch (self.bob1)
self.stick1 = mpl_lines.Line2D ([0, _x1], [0, _y1], zorder = 2)
self.ax_pendulum.add_line (self.stick1)
cv_bob1 = self.bob1.figure.canvas
cv_bob1.mpl_connect (& # 39; pick_event & # 39 ;, self.on_pick)
cv_bob1.mpl_connect (& # 39; motion_notify_event & # 39 ;, self.on_motion)
cv_bob1.mpl_connect ('button_release_event', self.on_release)

_x2, _y2 = self.calc_xy (self.length_r2, self.theta2_initial)
_x2 + = _x1
_y2 + = _y1
self.bob2 = mpl_patches.Circle ((_ x2, _y2), 0,2 + self.m2 * 0,02,
fc = self.color_bob2, alpha = 1, zorder = 2)
self.bob2.set_picker (0)
self.ax_pendulum.add_patch (self.bob2)
self.stick2 = mpl_lines.Line2D ([_x1, _x2], [_y1, _y2], zorder = 2)
self.ax_pendulum.add_line (self.stick2)
cv_bob2 = self.bob2.figure.canvas
cv_bob2.mpl_connect (& # 39; pick_event & # 39 ;, self.on_pick)
cv_bob2.mpl_connect (& # 39; motion_notify_event & # 39 ;, self.on_motion)
cv_bob2.mpl_connect ('button_release_event', self.on_release)

self.x_traces = []
        self.y_traces = []
        self.trace_line, = self.ax_pendulum.plot (
            [0], [0], color = "black", line width = 0.2, zorder = 1)

self.current_object = None
self.current_dragging = False
self.break_the_loop = False

self.theta_graphs = ThetaGraphs ()
self.blip ()

def switch_colors_of_bob (self):
print (& # 39; change color & # 39;)
self.color_bob1, self.color_bob2 = self.color_bob2, self.color_bob1
self.bob1.set_color (self.color_bob1)
self.bob2.set_color (self.color_bob2)
self.blip ()

def toggle_trace_visible (self):
print (self.trace_line.get_visible ())
if self.trace_line.get_visible ():
self.trace_line.set_visible (False)
other:
self.trace_line.set_visible (True)
self.blip ()

clear_trace def (auto):
self.x_traces = []
        self.y_traces = []
        self.trace_line.set_data ([0], [0])
self.blip ()

@property
def gravity (auto):
return self.g

@ gravity.setter
def gravity (self, value):
self.g = value

@property
def m1 (auto):
return self.mass_bob1

@ m1.setter
def m1 (self, value):
self.mass_bob1 = value
self.bob1.set_radius (0.2 + self.mass_bob1 * 0.02)
self.blip ()

@property
def m2 (auto):
returns self.mass_bob2

@ m2.setter
def m2 (self, value):
self.mass_bob2 = value
self.bob2.set_radius (0.2 + self.mass_bob2 * 0.02)
self.blip ()

@property
def l1 (auto):
returns self.length_r1

@ l1.setter
def l1 (self, value):
self.length_r1 = value
self.calc_positions ()
self.blip ()

@property
def l2 (auto):
returns self.length_r2

@ l2.setter
def l2 (self, value):
self.length_r2 = value
self.calc_positions ()
self.blip ()

@property
def k1 (auto):
return from self.damping1

@ k1.setter
def k1 (self, value):
self.damping1 = value

@property
def k2 (auto):
return from self.damping2

@ k2.setter
def k2 (self, value):
self.damping2 = value

@property
def angle1_initial (self):
angle = self.theta1_initial
returns np.degrees (-PI + (angle - PI)% TWOPI)

@property
def angle2_initial (self):
angle = self.theta2_initial
returns np.degrees (-PI + (angle - PI)% TWOPI)

@property
def angle1 (auto):
angle = self.theta1
returns np.degrees (-PI + (angle - PI)% TWOPI)

@property
def angle2 (auto):
angle = self.theta2
returns np.degrees (-PI + (angle - PI)% TWOPI)

@property
def time (self):
return self._time

def on_pick (auto, event):
if event.artist! = self.bob1 and 
event.artist! = self.bob2:
return

self.current_dragging = True
self.current_object = event.artist

def on_motion (auto, event):
otherwise self.current_dragging:
return
if self.current_object == self.bob1:
self.theta1 = self.calc_theta (event.xdata, event.ydata, self.theta1)
self.theta1_initial = self.theta1

elif self.current_object == self.bob2:
_x1, _y1 = self.bob1.center
self.theta2 = self.calc_theta (
event.xdata - _x1, event.ydata - _y1, self.theta2)
self.theta2_initial = self.theta2

other:
return

self.calc_positions ()
self.blip ()

def on_release (self, _):
self.current_object = None
self.current_dragging = False

def start_swing (auto):
self.break_the_loop = False
self.theta1_initial = self.theta1
self.theta2_initial = self.theta2
self.y_traces = []
        self.x_traces = []
        self.plot_double_pendulum ()

def stop_swing (auto):
self.break_the_loop = True

def calc_positions (self):
_x1, _y1 = self.calc_xy (self.l1, self.theta1)
self.bob1.center = (_x1, _y1)
self.stick1.set_data ([0, _x1], [0, _y1])

_x2, _y2 = self.calc_xy (self.l2, self.theta2)
_y2 + = _y1
_x2 + = _x1
self.bob2.center = (_x2, _y2)
self.stick2.set_data ([_x1, _x2], [_y1, _y2])

def add_to_trace (auto):
_x2, _y2 = self.bob2.center
self.x_traces.append (_x2)
self.y_traces.append (_y2)
self.trace_line.set_data (self.x_traces[:], self.y_traces[:])

@staticmethod
def calc_theta (x, y, theta):
try:
returns np.arctan2 (x, -y)
except TypeError:
back theta

@staticmethod
def calc_xy (length, theta):
x = length * np.sin (theta)
y = - length * np.cos (theta)
return x, y

def blip (auto):
self.fig_pendulum.canvas.draw ()
self.fig_pendulum.canvas.flush_events ()

def get_derivatives_double_pendulum (self, t, state):
& # 39; & # 39; & # 39; definition of the ordinary differential equation for a
double pendulum. See for derivations at
https://ir.canterbury.ac.nz/bitstream/handle/10092/12659/chen_2008_report.pdf
& # 39; & # 39; & # 39;
t1, w1, t2, w2 = state
dt = t1 - t2
_sin_dt = np.sin (dt)
_den1 = (self.m1 + self.m2 * _sin_dt * _sin_dt)

_num1 = self.m2 * self.l1 * w1 * w1 * np.sin (2 * dt)
_num2 = 2 * self.m2 * self.l2 * w2 * w2 * _sin_dt
_num3 = 2 * self.g * self.m2 * np.cos (t2) * _sin_dt + 
2 * self.g * self.m1 * np.sin (t1)
_num4 = 2 * (self.k1 * w1 - self.k2 * w2 * np.cos (dt))
w1_dot = (_num1 + _num2 + _num3 + _num4) / (-2 * self.l1 * _den1)

_num1 = self.m2 * self.l2 * w2 * w2 * np.sin (2 * dt)
_num2 = 2 * (self.m1 + self.m2) * self.l1 * w1 * w1 * _sin_dt
_num3 = 2 * self.g * (self.m1 + self.m2) * np.cos (t1) * _sin_dt
_num4 = 2 * (self.k1 * w1 * np.cos (dt) - 
self.k2 * w2 * (self.m1 + self.m2) / self.m2)
w2_dot = (_num1 + _num2 + _num3 + _num4) / (2 * self.l2 * _den1)

state_differentiated = np.zeros (4)
state_differentiated[0] = w1
state_differentiated[1] = w1_dot
state_differentiated[2] = w2
state_differentiated[3] = w2_dot

return state_differentiated

def plot_double_pendulum (auto):
& # 39; & # 39; & # 39; methods to draw the pendulum in matplotlib
& # 39; & # 39; & # 39;
# note one frame per second (fps)> 24 l 'real time
# may not be able to follow the model's time

def current_time ():
return time.time ()

def check_drift (_time, running_time):
# check every 5 seconds
if _time% 5 <seconds_per_frame:
print (f) time (ms): {1000 * _time:,. 0f}, & # 39;
f drift: {1000 * (running_time - _time):,. 0f} & # 39;)

self._time = 0
dp_integrator = ode (self.get_derivatives_double_pendulum) .set_integrator (& # 39; vode & # 39;)
state = np.array ([self.theta1, self.theta1_dot_initial,
                          self.theta2, self.theta2_dot_initial])
dp_integrator.set_initial_value (state, self._time)

self.add_to_trace ()

actual_start_time = current_time ()
as dp_integrator.successful () and not self.break_the_loop:

self.theta1, _, self.theta2, _ = state

self.calc_positions ()
self.add_to_trace ()

if self._time% update_graph_interval_s <seconds_per_frame:
self.theta_graphs.plot_thetas (self._time, self.theta1, self.theta2)

running_time = current_time () - actual_start_time
check_drift (self._time, running_time)

while running_time <self._time:
running_time = current_time () - actual_start_time

other:
self.blip ()

state = dp_integrator.integrate (dp_integrator.t + seconds_per_frame)
self._time + = seconds_per_frame


ThetaGraphs class (MplMap):
& # 39; & # 39; & # 39; Display method of theta1 and theta2 graphs
& # 39; & # 39; & # 39;
def __init __ (auto):
self.time_window = time_window_graphs
self.time_base = 0
self.time_values ​​= []
        self.angle1_values ​​= []
        self.angle2_values ​​= []
        self.theta1_graph, = self.ax_graph_1.plot (
            [0], [0], color = "black", line width = 0.5, zorder = 2)
self.theta2_graph, = self.ax_graph_2.plot (
            [0], [0], color = "black", line width = 0.5, zorder = 2)
self.ax_graph_1.set_xlim (
self.time_base, self.time_base + self.time_window)
self.ax_graph_2.set_xlim (
self.time_base, self.time_base + self.time_window)

def plot_thetas (self, _time, theta1, theta2):
if _time% self.time_window <seconds_per_frame:

# reset when the time is zero
if _time <seconds_per_frame:
self.time_base = -self.time_window
self.angle1_values ​​= []
                self.angle2_values ​​= []
                self.time_values ​​= []

            self.time_base + = self.time_window
self.ax_graph_1.set_xlim (
self.time_base, self.time_base + self.time_window)
self.ax_graph_2.set_xlim (
self.time_base, self.time_base + self.time_window)

self.time_values.append (_time)

self.angle1_values.append (np.degrees (-PI + (theta1 - PI)% TWOPI))
self.theta1_graph.set_data (self.time_values, self.angle1_values)

self.angle2_values.append (np.degrees (-PI + (theta2 - PI)% TWOPI))
self.theta2_graph.set_data (self.time_values, self.angle2_values)

self.fig_graphs.canvas.draw ()
self.fig_graphs.canvas.flush_events ()


TkHandler class ():
& # 39; & # 39; & # 39; Methods for managing the tkinter GUI and links to the matplotlib canvases and pendulum
class. The methods:

__init__:
settings:
: root: root tk
: cnvs_pendulum: maplotlib canvas showing the movement of the pendulum
: cnvs_graphs: matplotlib canvas showing the graphics of theta1 and theta2
: doublependulum: class manipulating doublependulum status and positions

create_slider_status_frame:
Creates the cursor frame and the initial theta1 state values,
initial theta2, time, theta1, theta2

Cursor values ​​are connected to the pendulum class by the _set_value value
function that defines the values ​​for: gravity, mass1, mass2, length1, length2,
depreciation1, depreciation2

update_labels:
Update the status values. The update rate is set by: update_label_interval_ms

create_button_frame:
Creates a frame with control buttons and links with button functions:
_quit: quit the program

The following button functions connect to the pendulum class to change
status:
_set_colors: exchange the colors of the bobs
_toggle_trace_visible: enable or disable tracking
_clear_trace: clear the trace
_start: starts swinging the pendulum
_stop: stop the pendulum

create_grid:
Creates the graphic grid
& # 39; & # 39; & # 39;
def __init __ (self, root, cnvs_pendulum, cnvs_graphs, doublependulum):
self.root = root
self.cnvs_pendulum = cnvs_pendulum
self.cnvs_graphs = cnvs_graphs
self.pendulum = doublependulum

self.root.wm_title ("Double Pendulum")
self.create_slider_status_frame ()
self.create_button_frame ()
self.create_grid ()
self.update_labels ()
tk.mainloop ()

def create_slider_status_frame (auto):
self.sliders_status_frame = tk.Frame (self.root)
sliders_frame = tk.Frame (self.sliders_status_frame)
sliders = {gravity: {& # 39 ;: Gravity & # 39 ;, & # 39; settings & # 39 ;: [0, 30, 1]}, # Settings: [min, max, resolution] # pylint: disable = C0301
"M1": "label:" Bob Mass 1 ", & # 39; settings & # 39 ;: [1, 10, 0.1]}
"M2": "label:" Bob Mass 2 ", & # 39; settings & # 39 ;: [1, 10, 0.1]}
& Lt; & lt; & lt; & lt; Label: Length r1 & # 39; [0.1, 10, 0.1]}
& Lt; l2 & # 39 ;: Label & # 39; Length r2 & # 39 ;, & # 39 ;: settings & # 39 ;: [0.1, 10, 0.1]}
'######################################################################################### [0, 1, 0.1]}
& # 39 ;: {################################################################################### [0, 1, 0.1]}
}

def create_slider (slider_key, slider_params):
_min, _max, _resolution = slider_params['settings']

            slider_frame = tk.Frame (sliders_frame)
label_slider = tk.Label (slider_frame, font = ("TkFixedFont"),
text = f  # {slider_params["label"]: <11s} & # 39;)
slider = tk.Scale (slider_frame, from _ = _ min, to = _max, resolution = _resolution,
orient = tk.HORIZONTAL,
sliderlength = 15,
length = 150,
command = lambda value: self._set_value (value, slider_key))
slider.set (getattr (self.pendulum, slider_key))
label_slider.pack (side = tk.LEFT)
slider.pack (side = tk.LEFT)
slider_frame.pack ()

for the key, slider_params in sliders.items ():
create_slider (key, slider_params)

status_frame = tk.Frame (self.sliders_status_frame)
self.label_status1 = tk.Label (status_frame, font = ("TkFixedFont"),)
self.label_status1.pack (anchor = tk.W)

self.label_status2 = tk.Label (status_frame, font = ("TkFixedFont"),)
self.label_status2.pack (anchor = tk.W)

self.label_status3 = tk.Label (status_frame, font = ("TkFixedFont"),)
self.label_status3.pack (anchor = tk.W)

self.label_status4 = tk.Label (status_frame, font = ("TkFixedFont"),)
self.label_status4.pack (anchor = tk.W)

self.label_status5 = tk.Label (status_frame, font = ("TkFixedFont"),)
self.label_status5.pack (anchor = tk.W)

sliders_frame.pack (anchor = tk.NW)
status_frame.pack (anchor = tk.W)

def update_labels (self):
self.label_status1.config (
text = f # initial  ntheta1: {self.pendulum.angle1_initial: + 3.2f} & # 39;)
self.label_status2.config (
text = f & # 39; theta2 initial: {self.pendulum.angle2_initial: + 3.2f} & # 39;)
self.label_status3.config (
text = f & # 39; time: {self.pendulum.time: + 3.1f} & # 39;)
self.label_status4.config (
text = f & # 39; theta1: {self.pendulum.angle1: + 3.0f} & # 39;)
self.label_status5.config (
text = f & # 39; theta2: {self.pendulum.angle2: + 3.0f} & # 39;)
self.root.after (update_label_interval_ms, self.update_labels)

def create_button_frame (self):
self.buttons_frame = tk.Frame (self.root)

tk.Button (
self.buttons_frame, text = Quit, command = self._quit) .pack (side = tk.LEFT)
tk.Button (
self.buttons_frame, text = "Change color",
command = lambda * args: self._set_colors (* args)). pack (side = tk.LEFT)
tk.Button (
self.buttons_frame, text = "Trace on / off",
command = lambda * args: self._toggle_trace_visible (* args)). pack (side = tk.LEFT)
tk.Button (
self.buttons_frame, text = "Delete trace",
command = lambda * args: self._clear_trace (* args)). pack (side = tk.LEFT)
tk.Button (
self.buttons_frame, text = Start, command = self._start) .pack (side = tk.LEFT)
tk.Button (
self.buttons_frame, text = Stop, command = self._stop) .pack (side = tk.LEFT)

def create_grid (auto):
tk.Grid.rowconfigure (self.root, 0, weight = 1)
tk.Grid.columnconfigure (self.root, 0, weight = 1)
self.sliders_status_frame.grid (
row = 0, column = 0, sticky = tk.NW)
self.cnvs_pendulum.get_tk_widget (). grid (
row = 0, column = 1, rowspan = 1, columnspan = 1, sticky = tk.W + tk.E + tk.N + tk.S)
self.cnvs_graphs.get_tk_widget (). grid (
row = 1, column = 0, rowspan = 1, columnspan = 2, sticky = tk.W + tk.E + tk.N + tk.S)
self.buttons_frame.grid (
row = 2, column = 0, columnspan = 2, sticky = tk.W)

def _quit (auto):
self.pendulum.stop_swing ()
auto.root.after (100, auto.root.quit)
auto.root.after (100, auto.root.destroy)

def _set_colors (auto):
self.pendulum.switch_colors_of_bob ()

def _toggle_trace_visible (self):
self.pendulum.toggle_trace_visible ()

def _clear_trace (auto):
self.pendulum.clear_trace ()

def _set_value (self, value, name):
value = float (value)
print (name, value)

if name == gravity:
self.pendulum.gravity = float (value)

elif name == m1 & # 39 ;:
self.pendulum.m1 = float (value)

elif name == & m2;
self.pendulum.m2 = float (value)

elif name ==> l1 & # 39;
self.pendulum.l1 = float (value)

elif name ==> l2 & # 39 ;:
self.pendulum.l2 = float (value)

elif name == k1 & # 39 ;:
self.pendulum.k1 = float (value)

elif name == & nbsp;
self.pendulum.k2 = float (value)

other:
assert False, wrong key value given: {name} & # 39;

def _start (self):
self.pendulum.start_swing ()

def _stop (auto):
self.pendulum.stop_swing ()


def main (_a1, _a2):
root = tk.Tk ()
MplMap.settings (root, FIG_SIZE_PENDULUM, FIG_SIZE_GRAPHS)
TkHandler (root, MplMap.get_cnvs_pendulum (),
MplMap.get_cnvs_graphs (), DoublePendulum (_a1, _a2))

if __name__ == "__main__":
main_arguments = sys.argv
angle1 = None
angle2 = None

if len (main_arguments) == 3:
try:
angle1 = float (main_arguments[1])
angle2 = float (main_arguments[2])
except ValueError:
print (invalid arguments, refer to default values ​​..)

principal (angle1, angle2)

Viewing the Windows 10 event log in "trace" (real-time) mode in a terminal?

Under Linux, if I want to observe the system log in the terminal in real time, I can use the tail command to exit the / var / log / syslog deposit with the -F or --to follow switch, which "where the output data is added as the file grows", say:

tail -f / var / log / syslog

… or could also use:

dmesg - follow

… or -w, --follow argument for dmesg means "wait for new messages".

In any case, these two applications in this mode usually block the device, and then display the new lines / text messages as you go, until you press Ctrl-C to exit them.

On Windows, I understand that the equivalent of the system log is the event viewer (log), which is a graphical application. After a while, I found https://www.petri.com/command-line-event-log – which says we can use the wevtutil.exe Command-line application to query the Windows event log.

So, I tried this:

C: > wevtutil qe System

… but it simply erases all events, then ends (as if you were calling dmesg on Linux without any arguments).

I looked through the help wevtutil /?, but I do not see any command line arguments that would put wevtutil in "tracking" mode (that is, it blocks the terminal after having emptied all the way to that point, and then prints new events / new lines of text as they are logged).

So, is it possible to get wevtutil to work in follow-up mode, and if so, how? If not, is there another utility I could use that would do the same – flush the Windows system event log to a tracking device?

Real-time display of the stdout shell

I want to see the real time shell stdout, instead of registerin a variable and then display once it's finished.

Example Playbook – test.yml

- name: test of the shell run command
hosts: localhost
connection: local

Tasks:
- name: Runnig Update
shell: apt update

Default output

$ ansible-playbook test.yml

TO PLAY [Testing RUN Shell Command] ************************************************** ************************************************ **

TASK [Gathering Facts] ************************************************** ************************************************ ** **********
D & # 39; agreement: [localhost]

TASK [Runnig Update] ************************************************** ************************************************ ** ************
amended: [localhost]

PLAY RECAP *********************************************** * ************************************************ ** *************************
localhost: ok = 2 changed = 1 inaccessible = 0 failure = 0   

But I want to see how it goes when we launch the apt update in the terminal

$ sudo apt update
Ign: 1 http://dl.google.com/linux/chrome/deb stable InRelease
Hit: 2 http://dl.google.com/linux/chrome/deb Stable version
Hit: 3 http://ppa.launchpad.net/brightbox/ruby-ng/ubuntu Bionic InRelease
Get: 4 http://security.ubuntu.com/ubuntu Bionic-security InRelease [88.7 kB]                                                           
Hit: 6 http://in.archive.ubuntu.com/ubuntu InRelease Bionic
Hit: 7 http://ppa.launchpad.net/canonical-chromium-builds/stage/ubuntu Bionic InRelease
------ EXIT REMOVED ----------

I see that there are already discussions on github and that this is not possible.

Is there a trick to get the output in real time with help ansible callback?

unit – Are real-time flashes calculated for each frame, including those that are not "visible"?

All objects affected by real-time light affect performance when rendered. It does not matter if the light itself is visible by the camera.

By and large, when a mesh is drawing itself, it checks all the nearby lights and performs calculations to get the final colors of the pixels. The lights are too far away and have a reduced range (so they do not affect any visible objects in the camera). They could be optimized or not. I do not know if Unity supports it, and if you can trust it on all platforms. .

The best advice to give is that, if you have a big scene, divide it into sections, disabling sections that leave the screen and allowing others to enter.

Interrupt management in the form of injected calls in real-time applications

I am reading the documentation on the TriCore architecture, developed by Infinion. Part describing the benefits of using it for real-time applications indicates that Interrupts are treated as injected calls and handled in the same way. What are the actual calls injected and how do they differ from interrupts?

Link to the Infineon documentation: https://www.infineon.com/dgdl/TC1_3_ArchOverview_1.pdf?fileId=db3a304312bae05f0112be86204c0111

architecture – RealTime Parallel DSP (Digital Signal Processing) in Java

enter the description of the image here

Hello, I have a DSP project, Multi Thread Standalone, using Java.

I have a sound Recipientit is a unique sensor that transmits data in Wav format. I selected 8KHz for sampling frequency 1 byte per sample, monophonic.

the Distributor it's a thread take the sound and copy to 50 threads.

Each DSP nn it is a thread that performs Resampling to decrement the frequency, and then re-filters and resamples to increment the frequency (each wire involves a large number of operations).
Each filter (DSP Thread) has a different frequency.

the Collector Take the 50 threads signal and compare the output. And put the results in the transmitter.

It is obvious that, for the architecture envisaged for a single machine, these operations could quickly consume the resources of any machine.

Which architecture would you suggest to me?