## HeidiSQL, how to export user definition

I am using MariaDB version 10.5.9.0 on Windows version 10.0.19041.928 with HeidiSQL version 11.0.0.5919

I have exported the database structure which includes the tables, stored procedures and data. I also want to export the user I created to access the database.

In HeidiSQL I select the Tools top line menu option, then Export database as SQL, I check the database I want to export in this case called training, in the SQL export tab I check the Drop checkboxes for Database(s) and Table(s), the Data: drop down is set to Insert, Output: is Single.sql file, Filename: is supplied the location and name to export to.

From the mysql schema I check the user table, then I click the Export button.

The SQL file created contains the structure of the user table but no inserts present where as the training database contains all the inserts and the stored procedures. Is there a reason why the user inserts are missing?

I want to use the SQL file as a complete set-up.

## Definition of 1-cell

There are two questions. 2nd question is placed below the image file.

1. I am confused about the definition of 1-cell. My textbook says that for $$n > 0$$, $$n$$-cell is obtained by attaching $$S^n$$ to space $$X$$ with a map $$f: S^{n-1} rightarrow X$$. This makes sense when $$n neq 1$$. However, when I am confused when $$n = 1$$. Take $$X = {x_0}$$ and attach 1-cell to $$X$$. $$S^0 = {a, b}$$, so identify two points on $$S^1$$. The resulting space looks like $$S^1 wedge S^1$$. Is this the correct interpretation?
1. How would I describe a straight line segment (with two endpoints included) in the language of cell-complex?

## Replacing variable in function definition

I would like to have a series of functions that depend one another, indexed by a number, and that are defined via a Do loop. However, Mathematica seems unable to replace the index in the loop. My trial code:

``````Do(
If(i == 1,
ff(i, x_, y_) := x + y;,
ff(i, x_, y_) := (x - y)*ff(i - 1, x, y);
);
, {i, 1, 2});
ff(2, x, y)
``````

Output:
(x – y) ff(-1 + i, x, y)

Desired output is however:
(x – y)(x + y)

This thing surprises me since if I manually define

``````ff(2, x_, y_) := (x - y)*ff(1, x, y);
``````

then I get the desired output. It seems that the Do loop is not replacing inside the function.

Is this normal? 😮

## scrum – Agile is said to be iterative-incremental, but where is this “revisiting” and “refining” if we follow Definition of Done?

First of all, I found it a bit strange because technically, iterative means something that is done as a recurring series of steps – so how can one be purely incremental, when each increment will be implemented through the same series of steps?

Anyway, my main confusion stems from the word “iterative” – if the meaning is enahnced to mean “refining and revising work”, where does it fit in the classical story development scenario: you develop story B, and once it passes the tests and meets your DoD and Acceptance criteria, it is Done. You added it on the top of the existing baseline. In the mean time, some other stories are finished, ideally Done and hence certainly not meant to be refined or reworked…
Where is the iterativeness?

So, to me it does not seem different from the decades old incremental models (which some claim are examples of Agile models, some say they are not). Just developing features one by one, with early testing and frequent delivery of working increments.

## calculus – Definition of \$int_{-infty}^{+infty}f(x),dx\$

By definition $$int_{-infty}^{+infty}f(x),dx = lim_{{A^prime}rightarrow-infty, {A^{primeprime}}rightarrow+infty} int_{A^prime}^{A^{primeprime}} f(x),dx$$ where $$A^prime, A^{primeprime}$$ are independent. The question is, why can’t they depend on a single $$epsilon rightarrow +infty$$?

## lambda calculus – Is this definition of \$alpha\$-equivalence correct?

I want to extend $$alpha$$-equivalence to cover substitution.

That is, I will implement `runSubst_Term : Subst -> Tm -> Tm` and prove:

``````  Theorem runSubst_Term_main_property :
forall sub : Subst,
forall tm : Tm,
AlphaSubst sub tm (runSubst_Term sub tm).
``````

where the definitions of `Subst`, `Tm`, `AlphaSubst` are below.

But I don’t sure that `AlphaEquiv` is a correct $$alpha$$-equivalence relation.

So it would be appreciated if you could check that the definition is correct.

``````  Definition IVar : Set :=
nat
.
Inductive Tm : Set :=
| Var : forall iv : IVar, Tm
| App : forall tm1 : Tm, forall tm2 : Tm, Tm
| Abs : forall iv : IVar, forall tm1 : Tm, Tm
.
Fixpoint runSubst_Var (sub : Subst) (iv0 : IVar) : Tm :=
match sub with
| () => Var iv0
| (iv, tm) :: sub' =>
if Nat.eq_dec iv iv0
then tm
else runSubst_Var sub' iv0
end
.
Inductive AlphaSubst : Subst -> Tm -> Tm -> Prop :=
| AlphaSubstVar :
forall sub : Subst,
forall iv : IVar,
forall tm : Tm,
runSubst_Var sub iv = tm ->
AlphaSubst sub (Var iv) tm
| AlphaSubstApp :
forall sub : Subst,
forall tm1_1 : Tm,
forall tm1_2 : Tm,
forall tm2_1 : Tm,
forall tm2_2 : Tm,
AlphaSubst sub tm1_1 tm2_1 ->
AlphaSubst sub tm1_2 tm2_2 ->
AlphaSubst sub (App tm1_1 tm1_2) (App tm2_1 tm2_2)
| AlphaSubstAbs :
forall sub : Subst,
forall iv1 : IVar,
forall iv2 : IVar,
forall tm1 : Tm,
forall tm2 : Tm,
AlphaSubst ((iv1, Var iv2) :: sub) tm1 tm2 ->
AlphaSubst sub (Abs iv1 tm1) (Abs iv2 tm2)
.
Definition AlphaEquiv (tm1 : Tm) (tm2 : Tm) : Prop :=
AlphaSubst () tm1 tm2
.
``````

## expression manipulation – Display function definition when function has list argument

(MMA 11.0.1) I have defined various activation functions, and plotted them using a little helper to put the equation into the plot

``````tanmoid(x_) := tanh(x) sigmoid(x);
``````

This is the helper function

``````fnDef(f_) :=  Block({x}, SymbolName(f) <> " ="  (f(x) // TraditionalForm) /. E -> "e")
``````

(the substition replaces the fancy “e”, which looks like a graphics error, with a plain “e”)

This

``````Block({imSize = 200},
Plot({tanmoid'(x), tanmoid(x)}, {x,-4.2,4.2},
PlotLabel-> Pane(Style(fnDef@tanmoid, Bold, 12), Alignment->Right,ImageSize -> imSize), (* MMA SE  *)
PlotRange->{Automatic, {-1.2,1.2}},
PlotStyle->{{RGBColor(0.58847, 0.22163, 0.16064), Thickness(0.01), Dashing({0.01,0.01})}, {ColorData(97,"ColorList")((1)), Thickness(0.015)}},
BaseStyle->{PrintPrecision->1},
PlotRange->{-1,1},
ImageSize->imSize,
AspectRatio->1,
Ticks->{Range(-4,4), {-1, -0.5, 0.5 ,1}})
)
``````

produces

This is all good – the problem comes when I want to plot (with Plot3d) the softmax activation function defined thus:

``````softmax(x_List) := Table(Exp(x((i)))/Total@Exp@x, {i, 1, Length(x)})
``````

in this instance the helper function fnDef(softmax) does not give me the expression for softmax.

I tried to force a list through but this doesn’t work either:

``````listFnDef(f_) :=  Block({x}, SymbolName(f) <> " ="  (f(List @@ x) // TraditionalForm) /. E -> "e")
``````

Question how can I produce the expression of softmax to use in e.g. a plot label?

## \$A^n\$ space of functions that have \$n-1-\$derivatives absolutely continuous functions – Equivalent definition

I am studying the $$A^n$$ space of functions that have $$n-1-$$derivatives absolutely continuous functions.
By Wiki,

So, $$fin A^niff (fin C^{n-1}text{ and } f^{(n)}text{ integrable })$$, am I right?

Thank you.

## design patterns – Minimal list definition in Rust

As a purely pedagogical exercise, I’ve been trying to use Rust’s (very expressive) type system to define the bare minimum one might expect from an ordinary list type.

While there’s likely a higher-level argument here about mutable vs immutable lists, and how lists should be implemented in Rust, please note that this is purely an educational exercise.

One thing I’ve encountered, is that Rust lends itself to quite some verbosity with respect to the number of different logical blocks of code one might need in order to comply with prevailing conventions. I’m unsure as to whether this is actually true of Rust itself, or due to my own misunderstandings about Rust as a language and as an ecosystem.

`list.rs`:

``````use std::fmt::Debug;
use std::ops::{Index, IndexMut};

pub trait List<T: Sized + Clone + Eq + Debug>:
Eq + Index<usize> + IndexMut<usize> + IntoIterator + Debug
{
type Error;

fn insert(&mut self, pos: usize, elem: T) -> Result<(), Self::Error>;
fn remove(&mut self, pos: usize) -> Result<T, Self::Error>;
fn length(&self) -> usize;
fn contains(&self, elem: T) -> bool;
}
``````

`veclist.rs`:

``````#!(allow(clippy::unit_arg))
use std::cmp::Ordering;
use std::fmt::Debug;
use std::ops::{Index, IndexMut};

use crate::list::List;

#(derive(Clone, Debug, Eq, PartialEq))
pub struct VecList<T: Clone + Debug + Eq> {
pub elems: Vec<T>,
}

impl<T: Clone + Debug + Eq> List<T> for VecList<T> {
type Error = String;

fn insert(&mut self, pos: usize, elem: T) -> Result<(), Self::Error> {
match pos.cmp(&self.elems.len()) {
Ordering::Less => Ok(self.elems.insert(pos, elem)),
Ordering::Equal => Ok(self.elems.push(elem)),
Ordering::Greater => Err("Out of bounds".to_string()),
}
}

fn remove(&mut self, pos: usize) -> Result<T, Self::Error> {
match pos.cmp(&self.elems.len()) {
Ordering::Less => Ok(self.elems.remove(pos)),
_ => Err("Out of bounds".to_string()),
}
}

fn length(&self) -> usize {
self.elems.len()
}

fn contains(&self, elem: T) -> bool {
self.iter().any(|x| x == elem)
}
}

impl<T: Clone + Debug + Eq> VecList<T> {
pub fn iter(&self) -> VecListIterator<T> {
self.into_iter()
}
}

impl<T: Clone + Debug + Eq> Index<usize> for VecList<T> {
type Output = T;

fn index(&self, pos: usize) -> &Self::Output {
&self.elems(pos)
}
}

impl<T: Clone + Debug + Eq> IndexMut<usize> for VecList<T> {
fn index_mut(&mut self, pos: usize) -> &mut Self::Output {
&mut self.elems(pos)
}
}

pub struct VecListIterator<T: Clone + Debug + Eq> {
pos: usize,
list: VecList<T>,
}

impl<T: Clone + Debug + Eq> Iterator for VecListIterator<T> {
type Item = T;

fn next(&mut self) -> Option<Self::Item> {
if self.pos < self.list.length() {
self.pos += 1;
Some(self.list(self.pos - 1).clone())
} else {
None
}
}
}

impl<T: Clone + Debug + Eq> IntoIterator for VecList<T> {
type Item = T;
type IntoIter = VecListIterator<T>;

fn into_iter(self) -> Self::IntoIter {
VecListIterator { pos: 0, list: self }
}
}

impl<T: Clone + Debug + Eq> IntoIterator for &VecList<T> {
type Item = T;
type IntoIter = VecListIterator<T>;

fn into_iter(self) -> Self::IntoIter {
VecListIterator {
pos: 0,
list: self.clone(),
}
}
}

impl<T: Clone + Debug + Eq> IntoIterator for &mut VecList<T> {
type Item = T;
type IntoIter = VecListIterator<T>;

fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
``````

1. Is the definition of the list type, `List<T>`, sensible?
2. Is the implementation of the list type, `VecList<T>`, sensible?
3. Are there any defects in the codebase itself?

## sharepoint foundation – The Execute method of job definition Microsoft.Office.Server.UserProfiles.FeedCacheRepopulationJob threw an exception

Please check the ULS log for more detailed information.

If there is any error message in the ULS log related to “No DNS entries exist for…”, if so, verify that the DNS does not in fact exist and then add the appropriate DNS entry for the server.

Reference: The Execute method of job definition Microsoft.Office.Server. UserProfiles .FeedCacheRepopulationJob threw an exception

If the issue exists, try to remove and re-add the Distributed Cache Service:

``````Stop-SPDistributedCacheServiceInstance
Remove-SPDistributedCacheServiceInstance