Ad5001/LogarithmPlotter
Ad5001/LogarithmPlotter
1
0
Fork 0
Code Issues6 Pull requests Projects Releases Wiki Activity

A lot of changes, starting BODE functions

Browse source
This commit is contained in:
Adsooi 2020-12-22 16:47:48 +01:00
parent 08d52fa371
commit 37c9772e94
8 changed files with 307 additions and 136 deletions

26
qml/js/mathlib.js
View file

@ -19,6 +19,7 @@
.pragma library
.import "expr-eval.js" as ExprEval
.import "utils.js" as Utils
const parser = new ExprEval.Parser()
@ -26,24 +27,6 @@ class Expression {
constructor(expr) {
this.expr = expr
this.calc = parser.parse(expr).simplify()
this.replacements = [
['pi', 'π'],
['inf', '∞'],
['Infinity', '∞'],
[' * ', '×'],
['0×', '0'],
['1×', '1'],
['2×', '2'],
['3×', '3'],
['4×', '4'],
['5×', '5'],
['6×', '6'],
['7×', '7'],
['8×', '8'],
['9×', '9'],
[')×', ')'],
['×(', '('],
]
}
isConstant() {
@ -66,13 +49,12 @@ class Expression {
return this.calc.toString()
}
toString() {
toString(forceSign=false) {
var str = this.calc.toString()
if(str[0] == "(") str = str.substr(1)
if(str[str.length - 1] == ")") str = str.substr(0, str.length - 1)
this.replacements.forEach(function(replacement){
str = str.replace(replacement[0], replacement[1])
})
str = Utils.makeExpressionReadable(str)
if(str[0] != '-' && forceSign) str = '+' + str
return str
}
}

143
qml/js/objects.js
View file

@ -112,18 +112,15 @@ class Point extends DrawableObject {
var pointSize = 8
switch(this.pointStyle) {
case 'dot':
ctx.fillStyle = this.color
ctx.beginPath();
ctx.ellipse(canvasX-pointSize/2, canvasY-pointSize/2, pointSize, pointSize)
ctx.fill();
break;
case 'diagonal cross':
ctx.strokeStyle = this.color
canvas.drawLine(ctx, canvasX-pointSize/2, canvasY-pointSize/2, canvasX+pointSize/2, canvasY+pointSize/2)
canvas.drawLine(ctx, canvasX-pointSize/2, canvasY+pointSize/2, canvasX-pointSize/2, canvasY+pointSize/2)
break;
case 'vertical cross':
ctx.strokeStyle = this.color
canvas.drawLine(ctx, canvasX, canvasY-pointSize/2, canvasX, canvasY+pointSize/2)
canvas.drawLine(ctx, canvasX-pointSize/2, canvasY, canvasX+pointSize/2, canvasY)
break;
@ -131,7 +128,6 @@ class Point extends DrawableObject {
var text = this.getLabel()
ctx.font = "14px sans-serif"
var textSize = ctx.measureText(text).width
ctx.fillStyle = this.color
switch(this.labelPos) {
case 'top':
canvas.drawVisibleText(ctx, text, canvasX-textSize/2, canvasY-16)
@ -178,7 +174,7 @@ class Function extends DrawableObject {
getReadableString() {
if(this.displayMode == 'application') {
return `${this.name}: ${this.inDomain} ⸺˃ ${this.outDomain}\n x ⸺˃ ${this.expression.toString()}`
return `${this.name}: ${this.inDomain} ⸺˃ ${this.outDomain}\n ${' '.repeat(this.name.length)}x ⸺˃ ${this.expression.toString()}`
} else {
return `${this.name}(x) = ${this.expression.toString()}`
}
@ -191,28 +187,11 @@ class Function extends DrawableObject {
}
draw(canvas, ctx) {
ctx.strokeStyle = this.color
ctx.fillStyle = this.color
// Drawing small traits every 2px
var pxprecision = 2
var previousX = canvas.px2x(0)
var previousY = this.expression.evaluate(previousX)
for(var px = pxprecision; px < canvas.canvasSize.width; px += pxprecision) {
var currentX = canvas.px2x(px)
var currentY = this.expression.evaluate(currentX)
if(this.inDomain.includes(currentX) && this.inDomain.includes(previousX) &&
this.outDomain.includes(currentY) && this.outDomain.includes(previousY) &&
Math.abs(previousY-currentY)<100) { // 100 per 2px is a lot (probably inf to inf issue)
canvas.drawLine(ctx, canvas.x2px(previousX), canvas.y2px(previousY), canvas.x2px(currentX), canvas.y2px(currentY))
}
previousX = currentX
previousY = currentY
}
Function.drawFunction(canvas, ctx, this.expression, this.inDomain, this.outDomain)
// Label
var text = this.getLabel()
ctx.font = "14px sans-serif"
var textSize = canvas.measureText(ctx, text)
ctx.fillStyle = this.color
var posX = canvas.x2px(this.labelX)
var posY = canvas.y2px(this.expression.evaluate(this.labelX))
switch(this.labelPos) {
@ -225,11 +204,125 @@ class Function extends DrawableObject {
}
}
static drawFunction(canvas, ctx, expr, inDomain, outDomain) {
// Reusable in other objects.
// Drawing small traits every 2px
var pxprecision = 2
var previousX = canvas.px2x(0)
var previousY = expr.evaluate(previousX)
for(var px = pxprecision; px < canvas.canvasSize.width; px += pxprecision) {
var currentX = canvas.px2x(px)
var currentY = expr.evaluate(currentX)
if(inDomain.includes(currentX) && inDomain.includes(previousX) &&
outDomain.includes(currentY) && outDomain.includes(previousY) &&
Math.abs(previousY-currentY)<100) { // 100 per 2px is a lot (probably inf to inf issue)
canvas.drawLine(ctx, canvas.x2px(previousX), canvas.y2px(previousY), canvas.x2px(currentX), canvas.y2px(currentY))
}
previousX = currentX
previousY = currentY
}
}
}
const drawableTypes = {
class GainBode extends DrawableObject {
static type(){return 'Gain Bode'}
static properties() {return {
'ω_0': 'Point',
'pass': ['high', 'low'],
'gain': 'Expression',
'labelPos': ['above', 'below'],
'labelX': 'number'
}}
constructor(name = null, visible = true, color = null, labelContent = 'name + value',
ω_0 = '', pass = 'high', gain = '20', labelPos = 'above', labelX = 1) {
if(name == null) name = getNewName('G', 'Gain Bode')
if(name == 'G') name = 'G₀' // G is reserved for sum of BODE gains.
super(name, visible, color, labelContent)
if(typeof ω_0 == "string") {
// Point name or create one
ω_0 = getObjectByName('Point', ω_0)
if(ω_0 == null) {
// Create new point
ω_0 = createNewRegisteredObject('Point')
ω_0.name = getNewName('ω', 'Gain Bode')
}
}
console.log(this, ω_0)
this.ω_0 = ω_0
this.pass = pass
if(typeof gain == 'number' || typeof gain == 'string') gain = new MathLib.Expression(gain.toString())
this.gain = gain
this.labelPos = labelPos
this.labelX = labelX
}
getReadableString() {
return `${this.name}: ${this.pass}-pass, ω₀=${this.ω_0.x}, ${this.gain.toString(true)} dB/dec.`
}
export() {
return [this.name, this.visible, this.color.toString(), this.labelContent,
this.ω_0.name, this.pass.toString(), this.gain.toEditableString(), this.labelPos, this.labelX]
}
draw(canvas, ctx) {
var base = [canvas.x2px(this.ω_0.x), canvas.y2px(this.ω_0.y)]
var dbfn = new MathLib.Expression(`${this.gain.evaluate()}*(ln(x)-ln(${this.ω_0.x}))/ln(10)+${this.ω_0.y}`)
var inDrawDom = new MathLib.EmptySet()
if(this.pass == 'high') {
// High pass, linear line from begining, then constant to the end.
canvas.drawLine(ctx, base[0], base[1], canvas.canvasSize.width, base[1])
inDrawDom = MathLib.parseDomain(`]-inf;${this.ω_0.x}[`)
} else {
// Low pass, constant from the beginning, linear line to the end.
canvas.drawLine(ctx, base[0], base[1], 0, base[1])
inDrawDom = MathLib.parseDomain(`]${this.ω_0.x};+inf[`)
}
Function.drawFunction(canvas, ctx, dbfn, inDrawDom, MathLib.Domain.R)
}
}
const types = {
'Point': Point,
'Function': Function
'Function': Function,
'Gain Bode': GainBode,
}
var currentObjects = {}
function getObjectByName(objType, objName) {
if(currentObjects[objType] == undefined) return null
var retObj = null
currentObjects[objType].forEach(function(obj){
if(obj.name == objName) retObj = obj
})
return retObj
}
function getObjectsName(objType) {
if(currentObjects[objType] == undefined) return []
return currentObjects[objType].map(function(obj) {
return obj.name
})
}
function createNewRegisteredObject(objType) {
if(Object.keys(types).indexOf(objType) == -1) return null // Object type does not exist.
var newobj = new types[objType]()
if(Object.keys(currentObjects).indexOf(objType) == -1) {
currentObjects[objType] = []
}
currentObjects[objType].push(newobj)
return newobj
}
var points = [new Point()]
var f = new Function();
f.point = points[0]
points[0].name = 'B'
points[0].x = 2
f.point.x = 4
console.log(points[0].name, f.point.name, points[0].x, f.point.x)

86
qml/js/utils.js
View file

@ -16,6 +16,8 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
.pragma library
var powerpos = {
"-": "⁻",
"0": "⁰",
@ -116,3 +118,87 @@ function textsub(text) {
}
return ret
}
function makeExpressionReadable(str) {
var replacements = [
[/pi/g, 'π'],
[/Infinity/g, '∞'],
[/inf/g, '∞'],
[/ \* /g, '×'],
[/ \^ /g, '^'],
[/\^\(([^\^]+)\)/g, function(match, p1) { return textsup(p1) }],
[/\^([^ ]+)/g, function(match, p1) { return textsup(p1) }],
[/(\d|\))×/g, '$1'],
[/×(\d|\()/g, '$1'],
[/\(([^)(+.-]+)\)/g, "$1"],
[/\(([^)(+.-]+)\)/g, "$1"],
[/\(([^)(+.-]+)\)/g, "$1"],
[/\(([^)(+.-]+)\)/g, "$1"],
[/\(([^)(+.-]+)\)/g, "$1"],
// Doing it 4 times to be recursive until better implementation
]
// Replacements
replacements.forEach(function(replacement){
str = str.replace(replacement[0], replacement[1])
})
return str
}
function parseName(str, removeUnallowed = true) {
var replacements = [
// Greek letters
[/(\s|^)al(pha)?[^a-z]/g, 'α'],
[/(\s|^)be(ta)?[^a-z]/g, 'β'],
[/(\s|^)ga(mma)?[^a-z]/g, 'γ'],
[/(\s|^)de(lta)?[^a-z]/g, 'δ'],
[/(\s|^)ep(silon)?[^a-z]/g, 'ε'],
[/(\s|^)ze(ta)?[^a-z]/g, 'ζ'],
[/(\s|^)et(a)?[^a-z]/g, 'η'],
[/(\s|^)th(eta)?[^a-z]/g, 'θ'],
[/(\s|^)io(ta)?[^a-z]/g, 'ι'],
[/(\s|^)ka(ppa)[^a-z]?/g, 'κ'],
[/(\s|^)la(mbda)?[^a-z]/g, 'λ'],
[/(\s|^)mu[^a-z]/g, 'μ'],
[/(\s|^)nu[^a-z]/g, 'ν'],
[/(\s|^)xi[^a-z]/g, 'ξ'],
[/(\s|^)rh(o)?[^a-z]/g, 'ρ'],
[/(\s|^)si(gma)?[^a-z]/g, 'σ'],
[/(\s|^)ta(u)?[^a-z]/g, 'τ'],
[/(\s|^)up(silon)?[^a-z]/g, 'υ'],
[/(\s|^)ph(i)?[^a-z]/g, 'φ'],
[/(\s|^)ch(i)?[^a-z]/g, 'χ'],
[/(\s|^)ps(i)?[^a-z]/g, 'ψ'],
[/(\s|^)om(ega)?[^a-z]/g, 'ω'],
// Capital greek letters
[/(\s|^)gga(mma)?[^a-z]/g, 'Γ'],
[/(\s|^)gde(lta)?[^a-z]/g, 'Δ'],
[/(\s|^)gth(eta)?[^a-z]/g, 'Θ'],
[/(\s|^)gla(mbda)?[^a-z]/g, 'Λ'],
[/(\s|^)gxi[^a-z]/g, 'Ξ'],
[/(\s|^)gpi[^a-z]/g, 'Π'],
[/(\s|^)gsi(gma)[^a-z]?/g, 'Σ'],
[/(\s|^)gph(i)?[^a-z]/g, 'Φ'],
[/(\s|^)gps(i)?[^a-z]/g, 'Ψ'],
[/(\s|^)gom(ega)?[^a-z]/g, 'Ω'],
// Underscores
[/_\(([^\^]+)\)/g, function(match, p1) { return textsub(p1) }],
[/_([^ ]+)/g, function(match, p1) { return textsub(p1) }],
// Removing
[/[xπℝℕ\\∪∩\]\[ ()^/÷*×+=\d-]/g , function(match){console.log('removing', match); return ''}],
]
if(!removeUnallowed) replacements.pop()
// Replacements
replacements.forEach(function(replacement){
str = str.replace(replacement[0], replacement[1])
})
return str
}
String.prototype.toLatinUppercase = function() {
return this.replace(/[a-z]/g, function(match){return match.toUpperCase()})
}
function camelCase2readable(label) {
var parsed = parseName(label, false)
return parsed.charAt(0).toLatinUppercase() + parsed.slice(1).replace(/([A-Z])/g," $1")
}