## polynomials – Term for a convex function & # 39; general & # 39;

Mathworld defines a convex function as

(…) a continuous function whose value at the midpoint of each interval in its domain does not exceed the arithmetic mean of its values ​​at the extremes of the interval.

Is there a name for a function for which the above is true, but only for intervals greater than the value of sone? Maybe something like this:

A < insert-function-name-here > it is a continuous function $$f$$ for which there is such a value of $$p in mathbb {R}$$ such that the value at the midpoint of each interval greater than $$p$$ in the domain of $$f$$ does not exceed the arithmetic mean of its values ​​at the end of the interval.

Specifically, I'm thinking about functions like
$$f (x) = x / 20 – x ^ 2/80 + x ^ 4/20000$$
In the context of optimization. Basically, the functions that go to infinity towards the edges of your domain and have a general "fall" in the middle. The previous function is not convex, but it can be optimized and its (global) minimum can be easily found. $$-f (x)$$ It is also not convex and can not be optimized.

Maybe something like 'broad convex convex & # 39 ;? However, I prefer to use an established term instead of proposing mine.

## man in the middle – mitmproxy: Error starting the proxy server: OSError (98, & # 39; Address already in use & # 39;)

I just installed the mitmproxy tool. I want to run it Once I write: `sudo mitmproxy` I get this error:

Failed to start the proxy server: OSError (98, & # 39; Address already in use & # 39;)

I searched and found some suggestion to change the port by typing: sudo `mitmproxy -p 99999` However, I think this can cause problems for me, as I will do with the manipulation of HTTPS traffic.

Can you help me please to solve the error?

## druid: A & # 39; Attack with melee spells & # 39; use spell or force statistics?

The spell & # 39; Flame Blade & # 39; makes a sword of fire with which you can perform a spell attack melee, but, as a druid with greater wisdom, I would prefer it to be based on that than on my strength, but I'm not sure if I would use my wisdom or strength, considering that it is a & # 39;confused fight spell out attack. So, would you use my wisdom for the blow or my strength? Because I feel that if it is based on strength, there is no real need for the spell for a druid.

## c # – Unit: animation & # 39; Quaternion.RotateTowards & # 39; it is too fast (instantaneous)

I have a 'block' scenario on a hinge & # 39; where I just want it to turn smoothly to the position of a step. I got into this for a day and finally verified that my start and end angles are correct. The problem now is that the rotation animation is instantaneous rather than smooth over time. How can I adjust this so that the rotation takes about 2 seconds? Connect this to the argument & # 39; maxDegreesDelta & # 39; He felt intuitive but did nothing at all:

``````endAngle * Time.deltaTime / 2.0f
``````

See the documentation

The block itself is linked to this vacuum (location of the hinge):

The father of all the hinges is only 10 blocks in a row rotated by $$– arctan { left ( frac {4} {3} right)}$$ (so that's the angle to undo):

Here is the script:

``````using System.Collections;
using System.Collections.Generic;
using UnityEngine;

SpinningPublic class session: MonoBehaviour
{
[SerializeField]
GameObject triggerObj;
bool deactivated = false;
Quaternion startAngle;
Quaternion endAngle;
// Start is called before the first frame update
void Home ()
{
startAngle = transform.localRotation; // Right
Debug.Log (startAngle.eulerAngles);
endAngle = startAngle * Quaternion.Euler (Mathf.Rad2Deg * Mathf.Atan (4.0f / 3.0f), 0,0);
Debug.Log (endAngle.eulerAngles); // FINALLY correct!
}

// The update is called once per frame
Null update ()
{
disabled = GameObject.Find (triggerObj.name) .GetComponentInChildren().disabled;

yes (disabled)
{
gameObject.transform.rotation = Quaternion.RotateTowards (startAngle, endAngle, Time.deltaTime);
}
}
}
``````

## c ++ – Making an example of & # 39; Clean Code & # 39;

I'm a C ++ developer, and recently I started working through Clean code*. Every time I find an example that I think could be improved, I try to redeploy it in C ++.

On pages 28-29 there is an example with a message construction class, which looks like this when implemented in C ++ (namespaces and spaces omitted are included):
.h

``````GuessStatisticsMessage class
{
public:
GuessStatisticsMessage () = default;
~ GuessStatisticsMessage () = default;

std :: string make (candidate char, int count);

private:
void createPluralDependentMessageParts (int count);
void createThereAreManyLetters (int count);
void createThereIsOneLetter ();
void createThereAreNoLetters ();

std :: string number;
std :: string verb;
std :: string pluralModifier;
};

``````

.cpp

``````std :: string GuessStatisticsMessage :: make (candidate char, int count)
{
createPluralDependentMessageParts (count);
return fmt :: format ("There {} {} {} {}", verb, number, candidate, pluralModifier);
}

void GuessStatisticsMessage :: createPluralDependentMessageParts (int count)
{
yes (account == 0) {
createThereAreNoLetters ();
} else if (count == 1) {
createThereIsOneLetter ();
} else {
createThereAreManyLetters (count);
}
}

void GuessStatisticsMessage :: createThereAreManyLetters (int count)
{
verb = "are";
number = std :: to_string (count);
pluralModifier = "s";
}

void GuessStatisticsMessage :: createThereIsOneLetter ()
{
verb = "is";
number = "one";
pluralModifier = "";
}

void GuessStatisticsMessage :: createThereAreNoLetters ()
{
verb = "are";
number = "no";
pluralModifier = "s";
}
``````

In an attempt to make this code more functional, I ended up with the following:
.h

``````class GuessStatisticsMessageAlt
{
public:
GuessStatisticsMessageAlt () = default;
~ GuessStatisticsMessageAlt () = default;

std :: string make (candidate char, int count);

private:
struct MessageComponents
{
std :: string verb;
std :: string number;
std :: string pluralModifier;
};

MessageComponents createPluralDependentMessageParts (int count);
MessageComponents createThereAreManyLetters (int count);
MessageComponents createThereIsOneLetter ();
MessageComponents createThereAreNoLetters ();
};
``````

.cpp

``````std :: string GuessStatisticsMessageAlt :: make (candidate char, int count)
{
auto messageComponents = createPluralDependentMessageParts (count);
returns fmt :: format ("There {} {} {} {}", messageComponents.verb, messageComponents.number,
candidate, messageComponents.pluralModifier);
}

GuessStatisticsMessageAlt :: MessageComponents GuessStatisticsMessageAlt :: createPluralDependentMessageParts (int count)
{
yes (account == 0) {
return createThereAreNoLetters ();
} else if (count == 1) {
returns createThereIsOneLetter ();
} else {
return createThereAreManyLetters (count);
}
}

GuessStatisticsMessageAlt :: MessageComponents GuessStatisticsMessageAlt :: createThereAreManyLetters (int account)
{
return {"are", std :: to_string (count), "s"};
}

GuessStatisticsMessageAlt :: MessageComponents GuessStatisticsMessageAlt :: createThereIsOneLetter ()
{
returns {"is", "one", ""};
}

GuessStatisticsMessageAlt :: MessageComponents GuessStatisticsMessageAlt :: createThereAreNoLetters ()
{
returns {"are", "no", "s"};
}
``````

As at this point there was no real need for a class, I continued, arriving at the final result:
.h

``````std :: string makeGuessStatisticsMessage (char candidate, int count);
``````

.cpp

``````namespace {

struct MessageComponents
{
std :: string verb;
std :: string number;
std :: string pluralModifier;
};

MessageComponents createThereAreManyLetters (int account)
{
return {"are", std :: to_string (count), "s"};
}

MessageComponents createThereIsOneLetter ()
{
returns {"is", "one", ""};
}

MessageComponents createThereAreNoLetters ()
{
returns {"are", "no", "s"};
}

MessageComponents createPluralDependentMessageParts (int count)
{
yes (account == 0) {
return createThereAreNoLetters ();
}
yes no (account == 1) {
returns createThereIsOneLetter ();
}
else {
return createThereAreManyLetters (count);
}
}

}

std :: string makeGuessStatisticsMessage (char candidate, int count)
{
auto messageComponents = createPluralDependentMessageParts (count);
returns fmt :: format ("There {} {} {} {}", messageComponents.verb, messageComponents.number,
candidate, messageComponents.pluralModifier);
}
``````

The point is that I take a little when to apply different programming paradigms and I find it difficult to decide if my reimplementation is really an improvement in this case. In particular, hiding so many things in the anonymous namespace is something that bothers me a bit.

So, the main question is: is this really an improvement? And high school, how can I learn to judge this better?

I hope you do not rely too much on the opinion, since this is a real struggle for me.

* Clean code: An agile software craft manualRobert C. Martin

## In the Gmail Inbox, is there any way to know if I received a message like & # 39; To & # 39; or as & # 39; CC & # 39 ;?

When you look at the list in your Gmail inbox, is there a way to distinguish only the messages that were sent to the inbox as a TO:, and not as DC: or BCC:?

## In Slack, we start a paragraph quoted with & # 39; >>> & # 39 ;. How do we end a paragraph quoted?

In Slack, we start a paragraph quoted with >>>.

Is there any way to finish the paragraph quoted and continue writing more unquoted text in the same message?

## 39 domains for \$ 29, include: SkyTradingnet, OnlineSystemco.uk

The list of domains is for sales.
Price \$ 29 for each one.
Payment: Paypal ,

1. ControlDocumentcom , Register Dynadot.com, LLC, expires on 2020/8
2. DevelopingTocom , Register Dynadot.com, LLC, expires on 2020/8
3. Helping yourcom , Register Dynadot.com, LLC, expires on 2020/8
4. nobzcom , Register Dynadot.com, LLC, expires on 2020/8

39 domains for \$ 29, include: SkyTradingnet, OnlineSystemco.uk

## The character set & # 39; utf8mb4 & # 39; it is not a compiled character set and is not specified in the file & # 39; /usr/share/mysql/charsets/Index.xml&#39;

Complete error

``````The character set & # 39; utf8mb4 & # 39; it is not a compiled character set and is not specified in the file & # 39; /usr/share/mysql/charsets/Index.xml&#39;
InvalidArgumentException: There was a problem connecting to the database: SQLSTATE[HY000] [2019]    Unable to initialize the utf8mb4 character set (path: / usr / share / mysql / charsets /)
``````

`mysql See 14.14 Distrib 5.7.26`

I'm trying to fix this error, but I can not fix it on an active server. I had to go through the procedure of adding the following to the `/usr/share/mysql/charsets/Index.xml` file in a local virtual machine that worked.

``````
Unicode
UTF-8 MB4 Unicode

primary
compiled

binary
compiled

``````

I have restarted mysql a couple of times since I updated this in vain. My database connection is shown as such

``````<? php
\$ db = new PDO ("mysql: host = \$ host; dbname = \$ db; charset = utf8mb4", \$ db_username, \$ db_pass);
``````

And all the variables in my database seem to be verified based on other publications I've seen

my.cnf has the following set also

``````set of characters-server = utf8mb4
collation-server = utf8mb4_unicode_ci
``````